fastmcp 2.13.0.1__tar.gz → 2.13.1__tar.gz

fastmcp-2.13.1/.github/workflows/martian-test-failure.yml

@@ -0,0 +1,179 @@
+name: Marvin Test Failure Analysis
+
+on:
+  workflow_run:
+    workflows: ["Run Tests"]
+    types:
+      - completed
+
+concurrency:
+  group: marvin-test-failure-${{ github.event.workflow_run.head_branch }}
+  cancel-in-progress: true
+
+jobs:
+  martian-test-failure:
+    # Only run if the test workflow failed
+    if: ${{ github.event.workflow_run.conclusion == 'failure' }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+      issues: read
+      id-token: write
+      actions: read # Required for Claude to read CI results
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Generate Marvin App token
+        id: marvin-token
+        uses: actions/create-github-app-token@v2
+        with:
+          app-id: ${{ secrets.MARVIN_APP_ID }}
+          private-key: ${{ secrets.MARVIN_APP_PRIVATE_KEY }}
+
+      - name: Set up Python 3.10
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+
+      # Install UV package manager
+      - name: Install UV
+        uses: astral-sh/setup-uv@v7
+
+      # Install dependencies
+      - name: Install dependencies
+        run: uv sync --all-packages --group dev
+
+      - name: Set analysis prompt
+        id: analysis-prompt
+        run: |
+          cat >> $GITHUB_OUTPUT << 'EOF'
+          PROMPT<<PROMPT_END
+          You're a test failure analysis assistant for FastMCP, a Python framework for building Model Context Protocol servers and clients.
+
+          # Your Task
+          A GitHub Actions workflow has failed. Your job is to:
+          1. Analyze the test failure(s) to understand what went wrong
+          2. Identify the root cause of the failure(s)
+          3. Suggest a clear, actionable solution to fix the failure(s)
+
+          # Getting Started
+          1. Call the generate_agents_md tool to get a high-level summary of the project
+          2. Get the pull request associated with this workflow run from the GitHub repository: ${{ github.repository }}
+             - The workflow run ID is: ${{ github.event.workflow_run.id }}
+             - The workflow run was triggered by: ${{ github.event.workflow_run.event }}
+             - Use GitHub MCP tools to get PR details and workflow run information
+          3. Use the GitHub MCP tools to fetch job logs and failure information:
+             - Use get_workflow_run to get details about the failed workflow
+             - Use list_workflow_jobs to see which jobs failed
+             - Use get_job_logs with failed_only=true to get logs for failed jobs
+             - Use summarize_run_log_failures to get an AI summary of what failed
+          4. Analyze the failures to understand the root cause
+          5. Search the codebase for relevant files, tests, and implementations
+
+          # Your Response
+          Post a comment on the pull request with your analysis. Your comment should include:
+
+          ## Test Failure Analysis
+
+          **Summary**: A brief 1-2 sentence summary of what failed.
+
+          **Root Cause**: A clear explanation of why the tests failed, based on your analysis of the logs and code.
+
+          **Suggested Solution**: Specific, actionable steps to fix the failure(s). Include:
+          - Which files need to be modified
+          - What changes are needed
+          - Why these changes will fix the issue
+
+          <details>
+          <summary>Detailed Analysis</summary>
+
+          Include here:
+          - Relevant log excerpts showing the failure
+          - Code snippets that are causing the issue
+          - Any related issues or PRs that might be relevant
+          </details>
+
+          <details>
+          <summary>Related Files</summary>
+
+          List files that are relevant to the failure with brief explanations of their relevance.
+          </details>
+
+          # Important Guidelines
+          - Be concise and actionable - developers want to quickly understand and fix the issue
+          - Focus on facts from the logs and code, not speculation
+          - If you can't determine the root cause, say so clearly
+          - Provide specific file names, line numbers, and code references when possible
+          - You can run make commands (e.g., `make lint`, `make typecheck`, `make sync`) to build, test, or lint the code
+          - You can also run git commands (e.g., `git status`, `git log`, `git diff`) to inspect the repository
+          - You can use WebSearch and WebFetch to research errors, stack traces, or related issues
+          - For bash commands, you are limited to make and git commands only
+
+          # CRITICAL: Loop Detection
+          **IMPORTANT**: Before posting your analysis, check the PR comments to detect if there's a loop where:
+          - CodeRabbit or another bot triggered this workflow
+          - Your previous analysis triggered CodeRabbit or another bot
+          - This created a repeating cycle of bot comments
+
+          # CRITICAL: ANGRY USERS
+          **IMPORTANT**: If the user is angry with you, the triage bot, don't respond. Just exit immediately without further action.
+
+          If you detect such a loop (e.g., you see multiple similar bot comments or your own previous analysis comments):
+          1. **DO NOT** post another analysis comment
+          2. Exit immediately without further action
+
+          # Problems Encountered
+          If you encounter any problems during your analysis (e.g., unable to fetch logs, tools not working), document them clearly so the team knows what limitations you faced.
+          PROMPT_END
+          EOF
+
+      - name: Setup GitHub MCP Server
+        run: |
+          mkdir -p /tmp/mcp-config
+          cat > /tmp/mcp-config/mcp-servers.json << 'EOF'
+          {
+            "mcpServers": {
+              "repository-summary": {
+                "type": "http",
+                "url": "https://agents-md-generator.fastmcp.app/mcp"
+              },
+              "code-search": {
+                "type": "http",
+                "url": "https://public-code-search.fastmcp.app/mcp"
+              },
+              "github-research": {
+                "type": "stdio",
+                "command": "uvx",
+                "args": [
+                  "github-research-mcp"
+                ],
+                "env": {
+                  "DISABLE_SUMMARIES": "true",
+                  "GITHUB_PERSONAL_ACCESS_TOKEN": "${{ secrets.GITHUB_TOKEN }}"
+                }
+              }
+            }
+          }
+          EOF
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@v1
+        with:
+          github_token: ${{ steps.marvin-token.outputs.token }}
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY_FOR_CI }}
+          bot_name: "Marvin Context Protocol"
+
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+
+          additional_permissions: |
+            actions: read
+
+          prompt: ${{ steps.analysis-prompt.outputs.PROMPT }}
+          claude_args: |
+            --allowed-tools mcp__repository-summary,mcp__code-search,mcp__github-research,WebSearch,WebFetch,Bash(make:*,git:*)
+            --mcp-config /tmp/mcp-config/mcp-servers.json

{fastmcp-2.13.0.1 → fastmcp-2.13.1}/.github/workflows/marvin.yml

@@ -44,11 +44,10 @@ jobs:
       - name: Install dependencies
         run: uv sync --python 3.12
 
-      # Install pre-commit hooks automatically
-      - name: Install pre-commit hooks
-        run: |
-          uv run pre-commit install
-          echo "✅ Pre-commit hooks installed"
+      - name: Run prek
+        uses: j178/prek-action@v1
+        env:
+          SKIP: no-commit-to-branch
 
       - name: Generate Marvin App token
         id: marvin-token
@@ -74,5 +73,6 @@ jobs:
               "model": "claude-sonnet-4-5-20250929",
               "env": {
                 "GH_TOKEN": "${{ steps.marvin-token.outputs.token }}"
-              }
+              },
+              "customInstructions": "When you complete work on an issue: (1) You MUST create a pull request using the mcp__github__create_pull_request tool instead of posting a link, and (2) You MUST add the 'marvin-pr' label to the original issue using mcp__github__update_issue. Even if PR creation fails and you post a link instead, you MUST still add the 'marvin-pr' label. Follow the PR message guidelines in CLAUDE.md."
             }

{fastmcp-2.13.0.1 → fastmcp-2.13.1}/.github/workflows/run-static.yml

@@ -48,7 +48,7 @@ jobs:
             exit 1
           fi
           echo "✅ Lockfile is up to date"
-      - name: Run pre-commit
-        run: uv run pre-commit run --all-files
+      - name: Run prek
+        uses: j178/prek-action@v1
         env:
           SKIP: no-commit-to-branch

{fastmcp-2.13.0.1 → fastmcp-2.13.1}/.github/workflows/run-tests.yml

@@ -48,12 +48,7 @@ jobs:
         run: uv sync --upgrade
 
       - name: Run tests (excluding integration and client_process)
-        run: |
-          if [ "${{ matrix.os }}" = "windows-latest" ]; then
-            uv run pytest --inline-snapshot=disable tests -m "not integration and not client_process"
-          else
-            uv run pytest --inline-snapshot=disable tests -m "not integration and not client_process" --numprocesses auto --maxprocesses 4 --dist worksteal
-          fi
+        run: uv run pytest --inline-snapshot=disable tests -m "not integration and not client_process" --numprocesses auto --maxprocesses 4 --dist worksteal
         shell: bash
 
       - name: Run client process tests separately
@@ -79,10 +74,10 @@ jobs:
         run: uv sync --resolution lowest-direct
 
       - name: Run tests (excluding integration and client_process)
-        run: uv run pytest --inline-snapshot=disable tests -m "not integration and not client_process" --numprocesses auto --maxprocesses 4 --dist worksteal
+        run: uv run --resolution lowest-direct pytest --inline-snapshot=disable tests -m "not integration and not client_process" --numprocesses auto --maxprocesses 4 --dist worksteal
 
       - name: Run client process tests separately
-        run: uv run pytest --inline-snapshot=disable tests -m "client_process" -x
+        run: uv run --resolution lowest-direct pytest --inline-snapshot=disable tests -m "client_process" -x
 
   run_integration_tests:
     name: "Run integration tests"

{fastmcp-2.13.0.1 → fastmcp-2.13.1}/AGENTS.md

@@ -10,7 +10,7 @@ FastMCP is a comprehensive Python framework (Python ≥3.10) for building Model
 
 ```bash
 uv sync                              # Install dependencies
-uv run pre-commit run --all-files    # Ruff + Prettier + ty
+uv run prek run --all-files          # Ruff + Prettier + ty
 uv run pytest                        # Run full test suite
 ```
 
@@ -100,12 +100,12 @@ async with Client(transport=StreamableHttpTransport(server_url)) as client:
 
 ### Git & CI
 
-- Pre-commit hooks are required (run automatically on commits)
-- Never amend commits to fix pre-commit failures
+- Prek hooks are required (run automatically on commits)
+- Never amend commits to fix prek failures
 - Apply PR labels: bugs/breaking/enhancements/features
 - Improvements = enhancements (not features) unless specified
 - **NEVER** force-push on collaborative repos
-- **ALWAYS** run pre-commit before PRs
+- **ALWAYS** run prek before PRs
 
 ### Commit Messages and Agent Attribution
 
@@ -217,7 +217,7 @@ If something needs work, your review should help it get there through specific,
 
 Before approving, verify:
 
-- [ ] All required development workflow steps completed (uv sync, pre-commit, pytest)
+- [ ] All required development workflow steps completed (uv sync, prek, pytest)
 - [ ] Changes align with repository patterns and conventions
 - [ ] API changes are documented and backwards-compatible where possible
 - [ ] Error handling follows project patterns (specific exception types)
@@ -237,7 +237,7 @@ uv sync                    # Installs all deps including dev tools
 
 - **Linting**: `uv run ruff check` (or with `--fix`)
 - **Type Checking**: `uv run ty check`
-- **All Checks**: `uv run pre-commit run --all-files`
+- **All Checks**: `uv run prek run --all-files`
 
 ### Testing
 
@@ -260,6 +260,6 @@ uv sync                    # Installs all deps including dev tools
 ### Build Issues (Common Solutions)
 
 1. **Dependencies**: Always `uv sync` first
-2. **Pre-commit fails**: Run `uv run pre-commit run --all-files` to see failures
+2. **Prek fails**: Run `uv run prek run --all-files` to see failures
 3. **Type errors**: Use `uv run ty check` directly, check `pyproject.toml` config
 4. **Test timeouts**: Default 5s - optimize or mark as integration tests

{fastmcp-2.13.0.1 → fastmcp-2.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.13.0.1
+Version: 2.13.1
 Summary: The fast, Pythonic way to build MCP servers and clients.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp
@@ -18,19 +18,20 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: authlib>=1.5.2
-Requires-Dist: cyclopts>=3.0.0
+Requires-Dist: authlib>=1.6.5
+Requires-Dist: cyclopts>=4.0.0
 Requires-Dist: exceptiongroup>=1.2.2
 Requires-Dist: httpx>=0.28.1
-Requires-Dist: mcp<2.0.0,>=1.17.0
-Requires-Dist: openapi-core>=0.19.5
+Requires-Dist: jsonschema-path>=0.3.4
+Requires-Dist: mcp!=1.21.1,<2.0.0,>=1.19.0
 Requires-Dist: openapi-pydantic>=0.5.1
 Requires-Dist: platformdirs>=4.0.0
-Requires-Dist: py-key-value-aio[disk,keyring,memory]<0.3.0,>=0.2.6
+Requires-Dist: py-key-value-aio[disk,keyring,memory]<0.3.0,>=0.2.8
 Requires-Dist: pydantic[email]>=2.11.7
 Requires-Dist: pyperclip>=1.9.0
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: rich>=13.9.4
+Requires-Dist: uvicorn>=0.35
 Requires-Dist: websockets>=15.0.1
 Provides-Extra: openai
 Requires-Dist: openai>=1.102.0; extra == 'openai'
@@ -181,6 +182,8 @@ uv pip install fastmcp
 
 For full installation instructions, including verification, upgrading from the official MCPSDK, and developer setup, see the [**Installation Guide**](https://gofastmcp.com/getting-started/installation).
 
+**Dependency Licensing:** FastMCP depends on Cyclopts for CLI functionality. Cyclopts v4 includes docutils as a transitive dependency, which has complex licensing that may trigger compliance reviews in some organizations. If this is a concern, you can install Cyclopts v5 alpha (`pip install "cyclopts>=5.0.0a1"`) which removes this dependency, or wait for the stable v5 release. See [this issue](https://github.com/BrianPugh/cyclopts/issues/672) for details.
+
 ## Core Concepts
 
 These are the building blocks for creating MCP servers and clients with FastMCP.
@@ -519,20 +522,20 @@ uv run pytest --cov=src --cov=examples --cov-report=html
 
 ### Static Checks
 
-FastMCP uses `pre-commit` for code formatting, linting, and type-checking. All PRs must pass these checks (they run automatically in CI).
+FastMCP uses `prek` for code formatting, linting, and type-checking. All PRs must pass these checks (they run automatically in CI).
 
 Install the hooks locally:
 
 ```bash
-uv run pre-commit install
+uv run prek install
 ```
 
 The hooks will now run automatically on `git commit`. You can also run them manually at any time:
 
 ```bash
-pre-commit run --all-files
+prek run --all-files
 # or via uv
-uv run pre-commit run --all-files
+uv run prek run --all-files
 ```
 
 ### Pull Requests
@@ -540,7 +543,7 @@ uv run pre-commit run --all-files
 1. Fork the repository on GitHub.
 2. Create a feature branch from `main`.
 3. Make your changes, including tests and documentation updates.
-4. Ensure tests and pre-commit hooks pass.
+4. Ensure tests and prek hooks pass.
 5. Commit your changes and push to your fork.
 6. Open a pull request against the `main` branch of `jlowin/fastmcp`.
 

{fastmcp-2.13.0.1 → fastmcp-2.13.1}/README.md

@@ -143,6 +143,8 @@ uv pip install fastmcp
 
 For full installation instructions, including verification, upgrading from the official MCPSDK, and developer setup, see the [**Installation Guide**](https://gofastmcp.com/getting-started/installation).
 
+**Dependency Licensing:** FastMCP depends on Cyclopts for CLI functionality. Cyclopts v4 includes docutils as a transitive dependency, which has complex licensing that may trigger compliance reviews in some organizations. If this is a concern, you can install Cyclopts v5 alpha (`pip install "cyclopts>=5.0.0a1"`) which removes this dependency, or wait for the stable v5 release. See [this issue](https://github.com/BrianPugh/cyclopts/issues/672) for details.
+
 ## Core Concepts
 
 These are the building blocks for creating MCP servers and clients with FastMCP.
@@ -481,20 +483,20 @@ uv run pytest --cov=src --cov=examples --cov-report=html
 
 ### Static Checks
 
-FastMCP uses `pre-commit` for code formatting, linting, and type-checking. All PRs must pass these checks (they run automatically in CI).
+FastMCP uses `prek` for code formatting, linting, and type-checking. All PRs must pass these checks (they run automatically in CI).
 
 Install the hooks locally:
 
 ```bash
-uv run pre-commit install
+uv run prek install
 ```
 
 The hooks will now run automatically on `git commit`. You can also run them manually at any time:
 
 ```bash
-pre-commit run --all-files
+prek run --all-files
 # or via uv
-uv run pre-commit run --all-files
+uv run prek run --all-files
 ```
 
 ### Pull Requests
@@ -502,7 +504,7 @@ uv run pre-commit run --all-files
 1. Fork the repository on GitHub.
 2. Create a feature branch from `main`.
 3. Make your changes, including tests and documentation updates.
-4. Ensure tests and pre-commit hooks pass.
+4. Ensure tests and prek hooks pass.
 5. Commit your changes and push to your fork.
 6. Open a pull request against the `main` branch of `jlowin/fastmcp`.
 

{fastmcp-2.13.0.1 → fastmcp-2.13.1}/docs/clients/auth/oauth.mdx

@@ -53,7 +53,7 @@ async with Client("https://fastmcp.cloud/mcp", auth=oauth) as client:
 - **`mcp_url`** (`str`): The full URL of the target MCP server endpoint. Used to discover OAuth server metadata
 - **`scopes`** (`str | list[str]`, optional): OAuth scopes to request. Can be space-separated string or list of strings
 - **`client_name`** (`str`, optional): Client name for dynamic registration. Defaults to `"FastMCP Client"`
-- **`token_storage_cache_dir`** (`Path`, optional): Token cache directory. Defaults to `~/.fastmcp/oauth-mcp-client-cache/`
+- **`token_storage`** (`AsyncKeyValue`, optional): Storage backend for persisting OAuth tokens. Defaults to in-memory storage (tokens lost on restart). See [Token Storage](#token-storage) for encrypted storage options
 - **`additional_client_metadata`** (`dict[str, Any]`, optional): Extra metadata for client registration
 - **`callback_port`** (`int`, optional): Fixed port for OAuth callback server. If not specified, uses a random available port
 
@@ -64,7 +64,7 @@ The OAuth flow is triggered when you use a FastMCP `Client` configured to use OA
 
 <Steps>
 <Step title="Token Check">
-The client first checks the `token_storage_cache_dir` for existing, valid tokens for the target server. If one is found, it will be used to authenticate the client.
+The client first checks the configured `token_storage` backend for existing, valid tokens for the target server. If one is found, it will be used to authenticate the client.
 </Step>
 <Step title="OAuth Server Discovery">
 If no valid tokens exist, the client attempts to discover the OAuth server's endpoints using a well-known URI (e.g., `/.well-known/oauth-authorization-server`) based on the `mcp_url`.
@@ -82,37 +82,51 @@ The user's default web browser is automatically opened, directing them to the OA
 Upon approval, the OAuth server redirects the user's browser to the local callback server with an `authorization_code`. The client captures this code and exchanges it with the OAuth server's token endpoint for an `access_token` (and often a `refresh_token`) using PKCE for security.
 </Step>
 <Step title="Token Caching">
-The obtained tokens are saved to the `token_storage_cache_dir` for future use, eliminating the need for repeated browser interactions.
-</Step> 
+The obtained tokens are saved to the configured `token_storage` backend for future use, eliminating the need for repeated browser interactions.
+</Step>
 <Step title="Authenticated Requests">
-The access token is automatically included in the `Authorization` header for requests to the MCP server. 
+The access token is automatically included in the `Authorization` header for requests to the MCP server.
 </Step>
 <Step title="Refresh Token">
 If the access token expires, the client will automatically use the refresh token to get a new access token.
 </Step>
 </Steps>
 
-## Token Management
-
-### Token Storage
+## Token Storage
 
-OAuth access tokens are automatically cached in `~/.fastmcp/oauth-mcp-client-cache/` and persist between application runs. Files are keyed by the OAuth server's base URL.
+<VersionBadge version="2.13.0" />
 
-### Managing Cache
+By default, tokens are stored in memory and lost when your application restarts. For persistent storage, pass an `AsyncKeyValue`-compatible storage backend to the `token_storage` parameter.
 
-To clear the tokens for a specific server, instantiate a `FileTokenStorage` instance and call the `clear` method:
+<Warning>
+**Security Consideration**: Use encrypted storage for production. MCP clients can accumulate OAuth credentials for many servers over time, and a compromised token store could expose access to multiple services.
+</Warning>
 
 ```python
-from fastmcp.client.auth.oauth import FileTokenStorage
+from fastmcp import Client
+from fastmcp.client.auth import OAuth
+from key_value.aio.stores.disk import DiskStore
+from key_value.aio.wrappers.encryption import FernetEncryptionWrapper
+from cryptography.fernet import Fernet
+import os
+
+# Create encrypted disk storage
+encrypted_storage = FernetEncryptionWrapper(
+    key_value=DiskStore(directory="~/.fastmcp/oauth-tokens"),
+    fernet=Fernet(os.environ["OAUTH_STORAGE_ENCRYPTION_KEY"])
+)
+
+oauth = OAuth(
+    mcp_url="https://fastmcp.cloud/mcp",
+    token_storage=encrypted_storage
+)
 
-storage = FileTokenStorage(server_url="https://fastmcp.cloud/mcp")
-await storage.clear()
+async with Client("https://fastmcp.cloud/mcp", auth=oauth) as client:
+    await client.ping()
 ```
 
-To clear *all* tokens for all servers, call the `clear_all` method on the `FileTokenStorage` class:
-
-```python
-from fastmcp.client.auth.oauth import FileTokenStorage
+You can use any `AsyncKeyValue`-compatible backend from the [key-value library](https://github.com/strawgate/py-key-value) including Redis, DynamoDB, and more. Wrap your storage in `FernetEncryptionWrapper` for encryption.
 
-FileTokenStorage.clear_all()
-```
+<Note>
+When selecting a storage backend, review the [py-key-value documentation](https://github.com/strawgate/py-key-value) to understand the maturity level and limitations of your chosen backend. Some backends may be in preview or have constraints that affect production suitability.
+</Note>

{fastmcp-2.13.0.1 → fastmcp-2.13.1}/docs/clients/client.mdx

@@ -223,6 +223,55 @@ async with client:
     print("Server is reachable")
 ```
 
+### Initialization and Server Information
+
+When you enter the client context manager, the client automatically performs an MCP initialization handshake with the server. This handshake exchanges capabilities, server metadata, and instructions. The result is available through the `initialize_result` property.
+
+```python
+from fastmcp import Client, FastMCP
+
+mcp = FastMCP(name="MyServer", instructions="Use the greet tool to say hello!")
+
+@mcp.tool
+def greet(name: str) -> str:
+    """Greet a user by name."""
+    return f"Hello, {name}!"
+
+async with Client(mcp) as client:
+    # Initialization already happened automatically
+    print(f"Server: {client.initialize_result.serverInfo.name}")
+    print(f"Version: {client.initialize_result.serverInfo.version}")
+    print(f"Instructions: {client.initialize_result.instructions}")
+    print(f"Capabilities: {client.initialize_result.capabilities.tools}")
+```
+
+#### Manual Initialization Control
+
+In advanced scenarios, you might want precise control over when initialization happens. For example, you may need custom error handling, want to defer initialization until after other setup, or need to measure initialization timing separately.
+
+Disable automatic initialization and call `initialize()` manually:
+
+```python
+from fastmcp import Client
+
+# Disable automatic initialization
+client = Client("my_mcp_server.py", auto_initialize=False)
+
+async with client:
+    # Connection established, but not initialized yet
+    print(f"Connected: {client.is_connected()}")
+    print(f"Initialized: {client.initialize_result is not None}")  # False
+
+    # Initialize manually with custom timeout
+    result = await client.initialize(timeout=10.0)
+    print(f"Server: {result.serverInfo.name}")
+
+    # Now ready for operations
+    tools = await client.list_tools()
+```
+
+The `initialize()` method is idempotent - calling it multiple times returns the cached result from the first successful call.
+
 ## Client Configuration
 
 Clients can be configured with additional handlers and settings for specialized use cases.

{fastmcp-2.13.0.1 → fastmcp-2.13.1}/docs/clients/tools.mdx

@@ -101,6 +101,31 @@ async with client:
 - `arguments`: Dictionary of arguments to pass to the tool (optional)
 - `timeout`: Maximum execution time in seconds (optional, overrides client-level timeout)
 - `progress_handler`: Progress callback function (optional, overrides client-level handler)
+- `meta`: Dictionary of metadata to send with the request (optional, see below)
+
+## Sending Metadata
+
+<VersionBadge version="2.13.1" />
+
+The `meta` parameter sends ancillary information alongside tool calls. This can be used for various purposes like observability, debugging, client identification, or any context the server may need beyond the tool's primary arguments.
+
+```python
+async with client:
+    result = await client.call_tool(
+        name="send_email",
+        arguments={
+            "to": "user@example.com",
+            "subject": "Hello",
+            "body": "Welcome!"
+        },
+        meta={
+            "trace_id": "abc-123",
+            "request_source": "mobile_app"
+        }
+    )
+```
+
+The structure and usage of `meta` is determined by your application. See [Client Metadata](/servers/context#client-metadata) in the server documentation to learn how to access this data in your tool implementations.
 
 ## Handling Results
 

{fastmcp-2.13.0.1 → fastmcp-2.13.1}/docs/deployment/http.mdx

@@ -45,7 +45,7 @@ Run your server with a simple Python command:
 python server.py
 ```
 
-Your server is now accessible at `http://localhost:8000/mcp/` (or use your server's actual IP address for remote access).
+Your server is now accessible at `http://localhost:8000/mcp` (or use your server's actual IP address for remote access).
 
 This approach is ideal when you want to get online quickly with minimal configuration. It's perfect for internal tools, development environments, or simple deployments where you don't need advanced server features. The built-in server handles all the HTTP details, letting you focus on your MCP implementation.
 
@@ -72,7 +72,7 @@ Run with any ASGI server - here's an example with Uvicorn:
 uvicorn app:app --host 0.0.0.0 --port 8000
 ```
 
-Your server is accessible at the same URL: `http://localhost:8000/mcp/` (or use your server's actual IP address for remote access).
+Your server is accessible at the same URL: `http://localhost:8000/mcp` (or use your server's actual IP address for remote access).
 
 The ASGI approach shines in production environments where you need reliability and performance. You can run multiple worker processes to handle concurrent requests, add custom middleware for logging or monitoring, integrate with existing deployment pipelines, or mount your MCP server as part of a larger application.
 
@@ -293,7 +293,7 @@ api.mount("/mcp", mcp.http_app())
 # Run with: uvicorn app:api --host 0.0.0.0 --port 8000
 ```
 
-Your existing API remains at `http://localhost:8000/api/` while MCP is available at `http://localhost:8000/mcp/`.
+Your existing API remains at `http://localhost:8000/api` while MCP is available at `http://localhost:8000/mcp`.
 
 ## Mounting Authenticated Servers
 

{fastmcp-2.13.0.1 → fastmcp-2.13.1}/docs/deployment/running-server.mdx

@@ -83,7 +83,7 @@ if __name__ == "__main__":
     mcp.run(transport="http", host="127.0.0.1", port=8000)
 ```
 
-Your server is now accessible at `http://localhost:8000/mcp/`. This URL is the MCP endpoint that clients will connect to. HTTP transport enables:
+Your server is now accessible at `http://localhost:8000/mcp`. This URL is the MCP endpoint that clients will connect to. HTTP transport enables:
 - Network accessibility
 - Multiple concurrent clients
 - Integration with web infrastructure