o i@sddlmZddlZddlZddlZddlZddlmZmZddl m Z m Z ddl m Z ddlmZmZmZmZmZmZddlZddlZddlZddlZddlmZddlmZdd lmZddlZdd l m!Z!m"Z"dd l#m$Z$m%Z%m&Z&dd l'm(Z(m)Z)dd l*m+Z+m,Z,ddl-m.Z.m/Z/m0Z0ddl1m2Z2m3Z3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:Z:ddl;mZ>ddl?m@Z@ddlAmBZBddlCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOgdZPe@eQZRedddZSd)d!d"ZTe Gd#d$d$ZUGd%d&d&eeEZVe Gd'd(d(ZWdS)*) annotationsN)AsyncExitStackasynccontextmanager) dataclassfield)Path)AnyGenericLiteralTypeVarcastoverload)catch) ClientSession)AnyUrl)ElicitationHandlercreate_elicitation_callback) LogHandlercreate_log_callbackdefault_log_handler)MessageHandlerMessageHandlerT)ProgressHandlerdefault_progress_handler) RootsHandler RootsListcreate_roots_callback)ClientSamplingHandlerSamplingHandlercreate_sampling_callback) ToolError) MCPConfig)FastMCP)get_catch_handlers)json_schema_to_type) get_logger)get_cached_typeadapter) ClientTransportClientTransportTFastMCP1ServerFastMCPTransportMCPConfigTransportNodeStdioTransportPythonStdioTransport SessionKwargs SSETransportStdioTransportStreamableHttpTransportinfer_transport) Clientrrrrrrrrr/Tr()boundtimeout'datetime.timedelta | float | int | Nonereturn float | NonecCs(|durdSt|tjr|St|SN) isinstancedatetime timedelta total_secondsfloat)r7rA[/var/www/html/karishye-ai-python/venv/lib/python3.10/site-packages/fastmcp/client/client.py_timeout_to_secondsPs  rCc@s~eZdZUdZdZded<dZded<eej dZ d ed <dZ d ed <eej dZ d ed<eej dZd ed<dZded<dS)ClientSessionStatezHolds all session-related state for a Client instance. This allows clean separation of configuration (which is copied) from session state (which should be fresh for each new client instance). NzClientSession | Nonesessionrintnesting_counter)default_factoryz anyio.Locklockzasyncio.Task | None session_taskz anyio.Event ready_event stop_event!mcp.types.InitializeResult | Noneinitialize_result)__name__ __module__ __qualname____doc__rE__annotations__rGranyioLockrIrJEventrKrLrNrArArArBrDZs    rDc@s4eZdZdZedd d Zeddd Zeddd Zeddd Zeddd Zeddd Z            ddd6d Zedd8d9Zedd;d<Zdd>d?Z ddBdCZ ddFdGZ ddHdIZ ddKdLZ edMdNZdOdPZdQdRZdSdTZdddWdXZdYdZZd[d\Z ddd^d_Zdd`daZ dddedfZ  dddmdnZddqdrZddsdtZddvdwZddydzZdd|d}ZdddZdddZ dddZ!dddZ"dddZ# ddddZ$ ddddZ% ddddZ& ddddZ'dddZ(dddZ)   ddddZ*     ddddZ+e,ddddZ-dS)r4al MCP client that delegates connection management to a Transport instance. The Client class is responsible for MCP protocol logic, while the Transport handles connection establishment and management. Client provides methods for working with resources, prompts, tools and other MCP capabilities. This client supports reentrant context managers (multiple concurrent `async with client:` blocks) using reference counting and background session management. This allows efficient session reuse in any scenario with nested or concurrent client usage. MCP SDK 1.10 introduced automatic list_tools() calls during call_tool() execution. This created a race condition where events could be reset while other tasks were waiting on them, causing deadlocks. The issue was exposed in proxy scenarios but affects any reentrant usage. The solution uses reference counting to track active context managers, a background task to manage the session lifecycle, events to coordinate between tasks, and ensures all session state changes happen within a lock. Events are only created when needed, never reset outside locks. This design prevents race conditions where tasks wait on events that get replaced by other tasks, ensuring reliable coordination in concurrent scenarios. Args: transport: Connection source specification, which can be: - ClientTransport: Direct transport instance - FastMCP: In-process FastMCP server - AnyUrl or str: URL to connect to - Path: File path for local socket - MCPConfig: MCP server configuration - dict: Transport configuration roots: Optional RootsList or RootsHandler for filesystem access sampling_handler: Optional handler for sampling requests log_handler: Optional handler for log messages message_handler: Optional handler for protocol messages progress_handler: Optional handler for progress notifications timeout: Optional timeout for requests (seconds or timedelta) init_timeout: Optional timeout for initial connection (seconds or timedelta). Set to 0 to disable. If None, uses the value in the FastMCP global settings. Examples: ```python # Connect to FastMCP server client = Client("http://localhost:8080") async with client: # List available resources resources = await client.list_resources() # Call a tool result = await client.call_tool("my_tool", {"param": "value"}) ``` self Client[T] transportr5argsrkwargsr9NonecOdSr;rArWrYrZr[rArArB__init__szClient.__init__.Client[SSETransport | StreamableHttpTransport]rcOr]r;rAr^rArArBr_Client[FastMCPTransport]FastMCP | FastMCP1ServercOr]r;rAr^rArArBr_ra1Client[PythonStdioTransport | NodeStdioTransport]rcOr]r;rAr^rArArBr_raClient[MCPConfigTransport]MCPConfig | dict[str, Any]cOr]r;rAr^rArArBr_raZClient[PythonStdioTransport | NodeStdioTransport | SSETransport | StreamableHttpTransport]strcOr]r;rAr^rArArBr_s NT^ClientTransportT | FastMCP | FastMCP1Server | AnyUrl | Path | MCPConfig | dict[str, Any] | strname str | NonerootsRootsList | RootsHandler | Nonesampling_handlerClientSamplingHandler | Noneelicitation_handlerElicitationHandler | None log_handlerLogHandler | Nonemessage_handler'MessageHandlerT | MessageHandler | Noneprogress_handlerProgressHandler | Noner7r8auto_initializebool init_timeout client_infomcp.types.Implementation | Noneauth*httpx.Auth | Literal['oauth'] | str | NonecCs|p||_ttt||_| dur|j| |durt}|dur%t}||_ t | t t Br7t jt | d} | dur?tjj} t| |_| |_ddt||| | d|_|dur\|||durgt||jd<|durrt||jd<t|_dS)Nseconds)sampling_callbacklist_roots_callbacklogging_callbackrtread_timeout_secondsr{relicitation_callback) generate_namerjr r)r3rY _set_authrr_progress_handlerr<rFr@r=r>fastmcpsettingsclient_init_timeoutrC _init_timeoutrxr_session_kwargs set_rootsrrrD_session_state)rWrYrjrlrnrprrrtrvr7rxrzr{r}rArArBr_sB     rcCs|jjdur td|jjS)zEGet the current active session. Raises RuntimeError if not connected.NzLClient is not connected. Use the 'async with client:' context manager first.)rrE RuntimeErrorrWrArArBrE"s zClient.sessionrMcCs|jjS)z-Get the result of the initialization request.)rrNrrArArBrN,szClient.initialize_resultRootsList | RootsHandlercCt||jd<dS)zYSet the roots for the client. This does not automatically call `send_roots_list_changed`.rN)rr)rWrlrArArBr1szClient.set_rootsrrcCr)z)Set the sampling callback for the client.rN)rr)rWrrArArBset_sampling_callback5szClient.set_sampling_callbackrrcCr)z,Set the elicitation callback for the client.rN)rr)rWrrArArBset_elicitation_callback;szClient.set_elicitation_callbackcCs |jjduS)z+Check if the client is currently connected.N)rrErrArArB is_connectedCs zClient.is_connectedClient[ClientTransportT]cCs<t|}t|jtst|_|jdtd7_|S)aCreate a new client instance with the same configuration but fresh session state. This creates a new client with the same transport, handlers, and configuration, but with no active session. Useful for creating independent sessions that don't share state with the original client. Returns: A new Client instance with the same configuration but disconnected state. Example: ```python # Create a fresh client for each concurrent operation fresh_client = client.new() async with fresh_client: await fresh_client.call_tool("some_tool", {}) ``` :) copyr<rYr1rDrrjsecrets token_hex)rW new_clientrArArBnewGs  z Client.newc Cstto|jjdi|j4IdHE}||j_z,z|jr&|IdHdVWnt j y<}zt d|d}~wwWd|j_d|j_ n d|j_d|j_ wWdIdHn1IdHs`wYWddSWddS1sxwYdS)Nz&Server session was closed unexpectedlyrA) rr#rYconnect_sessionrrrErx initializerTClosedResourceErrorrrN)rWrEerArArB_context_managercs0      *"zClient._context_managercs|IdHSr;)_connectrrArArB __aenter__uszClient.__aenter__cs|IdHdSr;) _disconnect)rWexc_typeexc_valexc_tbrArArB __aexit__xszClient.__aexit__c s|jj4IdHs|jjdup|jj}|ri|jjdkr'td|jjt|j_t|j_ t | |j_|jj IdH|jjri|jj}|durYtdt|tjra|td|||jjd7_WdIdH|S1IdHswY|S)aT Establish or reuse a session connection. This method implements the reentrant context manager pattern: - First call: Creates background session task and waits for it to be ready - Subsequent calls: Increments reference counter and reuses existing session - All operations protected by _context_lock to prevent race conditions The critical fix: Events are only created when starting a new session, never reset outside the lock, preventing the deadlock scenario where tasks wait on events that get replaced by other tasks. NrzKInternal error: nesting counter should be 0 when starting new session, got z>Session task completed without exception but connection failedzClient failed to connect: r')rrIrJdonerGrrTrVrLrKasyncio create_task_session_runnerwait exceptionr<httpxHTTPStatusError)rW need_to_startrrArArBr{sD           zClient._connectFforcec s|jj4IdHS|rd|j_n td|jjd|j_|jjdkr. WdIdHdS|jjdur@ WdIdHdS|jj|jjIdHd|j_WdIdHdS1IdHsbwYdS)a Disconnect from session using reference counting. This method implements proper cleanup for reentrant context managers: - Decrements reference counter for normal exits - Only stops session when counter reaches 0 (no more active contexts) - Force flag bypasses reference counting for immediate shutdown - Session cleanup happens inside the lock to ensure atomicity Key fix: Removed the problematic "Reset for future reconnects" logic that was resetting events outside the lock, causing race conditions. Event recreation now happens only in _connect() when actually needed. Nrr')rrIrGmaxrJrLset)rWrrArArBrs"      .zClient._disconnectc szHt4IdH$}||IdH|jj|jjIdHWdIdHn1IdHs3wYW|jjdSW|jjdS|jjw)aF Background task that manages the actual session lifecycle. This task runs in the background and: 1. Establishes the transport connection via _context_manager() 2. Signals that the session is ready via _ready_event.set() 3. Waits for disconnect signal via _stop_event.wait() 4. Ensures _ready_event is always set, even on failures The simplified error handling (compared to the original) removes redundant exception re-raising while ensuring waiting tasks are always unblocked via the finally block. N)renter_async_contextrrrKrrLr)rWstackrArArBrs *zClient._session_runnercs(|jddIdH|jIdHdS)NT)r)rrYcloserrArArBrsz Client.closemcp.types.InitializeResultc s|jdur |jS|dur|j}z)tt||jIdH}||j_|WdWS1s2wYWdStyJ}zt d|d}~ww)aXSend an initialize request to the server. This method performs the MCP initialization handshake with the server, exchanging capabilities and server information. It is idempotent - calling it multiple times returns the cached result from the first call. The initialization happens automatically when entering the client context manager unless `auto_initialize=False` was set during client construction. Manual calls to this method are only needed when auto-initialization is disabled. Args: timeout: Optional timeout for the initialization request (seconds or timedelta). If None, uses the client's init_timeout setting. Returns: InitializeResult: The server's initialization response containing server info, capabilities, protocol version, and optional instructions. Raises: RuntimeError: If the client is not connected or initialization times out. Example: ```python # With auto-initialization disabled client = Client(server, auto_initialize=False) async with client: result = await client.initialize() print(f"Server: {result.serverInfo.name}") print(f"Instructions: {result.instructions}") ``` Nz#Failed to initialize server session) rNrrT fail_afterrCrErr TimeoutErrorr)rWr7rNrrArArBrs $( zClient.initializecs |jIdH}t|tjjS)zSend a ping request.N)rE send_pingr<mcptypes EmptyResultrWresultrArArBping!sz Client.ping request_id str | intreasoncs>tjjtjjdtjj||ddd}|j|IdHdS)zrE call_toolr)rWrjrrvr7rrrArArB call_tool_mcpms zClient.call_tool_mcpraise_on_errorCallToolResultc s:|j||pi|||dIdH}d}|jr&|r&ttjj|jdj} t| |j rzH||j j vr8|j IdH||j j vrp|j j |} | rm| dr\| di d} |j d} n|j } t| } t| } | | }n|j }Wnty}ztd|jd|WYd}~nd}~wwt|j|j |j||jd S) aCall a tool on the server. Unlike call_tool_mcp, this method raises a ToolError if the tool call results in an error. Args: name (str): The name of the tool to call. arguments (dict[str, Any] | None, optional): Arguments to pass to the tool. Defaults to None. timeout (datetime.timedelta | float | int | None, optional): The timeout for the tool call. Defaults to None. progress_handler (ProgressHandler | None, optional): The progress handler to use for the tool call. Defaults to None. raise_on_error (bool, optional): Whether to raise a ToolError if the tool call results in an error. Defaults to True. meta (dict[str, Any] | None, optional): Additional metadata to include with the request. This is useful for passing contextual information (like user IDs, trace IDs, or preferences) that shouldn't be tool arguments but may influence server-side processing. The server can access this via `context.request_context.meta`. Defaults to None. Returns: CallToolResult: The content returned by the tool. If the tool returns structured outputs, they are returned as a dataclass (if an output schema is available) or a dictionary; otherwise, a list of content blocks is returned. Note: to receive both structured and unstructured outputs, use call_tool_mcp instead and access the raw result object. Raises: ToolError: If the tool call results in an error. RuntimeError: If called while the client is not connected. )rjrr7rvrNrzx-fastmcp-wrap-result propertiesrrz$] Error parsing structured content: )contentstructured_contentrdatais_error)risErrorr rr TextContentr textr structuredContentrE_tool_output_schemasrgetr$r&validate_pythonrrerrorrjrr)rWrjrr7rvrrrr"msg output_schemar! output_type type_adapterrrArArBrsR%       $zClient.call_toolcCs<|j}|dur|dtdS|d|dtdS)N-r)rOrr)clsrj class_namerArArBrszClient.generate_name) rWrXrYr5rZrr[rr9r\) rWr`rYrrZrr[rr9r\) rWrbrYrcrZrr[rr9r\) rWrdrYrrZrr[rr9r\) rWrerYrfrZrr[rr9r\) rWrgrYrhrZrr[rr9r\) NNNNNNNNTNNN)rYrirjrkrlrmrnrorprqrrrsrtrurvrwr7r8rxryrzr8r{r|r}r~r9r\)r9r)r9rM)rlrr9r\)rrr9r\)rrr9r\)r9ry)r9r)F)rryr;)r7r8r9r)rrrrkr9r\)NN) rrrr@rr:rrkr9r\)rrr9r\)r9r\)r9r)r9r)r9r)r9r)rrr9r)rrr9r)r9r)r9r)rjrhrrr9r)rrrr r rr9r )rrrr r rr9r)r9r)r9r)NNN) rjrhrrrvrwr7r8rrr9r)NNNTN)rjrhrrr7r8rvrwrryrrr9r)rjrkr9rh).rOrPrQrRr r_propertyrErNrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrr classmethodrrArArArBr4ks;       K         0& 1        '  %     0 Nr4c@s>eZdZUded<ded<ded<dZded<d Zd ed <dS) rzlist[mcp.types.ContentBlock]r rr!rNrr"Fryr#)rOrPrQrSr"r#rArArArBrs  r)r7r8r9r:)X __future__rrrr=r contextlibrr dataclassesrrpathlibrtypingrr r r r r rTr mcp.typesrrexceptiongrouprrpydanticrrfastmcp.client.elicitationrrfastmcp.client.loggingrrrfastmcp.client.messagesrrfastmcp.client.progressrrfastmcp.client.rootsrrrfastmcp.client.samplingrrrfastmcp.exceptionsr fastmcp.mcp_configr!fastmcp.serverr"fastmcp.utilities.exceptionsr#"fastmcp.utilities.json_schema_typer$fastmcp.utilities.loggingr%fastmcp.utilities.typesr& transportsr(r)r*r+r,r-r.r/r0r1r2r3__all__rOrr5rCrDr4rrArArArBs^             8