Minor fixes

Author: pantanurag555

src/mcp/client/session.py

@@ -282,8 +282,8 @@ async def call_tool(
                     params=types.CallToolRequestParams(
                         name=name,
                         arguments=arguments,
+                        webhooks=webhooks,
                     ),
-                    webhooks=webhooks,
                 )
             ),
             types.CallToolResult,

src/mcp/server/fastmcp/server.py

@@ -63,7 +63,6 @@
 from mcp.types import Resource as MCPResource
 from mcp.types import ResourceTemplate as MCPResourceTemplate
 from mcp.types import Tool as MCPTool
-from mcp.types import Webhook
 
 logger = get_logger(__name__)
 
@@ -277,15 +276,13 @@ async def call_tool(
         self,
         name: str,
         arguments: dict[str, Any],
-        webhooks: list[Webhook] | None = None,
     ) -> Sequence[TextContent | ImageContent | EmbeddedResource]:
         """Call a tool by name with arguments."""
         context = self.get_context()
         result = await self._tool_manager.call_tool(
             name,
             arguments,
             context=context,
-            webhooks=webhooks
         )
         converted_result = _convert_to_content(result)
         return converted_result
@@ -787,7 +784,8 @@ def streamable_http_app(self) -> Starlette:
                 event_store=self._event_store,
                 json_response=self.settings.json_response,
                 stateless=self.settings.stateless_http,  # Use the stateless setting
-                webhooks_supported=self.settings.webhooks_supported,  # Use the webhooks supported setting
+                webhooks_supported=self.settings.webhooks_supported,
+                # Use the webhooks supported setting
             )
 
         # Create the ASGI handler

src/mcp/server/fastmcp/tools/tool_manager.py

@@ -7,7 +7,7 @@
 from mcp.server.fastmcp.tools.base import Tool
 from mcp.server.fastmcp.utilities.logging import get_logger
 from mcp.shared.context import LifespanContextT
-from mcp.types import ToolAnnotations, Webhook
+from mcp.types import ToolAnnotations
 
 if TYPE_CHECKING:
     from mcp.server.fastmcp.server import Context
@@ -66,16 +66,16 @@ async def call_tool(
         name: str,
         arguments: dict[str, Any],
         context: Context[ServerSessionT, LifespanContextT] | None = None,
-        webhooks: list[Webhook] | None = None,
     ) -> Any:
         """Call a tool by name with arguments."""
         tool = self.get_tool(name)
         if not tool:
             raise ToolError(f"Unknown tool: {name}")
 
-        if context:
-            context.has_webhook = (
-                webhooks is not None and len(webhooks) > 0
-            )
+        if context is not None:
+            try:
+                context.has_webhook = context.request_context.has_webhook
+            except Exception:
+                logger.debug("Request context is not available.")
 
         return await tool.run(arguments, context=context)

src/mcp/server/lowlevel/server.py

@@ -412,7 +412,9 @@ def decorator(
 
             async def handler(req: types.CallToolRequest):
                 try:
-                    results = await func(req.params.name, (req.params.arguments or {}), req.webhooks)
+                    if req.params.webhooks is not None and len(req.params.webhooks) > 0:
+                        self.request_context.has_webhook = True
+                    results = await func(req.params.name, (req.params.arguments or {}))
                     return types.ServerResult(
                         types.CallToolResult(content=list(results), isError=False)
                     )

src/mcp/server/streamable_http.py

@@ -420,27 +420,29 @@ async def _handle_post_request(
             request_stream_reader = self._request_streams[request_id][1]
 
             session_message = SessionMessage(message)
-            if self._is_call_tool_request_with_webhooks(
-                session_message.message
-            ):
+            webhooks = self._get_webhooks(session_message.message)
+            if webhooks is not None:
                 if self.is_webhooks_supported:
+                    result = {
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": "Response will be forwarded to the webhook.",
+                            }
+                        ],
+                        "isError": False,
+                    }
                     response = self._create_json_response(
-                        JSONRPCMessage(root=JSONRPCResponse(
-                            jsonrpc="2.0",
-                            id=message.root.id,
-                            result={
-                                'content': [{
-                                    'type': 'text',
-                                    'text': 'Response will be forwarded to the webhook.'
-                                }],
-                                'isError': False
-                            },
-                        )),
+                        JSONRPCMessage(
+                            root=JSONRPCResponse(
+                                jsonrpc="2.0", id=message.root.id, result=result
+                            )
+                        ),
                         HTTPStatus.OK,
                     )
                     asyncio.create_task(
                         self._send_response_to_webhooks(
-                            request_id, session_message, request_stream_reader
+                            request_id, session_message, webhooks, request_stream_reader
                         )
                     )
                 else:
@@ -574,14 +576,13 @@ async def sse_writer():
                 await writer.send(Exception(err))
             return
 
-
     async def _send_response_to_webhooks(
         self,
         request_id: str,
         session_message: SessionMessage,
+        webhooks: list[Webhook],
         request_stream_reader: MemoryObjectReceiveStream[EventMessage],
     ):
-        webhooks: list[Webhook] = [Webhook(**webhook) for webhook in session_message.message.root.webhooks]
         writer = self._read_stream_writer
         if writer is None:
             raise ValueError(
@@ -611,9 +612,7 @@ async def _send_response_to_webhooks(
                         break
                     # For notifications and request, keep waiting
                     else:
-                        logger.debug(
-                            f"received: {event_message.message.root.method}"
-                        )        
+                        logger.debug(f"received: {event_message.message.root.method}")
 
                 await self._send_message_to_webhooks(webhooks, response_message)
             else:
@@ -635,7 +634,6 @@ async def _send_response_to_webhooks(
         finally:
             await self._clean_up_memory_streams(request_id)
 
-
     async def _send_message_to_webhooks(
         self,
         webhooks: list[Webhook],
@@ -646,7 +644,9 @@ async def _send_message_to_webhooks(
             # Add authorization headers
             if webhook.authentication and webhook.authentication.credentials:
                 if webhook.authentication.strategy == "bearer":
-                    headers["Authorization"] = f"Bearer {webhook.authentication.credentials}"
+                    headers["Authorization"] = (
+                        f"Bearer {webhook.authentication.credentials}"
+                    )
                 elif webhook.authentication.strategy == "apiKey":
                     headers["X-API-Key"] = webhook.authentication.credentials
                 elif webhook.authentication.strategy == "basic":
@@ -656,32 +656,45 @@ async def _send_message_to_webhooks(
                         if "username" in creds_dict and "password" in creds_dict:
                             # Create basic auth header from username and password
                             import base64
-                            auth_string = f"{creds_dict['username']}:{creds_dict['password']}"
-                            credentials = base64.b64encode(auth_string.encode()).decode()
+
+                            auth_string = (
+                                f"{creds_dict['username']}:{creds_dict['password']}"
+                            )
+                            credentials = base64.b64encode(
+                                auth_string.encode()
+                            ).decode()
                             headers["Authorization"] = f"Basic {credentials}"
-                    except:
+                    except Exception:
                         # Not JSON, use as-is
-                        headers["Authorization"] = f"Basic {webhook.authentication.credentials}"
-                elif webhook.authentication.strategy == "customHeader" and webhook.authentication.credentials:
+                        headers["Authorization"] = (
+                            f"Basic {webhook.authentication.credentials}"
+                        )
+                elif (
+                    webhook.authentication.strategy == "customHeader"
+                    and webhook.authentication.credentials
+                ):
                     try:
                         custom_headers = json.loads(webhook.authentication.credentials)
                         headers.update(custom_headers)
-                    except:
-                        pass
+                    except Exception as e:
+                        logger.exception(f"Error setting custom headers: {e}")
 
             async with create_mcp_http_client(headers=headers) as client:
                 try:
                     if isinstance(message, JSONRPCMessage | JSONRPCError):
                         await client.post(
                             webhook.url,
-                            json=message.model_dump_json(by_alias=True, exclude_none=True),
+                            json=message.model_dump_json(
+                                by_alias=True, exclude_none=True
+                            ),
                         )
                     else:
                         await client.post(webhook.url, json=message)
 
                 except Exception as e:
-                    logger.exception(f"Error sending response to webhook {webhook.url}: {e}")
-
+                    logger.exception(
+                        f"Error sending response to webhook {webhook.url}: {e}"
+                    )
 
     async def _handle_get_request(self, request: Request, send: Send) -> None:
         """
@@ -803,17 +816,18 @@ async def _handle_delete_request(self, request: Request, send: Send) -> None:
         )
         await response(request.scope, request.receive, send)
 
-
-    def _is_call_tool_request_with_webhooks(self, message: JSONRPCMessage) -> bool:
-        """Check if the request is a call tool request with webhooks."""
-        return (
+    def _get_webhooks(self, message: JSONRPCMessage) -> list[Webhook] | None:
+        """Return webhooks if the request is a call tool request with webhooks."""
+        if (
             isinstance(message.root, JSONRPCRequest)
             and message.root.method == "tools/call"
-            and hasattr(message.root, "webhooks")
-            and message.root.webhooks is not None
-            and len(message.root.webhooks) > 0
-        )
-
+            and message.root.params is not None
+            and "webhooks" in message.root.params
+            and message.root.params["webhooks"] is not None
+            and len(message.root.params["webhooks"]) > 0
+        ):
+            return [Webhook(**webhook) for webhook in message.root.params["webhooks"]]
+        return None
 
     async def _terminate_session(self) -> None:
         """Terminate the current session, closing all streams.

src/mcp/shared/context.py

@@ -16,3 +16,4 @@ class RequestContext(Generic[SessionT, LifespanContextT]):
     meta: RequestParams.Meta | None
     session: SessionT
     lifespan_context: LifespanContextT
+    has_webhook: bool = False

src/mcp/types.py

@@ -122,6 +122,7 @@ class JSONRPCRequest(Request[dict[str, Any] | None, str]):
     id: RequestId
     method: str
     params: dict[str, Any] | None = None
+    webhooks: dict[str, Any] | None = None
 
 
 class JSONRPCNotification(Notification[dict[str, Any] | None, str]):
@@ -806,6 +807,7 @@ class CallToolRequestParams(RequestParams):
 
     name: str
     arguments: dict[str, Any] | None = None
+    webhooks: list[Webhook] | None = None
     model_config = ConfigDict(extra="allow")
 
 
@@ -814,7 +816,6 @@ class CallToolRequest(Request[CallToolRequestParams, Literal["tools/call"]]):
 
     method: Literal["tools/call"]
     params: CallToolRequestParams
-    webhooks: list[Webhook] | None = None
 
 
 class CallToolResult(Result):