PyPI / fastmcp / 3.4.11

fastmcp 3.4.11

Source

https://github.com/PrefectHQ/fastmcp

Tag scanned

v3.4.11

Compared with

v3.4.10 (0 signals introduced since)

Files

854 scanned, 390 skipped (binary, oversized, or unrecognised)

Signals

0 critical · 0 warn · 18 info

Scan time

15.1 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:26

Signals

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

1. 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 Test asserts that generated Python source compiles.

   Reasoning

   compile() is applied to generated source inside a test to check that it is syntactically valid. The call does not execute the code and has no obfuscation or malicious indicators.

2. 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 Test compiles generated source to check for syntax errors.

   Reasoning

   Same pattern as the other generator tests: compile() checks syntax of generated source in a test. Nothing suggests malicious intent.

3. 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 Test compiles generated source to validate syntax.

   Reasoning

   compile() on generated source in a unit test, used only as a syntax check alongside string assertions.

4. 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 Test compiles generated source for syntax validation.

   Reasoning

   compile() on generated output in a test; it validates the generator's output and does not execute it.

5. 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 Test compiles generated source for syntax validation.

   Reasoning

   compile() on generated output in a test with string assertions. It is a syntax check, not dynamic execution of untrusted input.

6. 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 Test compiles a generated script to ensure it is valid.

   Reasoning

   compile() of a generated script inside a test. The result is only checked for syntax errors.

7. 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 Test compiles generated script and asserts on its content.

   Reasoning

   Generated script is compiled in a test and then checked for expected strings. This is ordinary test verification.

8. 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 Test checks that generated script with escaped quotes compiles.

   Reasoning

   compile() validates that the generated app name with escaped quotes produces valid syntax. This is an expected test for escaping behavior.

9. 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 Test compiles generated script for stdio transport.

   Reasoning

   Generated script compile in a stdio transport test. It is a syntax check only.

10. 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 Test compiles generated script to verify syntax.

    Reasoning

    Syntax check of generated script in a test. No execution of untrusted content or obfuscation.

11. 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 to verify it is valid Python.

    Reasoning

    compile() on the content of an output file the test just generated. It verifies syntax and does not execute the code.

12. 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 Embedded base64 PNG image data in a conformance test server.

    Reasoning

    The snippet is a base64 PNG image literal (PNG header and IDAT-like data) in a conformance test server. Raw pass base64 heuristics commonly flag embedded image fixtures. It is not an encoded payload.

13. 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 Test checks that imports in doc examples resolve, using __import__ on parsed names.

    Reasoning

    __import__ is called on alias names parsed from documentation code examples to check that they import. The module names come from the repo's own docs inside a test, so this is a verification pattern rather than a dropper.

14. 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 Test imports modules referenced in doc examples to validate them.

    Reasoning

    Dynamic import of node.module parsed from doc examples, wrapped in try/except ImportError to collect errors. This is a doc-validation test on repo content.

15. 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 Test executes a wrapped code snippet in an isolated namespace to exercise code mode.

    Reasoning

    exec runs a wrapper built by the test to exercise the code-mode transform. The code is test-authored and the namespace is local. This is expected for testing an execution feature, though exec is inherently sensitive.

16. 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 Test executes a wrapped snippet to exercise code-mode discovery.

    Reasoning

    Same pattern as test_code_mode: exec of a test-constructed wrapper in a local namespace to test discovery behavior. No sign of hidden or malicious payloads.

17. 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 bytes literal.

    Reasoning

    The bytes literal is a genuine 1x1 white PNG file (PNG signature, IHDR, IDAT, IEND chunks), built in a test to exercise Image handling. The escapes are just how raw binary is written in Python source; there is no execution, decoding, or network activity. The comment states its purpose.

18. 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 base64-encoded PNG data URI used as test input for icon handling.

    Reasoning

    The string is a standard data URI for a tiny PNG image used as a test fixture for a FastMCP server's icon handling. It is only assigned to a variable and passed around as data, not decoded and executed. Base64 image data in tests is ordinary and expected.

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.11
disclude scan --severity info --diff v3.4.10 .