@sylphai/adal-cli-linux-x64 0.2.3 → 0.3.0-beta.4

package/backend/adal-backend/_internal/deep_research/models/model_pricing.json

@@ -23,6 +23,19 @@
   "providers": {
     "anthropic": {
       "models": {
+        "claude-opus-4-5-20251101": {
+          "display_name": "Claude Opus 4.5",
+          "input_price_per_mtok": 5.0,
+          "cached_input_price_per_mtok": 0.5,
+          "cache_write_price_per_mtok": 6.25,
+          "output_price_per_mtok": 25.0,
+          "cache_discount_percent": 90,
+          "cache_write_markup_percent": 25,
+          "supports_caching": true,
+          "supports_thinking": true,
+          "model_type": "flagship",
+          "notes": "Latest flagship, thinking model, 67% cheaper than Opus 4/4.1"
+        },
         "claude-opus-4-1": {
           "display_name": "Claude Opus 4.1",
           "input_price_per_mtok": 15.0,
@@ -34,7 +47,7 @@
           "supports_caching": true,
           "supports_thinking": true,
           "model_type": "flagship",
-          "notes": "Latest flagship, thinking model"
+          "notes": "Previous flagship, thinking model"
         },
         "claude-opus-4": {
           "display_name": "Claude Opus 4",

package/backend/adal-backend/_internal/{mcp-1.22.0.dist-info → mcp-1.13.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp
-Version: 1.22.0
+Version: 1.13.1
 Summary: Model Context Protocol SDK
 Project-URL: Homepage, https://modelcontextprotocol.io
 Project-URL: Repository, https://github.com/modelcontextprotocol/python-sdk
@@ -25,13 +25,10 @@ Requires-Dist: httpx>=0.27.1
 Requires-Dist: jsonschema>=4.20.0
 Requires-Dist: pydantic-settings>=2.5.2
 Requires-Dist: pydantic<3.0.0,>=2.11.0
-Requires-Dist: pyjwt[crypto]>=2.10.1
 Requires-Dist: python-multipart>=0.0.9
 Requires-Dist: pywin32>=310; sys_platform == 'win32'
 Requires-Dist: sse-starlette>=1.6.1
 Requires-Dist: starlette>=0.27
-Requires-Dist: typing-extensions>=4.9.0
-Requires-Dist: typing-inspection>=0.4.1
 Requires-Dist: uvicorn>=0.31.1; sys_platform != 'emscripten'
 Provides-Extra: cli
 Requires-Dist: python-dotenv>=1.0.0; extra == 'cli'
@@ -52,8 +49,8 @@ Description-Content-Type: text/markdown
 [![MIT licensed][mit-badge]][mit-url]
 [![Python Version][python-badge]][python-url]
 [![Documentation][docs-badge]][docs-url]
-[![Protocol][protocol-badge]][protocol-url]
 [![Specification][spec-badge]][spec-url]
+[![GitHub Discussions][discussions-badge]][discussions-url]
 
 </div>
 
@@ -75,33 +72,22 @@ Description-Content-Type: text/markdown
     - [Prompts](#prompts)
     - [Images](#images)
     - [Context](#context)
-      - [Getting Context in Functions](#getting-context-in-functions)
-      - [Context Properties and Methods](#context-properties-and-methods)
     - [Completions](#completions)
     - [Elicitation](#elicitation)
     - [Sampling](#sampling)
     - [Logging and Notifications](#logging-and-notifications)
     - [Authentication](#authentication)
     - [FastMCP Properties](#fastmcp-properties)
-    - [Session Properties and Methods](#session-properties-and-methods)
+    - [Session Properties](#session-properties-and-methods)
     - [Request Context Properties](#request-context-properties)
   - [Running Your Server](#running-your-server)
     - [Development Mode](#development-mode)
     - [Claude Desktop Integration](#claude-desktop-integration)
     - [Direct Execution](#direct-execution)
     - [Streamable HTTP Transport](#streamable-http-transport)
-      - [CORS Configuration for Browser-Based Clients](#cors-configuration-for-browser-based-clients)
     - [Mounting to an Existing ASGI Server](#mounting-to-an-existing-asgi-server)
-      - [StreamableHTTP servers](#streamablehttp-servers)
-        - [Basic mounting](#basic-mounting)
-        - [Host-based routing](#host-based-routing)
-        - [Multiple servers with path configuration](#multiple-servers-with-path-configuration)
-        - [Path configuration at initialization](#path-configuration-at-initialization)
-      - [SSE servers](#sse-servers)
   - [Advanced Usage](#advanced-usage)
     - [Low-Level Server](#low-level-server)
-      - [Structured Output Support](#structured-output-support)
-    - [Pagination (Advanced)](#pagination-advanced)
     - [Writing MCP Clients](#writing-mcp-clients)
     - [Client Display Utilities](#client-display-utilities)
     - [OAuth Authentication for Clients](#oauth-authentication-for-clients)
@@ -118,12 +104,12 @@ Description-Content-Type: text/markdown
 [mit-url]: https://github.com/modelcontextprotocol/python-sdk/blob/main/LICENSE
 [python-badge]: https://img.shields.io/pypi/pyversions/mcp.svg
 [python-url]: https://www.python.org/downloads/
-[docs-badge]: https://img.shields.io/badge/docs-python--sdk-blue.svg
-[docs-url]: https://modelcontextprotocol.github.io/python-sdk/
-[protocol-badge]: https://img.shields.io/badge/protocol-modelcontextprotocol.io-blue.svg
-[protocol-url]: https://modelcontextprotocol.io
+[docs-badge]: https://img.shields.io/badge/docs-modelcontextprotocol.io-blue.svg
+[docs-url]: https://modelcontextprotocol.io
 [spec-badge]: https://img.shields.io/badge/spec-spec.modelcontextprotocol.io-blue.svg
-[spec-url]: https://modelcontextprotocol.io/specification/latest
+[spec-url]: https://spec.modelcontextprotocol.io
+[discussions-badge]: https://img.shields.io/github/discussions/modelcontextprotocol/python-sdk
+[discussions-url]: https://github.com/modelcontextprotocol/python-sdk/discussions
 
 ## Overview
 
@@ -176,14 +162,14 @@ Let's create a simple MCP server that exposes a calculator tool and some data:
 """
 FastMCP quickstart example.
 
-Run from the repository root:
-    uv run examples/snippets/servers/fastmcp_quickstart.py
+cd to the `examples/snippets/clients` directory and run:
+    uv run server fastmcp_quickstart stdio
 """
 
 from mcp.server.fastmcp import FastMCP
 
 # Create an MCP server
-mcp = FastMCP("Demo", json_response=True)
+mcp = FastMCP("Demo")
 
 
 # Add an addition tool
@@ -211,36 +197,23 @@ def greet_user(name: str, style: str = "friendly") -> str:
     }
 
     return f"{styles.get(style, styles['friendly'])} for someone named {name}."
-
-
-# Run with streamable HTTP transport
-if __name__ == "__main__":
-    mcp.run(transport="streamable-http")
 ```
 
 _Full example: [examples/snippets/servers/fastmcp_quickstart.py](https://github.com/modelcontextprotocol/python-sdk/blob/main/examples/snippets/servers/fastmcp_quickstart.py)_
 <!-- /snippet-source -->
 
-You can install this server in [Claude Code](https://docs.claude.com/en/docs/claude-code/mcp) and interact with it right away. First, run the server:
+You can install this server in [Claude Desktop](https://claude.ai/download) and interact with it right away by running:
 
 ```bash
-uv run --with mcp examples/snippets/servers/fastmcp_quickstart.py
-```
-
-Then add it to Claude Code:
-
-```bash
-claude mcp add --transport http my-server http://localhost:8000/mcp
+uv run mcp install server.py
 ```
 
-Alternatively, you can test it with the MCP Inspector. Start the server as above, then in a separate terminal:
+Alternatively, you can test it with the MCP Inspector:
 
 ```bash
-npx -y @modelcontextprotocol/inspector
+uv run mcp dev server.py
 ```
 
-In the inspector UI, connect to `http://localhost:8000/mcp`.
-
 ## What is MCP?
 
 The [Model Context Protocol (MCP)](https://modelcontextprotocol.io) lets you build servers that expose data and functionality to LLM applications in a secure, standardized way. Think of it like a web API, but specifically designed for LLM interactions. MCP servers can:
@@ -440,61 +413,6 @@ causes the tool to be classified as structured _and this is undesirable_,
 the  classification can be suppressed by passing `structured_output=False`
 to the `@tool` decorator.
 
-##### Advanced: Direct CallToolResult
-
-For full control over tool responses including the `_meta` field (for passing data to client applications without exposing it to the model), you can return `CallToolResult` directly:
-
-<!-- snippet-source examples/snippets/servers/direct_call_tool_result.py -->
-```python
-"""Example showing direct CallToolResult return for advanced control."""
-
-from typing import Annotated
-
-from pydantic import BaseModel
-
-from mcp.server.fastmcp import FastMCP
-from mcp.types import CallToolResult, TextContent
-
-mcp = FastMCP("CallToolResult Example")
-
-
-class ValidationModel(BaseModel):
-    """Model for validating structured output."""
-
-    status: str
-    data: dict[str, int]
-
-
-@mcp.tool()
-def advanced_tool() -> CallToolResult:
-    """Return CallToolResult directly for full control including _meta field."""
-    return CallToolResult(
-        content=[TextContent(type="text", text="Response visible to the model")],
-        _meta={"hidden": "data for client applications only"},
-    )
-
-
-@mcp.tool()
-def validated_tool() -> Annotated[CallToolResult, ValidationModel]:
-    """Return CallToolResult with structured output validation."""
-    return CallToolResult(
-        content=[TextContent(type="text", text="Validated response")],
-        structuredContent={"status": "success", "data": {"result": 42}},
-        _meta={"internal": "metadata"},
-    )
-
-
-@mcp.tool()
-def empty_result_tool() -> CallToolResult:
-    """For empty results, return CallToolResult with empty content."""
-    return CallToolResult(content=[])
-```
-
-_Full example: [examples/snippets/servers/direct_call_tool_result.py](https://github.com/modelcontextprotocol/python-sdk/blob/main/examples/snippets/servers/direct_call_tool_result.py)_
-<!-- /snippet-source -->
-
-**Important:** `CallToolResult` must always be returned (no `Optional` or `Union`). For empty results, use `CallToolResult(content=[])`. For optional simple types, use `str | None` without `CallToolResult`.
-
 <!-- snippet-source examples/snippets/servers/structured_output.py -->
 ```python
 """Example showing structured output with tools."""
@@ -523,7 +441,7 @@ def get_weather(city: str) -> WeatherData:
     """Get weather for a city - returns structured data."""
     # Simulated weather data
     return WeatherData(
-        temperature=22.5,
+        temperature=72.5,
         humidity=45.0,
         condition="sunny",
         wind_speed=5.2,
@@ -628,41 +546,6 @@ def debug_error(error: str) -> list[base.Message]:
 _Full example: [examples/snippets/servers/basic_prompt.py](https://github.com/modelcontextprotocol/python-sdk/blob/main/examples/snippets/servers/basic_prompt.py)_
 <!-- /snippet-source -->
 
-### Icons
-
-MCP servers can provide icons for UI display. Icons can be added to the server implementation, tools, resources, and prompts:
-
-```python
-from mcp.server.fastmcp import FastMCP, Icon
-
-# Create an icon from a file path or URL
-icon = Icon(
-    src="icon.png",
-    mimeType="image/png",
-    sizes="64x64"
-)
-
-# Add icons to server
-mcp = FastMCP(
-    "My Server",
-    website_url="https://example.com",
-    icons=[icon]
-)
-
-# Add icons to tools, resources, and prompts
-@mcp.tool(icons=[icon])
-def my_tool():
-    """Tool with an icon."""
-    return "result"
-
-@mcp.resource("demo://resource", icons=[icon])
-def my_resource():
-    """Resource with an icon."""
-    return "content"
-```
-
-_Full example: [examples/fastmcp/icons_demo.py](https://github.com/modelcontextprotocol/python-sdk/blob/main/examples/fastmcp/icons_demo.py)_
-
 ### Images
 
 FastMCP provides an `Image` class that automatically handles image data:
@@ -894,8 +777,6 @@ async def book_table(date: str, time: str, party_size: int, ctx: Context[ServerS
 _Full example: [examples/snippets/servers/elicitation.py](https://github.com/modelcontextprotocol/python-sdk/blob/main/examples/snippets/servers/elicitation.py)_
 <!-- /snippet-source -->
 
-Elicitation schemas support default values for all field types. Default values are automatically included in the JSON schema sent to clients, allowing them to pre-populate forms.
-
 The `elicit()` method returns an `ElicitationResult` with:
 
 - `action`: "accept", "decline", or "cancel"
@@ -1000,7 +881,6 @@ class SimpleTokenVerifier(TokenVerifier):
 # Create FastMCP instance as a Resource Server
 mcp = FastMCP(
     "Weather Service",
-    json_response=True,
     # Token verifier for authentication
     token_verifier=SimpleTokenVerifier(),
     # Auth settings for RFC 9728 Protected Resource Metadata
@@ -1046,8 +926,6 @@ The FastMCP server instance accessible via `ctx.fastmcp` provides access to serv
 
 - `ctx.fastmcp.name` - The server's name as defined during initialization
 - `ctx.fastmcp.instructions` - Server instructions/description provided to clients
-- `ctx.fastmcp.website_url` - Optional website URL for the server
-- `ctx.fastmcp.icons` - Optional list of icons for UI display
 - `ctx.fastmcp.settings` - Complete server configuration object containing:
   - `debug` - Debug mode flag
   - `log_level` - Current logging level
@@ -1216,7 +1094,7 @@ Note that `uv run mcp run` or `uv run mcp dev` only supports server using FastMC
 
 ### Streamable HTTP Transport
 
-> **Note**: Streamable HTTP transport is the recommended transport for production deployments. Use `stateless_http=True` and `json_response=True` for optimal scalability.
+> **Note**: Streamable HTTP transport is superseding SSE transport for production deployments.
 
 <!-- snippet-source examples/snippets/servers/streamable_config.py -->
 ```python
@@ -1227,15 +1105,15 @@ Run from the repository root:
 
 from mcp.server.fastmcp import FastMCP
 
-# Stateless server with JSON responses (recommended)
-mcp = FastMCP("StatelessServer", stateless_http=True, json_response=True)
+# Stateful server (maintains session state)
+mcp = FastMCP("StatefulServer")
 
 # Other configuration options:
-# Stateless server with SSE streaming responses
+# Stateless server (no session persistence)
 # mcp = FastMCP("StatelessServer", stateless_http=True)
 
-# Stateful server with session persistence
-# mcp = FastMCP("StatefulServer")
+# Stateless server (no session persistence, no sse stream with supported client)
+# mcp = FastMCP("StatelessServer", stateless_http=True, json_response=True)
 
 
 # Add a simple tool to demonstrate the server
@@ -1270,7 +1148,7 @@ from starlette.routing import Mount
 from mcp.server.fastmcp import FastMCP
 
 # Create the Echo server
-echo_mcp = FastMCP(name="EchoServer", stateless_http=True, json_response=True)
+echo_mcp = FastMCP(name="EchoServer", stateless_http=True)
 
 
 @echo_mcp.tool()
@@ -1280,7 +1158,7 @@ def echo(message: str) -> str:
 
 
 # Create the Math server
-math_mcp = FastMCP(name="MathServer", stateless_http=True, json_response=True)
+math_mcp = FastMCP(name="MathServer", stateless_http=True)
 
 
 @math_mcp.tool()
@@ -1381,7 +1259,7 @@ from starlette.routing import Mount
 from mcp.server.fastmcp import FastMCP
 
 # Create MCP server
-mcp = FastMCP("My App", json_response=True)
+mcp = FastMCP("My App")
 
 
 @mcp.tool()
@@ -1418,7 +1296,7 @@ from starlette.routing import Host
 from mcp.server.fastmcp import FastMCP
 
 # Create MCP server
-mcp = FastMCP("MCP Host App", json_response=True)
+mcp = FastMCP("MCP Host App")
 
 
 @mcp.tool()
@@ -1455,8 +1333,8 @@ from starlette.routing import Mount
 from mcp.server.fastmcp import FastMCP
 
 # Create multiple MCP servers
-api_mcp = FastMCP("API Server", json_response=True)
-chat_mcp = FastMCP("Chat Server", json_response=True)
+api_mcp = FastMCP("API Server")
+chat_mcp = FastMCP("Chat Server")
 
 
 @api_mcp.tool()
@@ -1506,11 +1384,7 @@ from mcp.server.fastmcp import FastMCP
 
 # Configure streamable_http_path during initialization
 # This server will mount at the root of wherever it's mounted
-mcp_at_root = FastMCP(
-    "My Server",
-    json_response=True,
-    streamable_http_path="/",
-)
+mcp_at_root = FastMCP("My Server", streamable_http_path="/")
 
 
 @mcp_at_root.tool()
@@ -1886,203 +1760,14 @@ if __name__ == "__main__":
 _Full example: [examples/snippets/servers/lowlevel/structured_output.py](https://github.com/modelcontextprotocol/python-sdk/blob/main/examples/snippets/servers/lowlevel/structured_output.py)_
 <!-- /snippet-source -->
 
-Tools can return data in four ways:
+Tools can return data in three ways:
 
 1. **Content only**: Return a list of content blocks (default behavior before spec revision 2025-06-18)
 2. **Structured data only**: Return a dictionary that will be serialized to JSON (Introduced in spec revision 2025-06-18)
 3. **Both**: Return a tuple of (content, structured_data) preferred option to use for backwards compatibility
-4. **Direct CallToolResult**: Return `CallToolResult` directly for full control (including `_meta` field)
 
 When an `outputSchema` is defined, the server automatically validates the structured output against the schema. This ensures type safety and helps catch errors early.
 
-##### Returning CallToolResult Directly
-
-For full control over the response including the `_meta` field (for passing data to client applications without exposing it to the model), return `CallToolResult` directly:
-
-<!-- snippet-source examples/snippets/servers/lowlevel/direct_call_tool_result.py -->
-```python
-"""
-Run from the repository root:
-    uv run examples/snippets/servers/lowlevel/direct_call_tool_result.py
-"""
-
-import asyncio
-from typing import Any
-
-import mcp.server.stdio
-import mcp.types as types
-from mcp.server.lowlevel import NotificationOptions, Server
-from mcp.server.models import InitializationOptions
-
-server = Server("example-server")
-
-
-@server.list_tools()
-async def list_tools() -> list[types.Tool]:
-    """List available tools."""
-    return [
-        types.Tool(
-            name="advanced_tool",
-            description="Tool with full control including _meta field",
-            inputSchema={
-                "type": "object",
-                "properties": {"message": {"type": "string"}},
-                "required": ["message"],
-            },
-        )
-    ]
-
-
-@server.call_tool()
-async def handle_call_tool(name: str, arguments: dict[str, Any]) -> types.CallToolResult:
-    """Handle tool calls by returning CallToolResult directly."""
-    if name == "advanced_tool":
-        message = str(arguments.get("message", ""))
-        return types.CallToolResult(
-            content=[types.TextContent(type="text", text=f"Processed: {message}")],
-            structuredContent={"result": "success", "message": message},
-            _meta={"hidden": "data for client applications only"},
-        )
-
-    raise ValueError(f"Unknown tool: {name}")
-
-
-async def run():
-    """Run the server."""
-    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
-        await server.run(
-            read_stream,
-            write_stream,
-            InitializationOptions(
-                server_name="example",
-                server_version="0.1.0",
-                capabilities=server.get_capabilities(
-                    notification_options=NotificationOptions(),
-                    experimental_capabilities={},
-                ),
-            ),
-        )
-
-
-if __name__ == "__main__":
-    asyncio.run(run())
-```
-
-_Full example: [examples/snippets/servers/lowlevel/direct_call_tool_result.py](https://github.com/modelcontextprotocol/python-sdk/blob/main/examples/snippets/servers/lowlevel/direct_call_tool_result.py)_
-<!-- /snippet-source -->
-
-**Note:** When returning `CallToolResult`, you bypass the automatic content/structured conversion. You must construct the complete response yourself.
-
-### Pagination (Advanced)
-
-For servers that need to handle large datasets, the low-level server provides paginated versions of list operations. This is an optional optimization - most servers won't need pagination unless they're dealing with hundreds or thousands of items.
-
-#### Server-side Implementation
-
-<!-- snippet-source examples/snippets/servers/pagination_example.py -->
-```python
-"""
-Example of implementing pagination with MCP server decorators.
-"""
-
-from pydantic import AnyUrl
-
-import mcp.types as types
-from mcp.server.lowlevel import Server
-
-# Initialize the server
-server = Server("paginated-server")
-
-# Sample data to paginate
-ITEMS = [f"Item {i}" for i in range(1, 101)]  # 100 items
-
-
-@server.list_resources()
-async def list_resources_paginated(request: types.ListResourcesRequest) -> types.ListResourcesResult:
-    """List resources with pagination support."""
-    page_size = 10
-
-    # Extract cursor from request params
-    cursor = request.params.cursor if request.params is not None else None
-
-    # Parse cursor to get offset
-    start = 0 if cursor is None else int(cursor)
-    end = start + page_size
-
-    # Get page of resources
-    page_items = [
-        types.Resource(uri=AnyUrl(f"resource://items/{item}"), name=item, description=f"Description for {item}")
-        for item in ITEMS[start:end]
-    ]
-
-    # Determine next cursor
-    next_cursor = str(end) if end < len(ITEMS) else None
-
-    return types.ListResourcesResult(resources=page_items, nextCursor=next_cursor)
-```
-
-_Full example: [examples/snippets/servers/pagination_example.py](https://github.com/modelcontextprotocol/python-sdk/blob/main/examples/snippets/servers/pagination_example.py)_
-<!-- /snippet-source -->
-
-#### Client-side Consumption
-
-<!-- snippet-source examples/snippets/clients/pagination_client.py -->
-```python
-"""
-Example of consuming paginated MCP endpoints from a client.
-"""
-
-import asyncio
-
-from mcp.client.session import ClientSession
-from mcp.client.stdio import StdioServerParameters, stdio_client
-from mcp.types import PaginatedRequestParams, Resource
-
-
-async def list_all_resources() -> None:
-    """Fetch all resources using pagination."""
-    async with stdio_client(StdioServerParameters(command="uv", args=["run", "mcp-simple-pagination"])) as (
-        read,
-        write,
-    ):
-        async with ClientSession(read, write) as session:
-            await session.initialize()
-
-            all_resources: list[Resource] = []
-            cursor = None
-
-            while True:
-                # Fetch a page of resources
-                result = await session.list_resources(params=PaginatedRequestParams(cursor=cursor))
-                all_resources.extend(result.resources)
-
-                print(f"Fetched {len(result.resources)} resources")
-
-                # Check if there are more pages
-                if result.nextCursor:
-                    cursor = result.nextCursor
-                else:
-                    break
-
-            print(f"Total resources: {len(all_resources)}")
-
-
-if __name__ == "__main__":
-    asyncio.run(list_all_resources())
-```
-
-_Full example: [examples/snippets/clients/pagination_client.py](https://github.com/modelcontextprotocol/python-sdk/blob/main/examples/snippets/clients/pagination_client.py)_
-<!-- /snippet-source -->
-
-#### Key Points
-
-- **Cursors are opaque strings** - the server defines the format (numeric offsets, timestamps, etc.)
-- **Return `nextCursor=None`** when there are no more pages
-- **Backward compatible** - clients that don't support pagination will still work (they'll just get the first page)
-- **Flexible page sizes** - Each endpoint can define its own page size based on data characteristics
-
-See the [simple-pagination example](examples/servers/simple-pagination) for a complete implementation.
-
 ### Writing MCP Clients
 
 The SDK provides a high-level client interface for connecting to MCP servers using various [transports](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports):
@@ -2493,9 +2178,8 @@ MCP servers declare capabilities during initialization:
 
 ## Documentation
 
-- [API Reference](https://modelcontextprotocol.github.io/python-sdk/api/)
 - [Model Context Protocol documentation](https://modelcontextprotocol.io)
-- [Model Context Protocol specification](https://modelcontextprotocol.io/specification/latest)
+- [Model Context Protocol specification](https://spec.modelcontextprotocol.io)
 - [Officially supported servers](https://github.com/modelcontextprotocol/servers)
 
 ## Contributing