fastmcp 3.4.10

Source: https://github.com/PrefectHQ/fastmcp
Tag scanned: v3.4.10
Compared with: v3.4.9 (0 signals introduced since)
Files: 854 scanned, 390 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 18 info
Scan time: 14.6 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 18 of 18 warn and critical signals; 18 demoted to info.
Disclude version: 4.0.0
Scanned (UTC): 2026-10-21 05:25

Signals

Ordered by severity, then signals introduced in this release. Hidden characters are shown as ⟨U+…⟩.

info ~~warn~~ → info by review dynamic-execution tests/cli/test_generate_cli.py:265:9

`compile` called on a non-literal expression (ast pass, confidence 0.70)
```
        # Generated code should compile
        compile(source, "<test>", "exec")

    def test_array_of_strings_parameter(self):
```
likely benign LLM, confidence 0.90 Test asserts that generated code compiles.
Reasoning
compile() is applied to source produced by the code generator under test, as a syntax check. It only compiles and never executes, and this is a test file.
info ~~warn~~ → info by review dynamic-execution tests/cli/test_generate_cli.py:285:9

`compile` called on a non-literal expression (ast pass, confidence 0.70)
```
        assert "json.loads" not in source
        compile(source, "<test>", "exec")

    def test_complex_object_parameter(self):
```
likely benign LLM, confidence 0.90 Test compiles generated source to check for syntax errors.
Reasoning
Same pattern: compile() on generated source as a syntax check inside a test, with no execution.
info ~~warn~~ → info by review dynamic-execution tests/cli/test_generate_cli.py:318:9

`compile` called on a non-literal expression (ast pass, confidence 0.70)
```
        assert "'metadata': metadata_parsed" in source
        compile(source, "<test>", "exec")

    def test_nested_array_parameter(self):
```
likely benign LLM, confidence 0.90 Test compiles generated source after asserting on its contents.
Reasoning
compile() on generator output in a test; the surrounding asserts check the generated text. Compile-only, no execution.
info ~~warn~~ → info by review dynamic-execution tests/cli/test_generate_cli.py:345:9

`compile` called on a non-literal expression (ast pass, confidence 0.70)
```
        )
        compile(source, "<test>", "exec")

    def test_complex_type_with_default(self):
```
likely benign LLM, confidence 0.90 Test compiles generated code with a complex type default.
Reasoning
compile() on generator output in a unit test as a syntax check. No execution occurs.
info ~~warn~~ → info by review dynamic-execution tests/cli/test_generate_cli.py:366:9

`compile` called on a non-literal expression (ast pass, confidence 0.70)
```
        assert "isinstance(options, str)" in source
        compile(source, "<test>", "exec")

    def test_name_collision_detection(self):
```
likely benign LLM, confidence 0.90 Test compiles generated code for name-collision handling.
Reasoning
compile() on generated code in a test, a standard syntax validation step.
info ~~warn~~ → info by review dynamic-execution tests/cli/test_generate_cli.py:445:9

`compile` called on a non-literal expression (ast pass, confidence 0.70)
```
        )
        compile(script, "<generated>", "exec")

    def test_contains_tool_functions(self):
```
likely benign LLM, confidence 0.90 Test compiles generated tool script.
Reasoning
compile() on a script produced by the generator under test. Compile-only validation inside a test.
info ~~warn~~ → info by review dynamic-execution tests/cli/test_generate_cli.py:491:9

`compile` called on a non-literal expression (ast pass, confidence 0.70)
```
        )
        compile(script, "<generated>", "exec")
        assert "call_tool_app" in script
```
likely benign LLM, confidence 0.90 Test compiles generated server script.
Reasoning
compile() on generated script as a syntax check in a test file, with no execution.
info ~~warn~~ → info by review dynamic-execution tests/cli/test_generate_cli.py:504:9

`compile` called on a non-literal expression (ast pass, confidence 0.70)
```
        # Should compile without syntax errors
        compile(script, "<generated>", "exec")
        # App name should have escaped quotes
        assert r'app = cyclopts.App(name="test-\"server\"-name"' in script
```
likely benign LLM, confidence 0.90 Test checks generated app name escaping compiles.
Reasoning
compile() validates generated output containing escaped quotes; no execution, test context.
info ~~warn~~ → info by review dynamic-execution tests/cli/test_generate_cli.py:528:9

`compile` called on a non-literal expression (ast pass, confidence 0.70)
```
        )
        compile(script, "<generated>", "exec")

    def test_compiles_with_stdio_transport(self):
```
likely benign LLM, confidence 0.90 Test compiles generated stdio transport script.
Reasoning
compile() on generator output in a test for stdio transport. Compile-only.
info ~~warn~~ → info by review dynamic-execution tests/cli/test_generate_cli.py:540:9

`compile` called on a non-literal expression (ast pass, confidence 0.70)
```
        )
        compile(script, "<generated>", "exec")
```
likely benign LLM, confidence 0.90 Test compiles generated script.
Reasoning
compile() on generator output as a syntax check in a test.
info ~~warn~~ → info by review dynamic-execution tests/cli/test_generate_cli.py:600:9

`compile` called on a non-literal expression (ast pass, confidence 0.70)
```
        content = output.read_text()
        compile(content, str(output), "exec")

    @pytest.mark.usefixtures("_patch_client")
```
likely benign LLM, confidence 0.90 Test compiles generated output file.
Reasoning
compile() on generated file contents read back from a test output path. Syntax check only.
info ~~warn~~ → info by review encoding-base64 tests/conformance/server.py:27:6

base64-like blob (40 bytes, compression ratio 1.27) (raw pass, confidence 0.60)
```
    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR4"
    "nGP4z8BQDwAEgAF/pooBPQAAAABJRU5ErkJggg=="
)
```
likely benign LLM, confidence 0.90 Base64-encoded PNG image literal in a conformance test server.
Reasoning
The blob is a base64-encoded 1x1 PNG image constant, a normal test fixture. The payload is a valid image header and is not hiding executable content.
info ~~critical~~ → info by review dynamic-import tests/docs/test_doc_examples.py:79:25

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
                    try:
                        __import__(alias.name)
                    except ImportError:
                        errors.append(
```
likely benign LLM, confidence 0.80 Doc-example test checks that imported modules resolve via __import__.
Reasoning
__import__ is called on module names parsed from the repository's own documentation to check that doc examples import successfully. The inputs are not attacker-controlled and this is a test utility.
info ~~critical~~ → info by review dynamic-import tests/docs/test_doc_examples.py:88:27

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
                try:
                    mod = __import__(node.module, fromlist=names)
                except ImportError:
                    errors.append(
```
likely benign LLM, confidence 0.80 Doc-example test dynamically imports a module named in docs.
Reasoning
Dynamic import of a module name taken from repository docs during a test; it only verifies importability and errors are collected.
info ~~warn~~ → info by review dynamic-execution tests/experimental/transforms/test_code_mode.py:112:9

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
        exec(wrapped, namespace, namespace)
        return await namespace["__test_main__"]()
```
likely benign LLM, confidence 0.75 Test executes a wrapped test main function via exec in a namespace.
Reasoning
exec runs wrapped code built by the test fixture inside an isolated namespace to exercise the code-mode transform. The code is test-authored, not external input, though exec is a sensitive pattern.
info ~~warn~~ → info by review dynamic-execution tests/experimental/transforms/test_code_mode_discovery.py:76:9

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
        exec(wrapped, namespace, namespace)
        return await namespace["__test_main__"]()
```
likely benign LLM, confidence 0.75 Discovery test executes wrapped test code via exec.
Reasoning
Same pattern as the sibling code-mode test: exec of test-authored wrapped code in a namespace to exercise discovery behavior.
info ~~warn~~ → info by review payload-bytes-literal tests/tools/test_tool_future_annotations.py:48:16

bytes literal contains 41 `\xNN` escapes (85% of content) — binary payload shape (ast pass, confidence 0.85)
```
    # Create a simple 1x1 white pixel PNG
    png_data = b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x02\x00\x00\x00\x90wS\xde\x00\x00\x00\x0cIDATx\x9cc\xf8\x0f\x00\x00\x01\x01\x00\x05\x18\xd4c\x00\x00\x00\x00IEND\xaeB`\x82"
    return Image(data=png_data, format="png")
```
likely benign LLM, confidence 0.95 A test fixture embedding a tiny PNG image as a Python bytes literal passed to an Image constructor.
Reasoning
The bytes literal is a complete 1x1 white PNG file (PNG signature, IHDR, IDAT, IEND chunks) and the preceding comment says it creates a 1x1 white pixel PNG for an Image test. The escape-heavy form is just how raw binary is written in a Python bytes literal; it is test fixture data with no execution or exfiltration behavior.
info ~~warn~~ → info by review encoding-base64 tests/utilities/test_inspect_icons.py:244:43

base64-like blob (96 bytes, compression ratio 1.00) (raw pass, confidence 0.60)
```
        data_uri = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="

        mcp = FastMCP("DataURIServer")
```
likely benign LLM, confidence 0.95 A test data URI containing a small base64-encoded PNG image for an icon-inspection test.
Reasoning
The base64 string is a standard PNG data URI used as a test input for a FastMCP server named DataURIServer. It is a small image payload in a test file, with no decoding into executable content or any suspicious use shown. The raw-pass base64 signal is a known false positive for embedded image data.

Reproduce This Scan

Run disclude locally to verify. Add --format sarif for SARIF output. Add --llm (with an API key in the environment) to include the LLM review.

cargo install disclude --version 4.0.0
git clone https://github.com/PrefectHQ/fastmcp fastmcp && cd fastmcp
git checkout v3.4.10
disclude scan --severity info --diff v3.4.9 .