fastmcp 3.4.9

Source: https://github.com/PrefectHQ/fastmcp
Tag scanned: v3.4.9
Compared with: v3.4.8 (0 signals introduced since)
Files: 853 scanned, 390 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 18 info
Scan time: 14.2 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-16 21:41

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.92 compile() on generated code in a syntax-validity test.
Reasoning
Test helper compiles generated source only to check it is valid Python syntax. The argument is output of the generator under test, not untrusted input, and nothing is executed.
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.92 compile() on generated source in a test asserting it compiles.
Reasoning
Same pattern as the other compile checks in this file: the generated source is compiled to assert it is syntactically valid, 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.92 compile() of generated code to verify syntax in a test.
Reasoning
Compile-only syntax check on generator output inside a unit test. Not an obfuscation or dropper pattern.
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.92 compile() on generated code to check it parses.
Reasoning
Syntax validation of generated output in a test with a complex type default. Benign test scaffolding.
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.92 compile() of generated source in a collision-detection test.
Reasoning
Compile check on generator output in a name-collision test. The flagged call is only a syntax check.
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.92 compile() of a generated script in a tool-function test.
Reasoning
Test confirms generated script compiles. The script comes from the code generator under test and is never run.
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.92 compile() on generated script before asserting its contents.
Reasoning
Compile-only validation of generated script, followed by string assertions. No runtime execution of untrusted content.
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.92 compile() on generated script to test quote escaping.
Reasoning
Checks that a generated script with escaped quotes compiles. Test-only syntax validation.
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.92 compile() of generated script in a transport test.
Reasoning
Compile check of generated stdio-transport script in a test. Benign.
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.92 compile() on generated script in a test.
Reasoning
Syntax check of generator output in the test suite. No execution of untrusted code.
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 compile() of an output file read back in a test.
Reasoning
Compiles the file the generator wrote to disk, to confirm it is valid Python. Test-only check, not execution.
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=="
)
```
dismissed LLM, confidence 0.90 Base64 constant encoding a small PNG image in a conformance server.
Reasoning
The string is a base64-encoded PNG header and image data, a typical embedded test image. The raw pass flags it as an encoded blob, which is a known false-positive pattern for raw findings.
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.85 __import__ of module names parsed from doc examples to verify they resolve.
Reasoning
Checks whether modules imported in documentation examples are importable, reporting ImportError as a test error. The module names come from the repo's own docs.
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.85 __import__ of a from-import module during doc example validation.
Reasoning
Dynamic import of a module name taken from a documentation example's AST, with ImportError collected as a test failure. Benign doc-validation logic.
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.80 exec() of a test-wrapped snippet in a code-mode transform test.
Reasoning
Executes wrapped test code in an explicit namespace to exercise the code-mode transform. This is the feature under test, run in a test process with the test's own inputs.
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.80 exec() of a wrapped test snippet in code-mode discovery tests.
Reasoning
Same pattern as the code-mode test: exec of a test-generated wrapper to validate discovery behavior. Expected for this kind of test harness.
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.97 A test fixture embedding a tiny PNG image as a bytes literal.
Reasoning
The bytes literal is a hand-written 1x1 white PNG with the standard PNG signature, IHDR and IEND chunks, in a test file that builds an Image object. The escapes are the normal way to express binary test data in Python; there is no execution or exfiltration.
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.97 A test data URI containing a base64-encoded PNG image.
Reasoning
The base64 string is a standard data URI for a small PNG image used as test input for a FastMCP server. It is a benign image payload in a test file, and no decoding or execution follows in the snippet.

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.9
disclude scan --severity info --diff v3.4.8 .