i UddlmZddlZddlZddlmZmZmZmZddl m Z ddl m Z m Z ddlmZddlmZddlmZmZmZddlZdd lmZmZdd lmZdd lmZdd lmZmZmZm Z dd lm!Z"ddlm#Z$ddl%m&Z&ddl'm(Z(ddl)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0m1Z1m2Z2m3Z3m4Z4ddl5m6Z6ddl7m8Z8m9Z9m:Z:ddl;mm?Z?m@Z@ddlAmBZBddlAmCZDddlAmEZFddlAmGZHddlAmIZJddlAmKZLddlMmNZNmOZOdd lPmQZQeOeR!ZSd"eTd#<eSjd$%ZVd"eTd&<eNeVd'(e*d)e*ZWe*d+eX*ZYdd,l;mZZZe d-d*Z[d.eTd/<ed0Z\e d1d*Z]d2eTd3< d=d4Z^d>d5Z_eGd6d7Z`ejejejejejejejejd8Zfe d?d:ZgeGd;d9Zh d@ dAd<Ziy)B) annotationsN)Callable GeneratorMappingSequence)contextmanager) ContextVarToken) dataclass)Logger)AnyLiteraloverload) LoggingLevel ServerSession) request_ctx)RequestContext)GetPromptResultModelPreferencesRootSamplingMessage)Prompt)Resource)AnyUrl)Request)TypeVar) SharedContext)ResourceResult)AcceptedElicitationCancelledElicitationDeclinedElicitationhandle_elicit_acceptparse_elicit_response_type)MiddlewareServerSession) SampleStepSamplingResult SamplingTool) sample_implsample_step_impl)FastMCP StateValue) Visibility)disable_components)enable_components)get_session_transforms)get_visibility_rules)reset_visibility) _clamp_logger get_logger) VersionSpec)namer logger to_client)suffixto_client_loggerDEBUG)r6 max_levelT)defaultResultT)ToolChoiceOptioncontextzContextVar[Context | None]_current_context)stdiossezstreamable-http transportz ContextVar[TransportType | None]_current_transportc,tj|S)z8Set the current transport type. Returns token for reset.)rEset)rDs f/Users/bowang/.openclaw/workspace/ChatDev/.venv/lib/python3.12/site-packages/fastmcp/server/context.py set_transportrIXs  ! !) ,,c.tj|y)z"Reset transport to previous value.N)rEreset)tokens rHreset_transportrN_sU#rJc*eZdZUdZded<dZded<y)LogDatazData object for passing log arguments to client-side handlers. This provides an interface to match the Python standard library logging, for compatibility with structured logging. strmsgNMapping[str, Any] | Noneextra)__name__ __module__ __qualname____doc____annotations__rTrJrHrPrPds H&*E #*rJrP)debuginfonoticewarningerrorcriticalalert emergencyContextc#Ktj|} |tj|y#tj|wxYwwN)rArGrL)r@rMs rH set_contextrf|s=   )E& u%u%sA 3A A  A c eZdZUdZdZded< d@ddd dAdZedBdZedCd Z edCd Z edDd Z dEd Z dFd Z edGdZedHdZ dI dJdZ dKdZdLdZdMdZ d@ dNdZdOdZ dP dQdZedRdZdSdZedCdZedTdZedTdZedUdZ dI dVdZ dI dVdZ dI dVdZ dI dVd Z dWd!Z! dXd"Z"dFd#Z#ddddddd$ddd% dYd&Z$e%dddddddd' dZd(Z&e%ddddddddd) d[d*Z&ddddddddd) d\d+Z&e% d]d,Z' e% d^d-Z' e% d_d.Z' e% d`d/Z' e% dad0Z' e% dbd1Z' d@ dcd2Z' ddd3Z(ded4Z)d$d5 dfd6Z*dgd7Z+dhd8Z,did9Z-djd:Z.dddddd;d< dkd=Z/dddddd;d< dkd>Z0dFd?Z1y)lrcakContext object providing access to MCP capabilities. This provides a cleaner interface to MCP's RequestContext functionality. It gets injected into tool and resource functions that request it via type hints. To use context in a tool function, add a parameter with the Context type annotation: ```python @server.tool async def my_tool(x: int, ctx: Context) -> str: # Log messages to the client await ctx.info(f"Processing {x}") await ctx.debug("Debug info") await ctx.warning("Warning message") await ctx.error("Error message") # Report progress await ctx.report_progress(50, 100, "Processing") # Access resources data = await ctx.read_resource("resource://data") # Get request info request_id = ctx.request_id client_id = ctx.client_id # Manage state across the session (persists across requests) await ctx.set_state("key", "value") value = await ctx.get_state("key") # Store non-serializable values for the current request only await ctx.set_state("client", http_client, serializable=False) return str(x) ``` State Management: Context provides session-scoped state that persists across requests within the same MCP session. State is automatically keyed by session, ensuring isolation between different clients. State set during `on_initialize` middleware will persist to subsequent tool calls when using the same session object (STDIO, SSE, single-server HTTP). For distributed/serverless HTTP deployments where different machines handle the init and tool calls, state is isolated by the mcp-session-id header. The context parameter name can be anything as long as it's annotated with Context. The context is optional - tools that don't need it can omit the parameter. iQint_STATE_TTL_SECONDSN)task_idorigin_request_idc~tj||_||_g|_||_||_i|_yre)weakrefref_fastmcp_session_tokens_task_id_origin_request_id_request_state)selffastmcpsessionrjrks rH__init__zContext.__init__s9/6kk'.B .5 $& $+ .?.0rJc|jduS)a<True when this context is running in a background task (Docket worker). When True, certain operations like elicit() and sample() will use task-aware implementations that can pause the task and wait for client input. Example: ```python @server.tool(task=True) async def my_task(ctx: Context) -> str: # Works transparently in both foreground and background task modes result = await ctx.elicit("Need input", str) return str(result) ``` Nrrrus rHis_background_taskzContext.is_background_tasks"}}D((rJc|jS)zGet the background task ID if running in a background task. Returns None if not running in a background task context. rzr{s rHrjzContext.task_ids }}rJcp|jt|jjS|jS)a Get the request ID that originated this execution, if available. In foreground request mode, this is the current request_id. In background task mode, this is the request_id captured when the task was submitted, if one was available. )request_contextrQ request_idrsr{s rHrkzContext.origin_request_ids3    +t++667 7&&&rJc@|j}| td|S)zGet the FastMCP instance.z'FastMCP instance is no longer available)ro RuntimeError)rurvs rHrvzContext.fastmcps%--/ ?HI IrJc|Ktjd}||j|_tj|}|jj |ddlm}m}m }m }|jtj|j|_|j}|rZ|j |j|j|_|j" |j|j"|_|St'|_|j(j+d{|S7w)zFEnter the context manager and set this context as the current context.Nr)_current_docket_current_server_current_workeris_docket_available)rAgetrtrGrqappendfastmcp.server.dependenciesrrrrrmrnrv _server_token_docket _docket_token_worker _worker_tokenr_shared_context __aenter__)ruparentrMrrrrservers rHrzContext.__aenter__s"%%d+  "("7"7D !$$T* E"  -00T\\1JK   ~~)%4%8%8%H"~~)%4%8%8%H" $1?D &&113 3 3  4sD1D<3D:4D<cKddlm}m}m}t |dr|j |j |`t |dr|j |j|`t |dr'|jj|||d{|`t |dr|j |j|` |jr0|jj}tj |yy7lw)z9Exit the context manager and reset the most recent token.r)rrrrrrNr)rrrrhasattrrLrrr __aexit__rrqpoprA)ruexc_typeexc_valexc_tbrrrrMs rHrzContext.__aexit__$s   4 )  ! !$"4"4 5" 4 )  ! !$"4"4 5" 4* +&&007FK K K$ 4 )  ! !$"4"4 5" <<LL$$&E  " "5 )  LsB C: C8 A-C:cJ tjS#t$rYywxYw)aAccess to the underlying request context. Returns None when the MCP session has not been established yet. Returns the full RequestContext once the MCP session is available. For HTTP request access in middleware, use `get_http_request()` from fastmcp.server.dependencies, which works whether or not the MCP session is available. Example in middleware: ```python async def on_request(self, context, call_next): ctx = context.fastmcp_context if ctx.request_context: # MCP session available - can access session_id, request_id, etc. session_id = ctx.session_id else: # MCP session not available yet - use HTTP helpers from fastmcp.server.dependencies import get_http_request request = get_http_request() return await call_next(context) ``` N)rr LookupErrorr{s rHrzContext.request_context@s&0 ??$ $  s  ""cn|j}||jj}||SiS|jS)aAccess the server's lifespan context. Returns the context dict yielded by the server's lifespan function. Returns an empty dict if no lifespan was configured or if the MCP session is not yet established. In background tasks (Docket workers), where request_context is not available, falls back to reading from the FastMCP server's lifespan result directly. Example: ```python @server.tool def my_tool(ctx: Context) -> str: db = ctx.lifespan_context.get("db") if db: return db.query("SELECT 1") return "No database connection" ``` )rrv_lifespan_resultlifespan_context)rurcresults rHrzContext.lifespan_context]sA, ! ! :\\22F! I"""rJcK|jr6|jjr |jjjnd}|3|jj |||||j d{yddlm}|sy ddlm }|j}|,|jjt|d{t|}t|dd} || z } | dkDr#|jj| d{||_|$|jj#|d{yy77y767 #t$$rYywxYww)aiReport progress for the current operation. Works in both foreground (MCP progress notifications) and background (Docket task execution) contexts. Args: progress: Current progress value e.g. 24 total: Optional total value e.g. 100 message: Optional status message describing current progress N)progress_tokenprogresstotalmessagerelated_request_idr)r)current_execution_fastmcp_last_progress)rmeta progressTokenrwsend_progress_notificationrrrdocket.dependenciesrrr set_totalrhgetattr incrementr set_messager) rurrrrrr executioncurrentlastdeltas rHreport_progresszContext.report_progress}sb ##(<(<(A(A  % % 3 3   %,,99-!#'?? :    D"$   =)--/I  ((223u:>>>(mG +CQGDdNEqy((225999/6I ,"((44W===#E 2? :>   smA4E6E7E ?E E AE E+E ;E<E EE E E EEEEcKg}d}t} ||}||d{}|j|||js |S|j|vr |S|j|j|j}w7cw)aVGeneric pagination helper for list operations. Args: request_factory: Function that creates a request from a cursor call_method: Async method to call with the request extract_items: Function to extract items from the result Returns: List of all items across all pages N)rGextend nextCursoradd) rurequest_factory call_method extract_items all_itemscursor seen_cursorsrequestrs rH_paginate_listzContext._paginate_lists " !!$ %f-G&w//F   ]62 3$$    L0   V.. /&&F/s#B B A$B crK|jd|jjdd{S7w)zList all available resources from the server. Returns: List of Resource objects available on the server ctjj|r%tjj|SdSNr)params)mcptypesListResourcesRequestPaginatedRequestParamsrs rHz(Context.list_resources..sC399+I+Iyy77v7F,J,,J,rJc|jSre) resourcesrs rHrz(Context.list_resources..s )9)9rJrrrN)rrv_list_resources_mcpr{s rHlist_resourceszContext.list_resourcessA ((  889)    .757crK|jd|jjdd{S7w)zList all available prompts from the server. Returns: List of Prompt objects available on the server ctjj|r%tjj|SdSr)rrListPromptsRequestrrs rHrz&Context.list_prompts..sC399+G+Gyy77v7F,H,,H,rJc|jSre)promptsrs rHrz&Context.list_prompts..srJrN)rrv_list_prompts_mcpr{s rH list_promptszContext.list_promptssA ((  667)    rcK|jj||d{}t|tjj r t d|jS7Cw)zGet a prompt by name with optional arguments. Args: name: The name of the prompt to get arguments: Optional arguments to pass to the prompt Returns: The prompt result NHUnexpected CreateTaskResult: Context calls should not have task metadata)rv render_prompt isinstancerrCreateTaskResultrto_mcp_prompt_result)rur5 argumentsrs rH get_promptzContext.get_prompts\||11$ BB fcii88 9Z **,, Cs A(A&AA(cK|jjt|d{}t|tj j r td|S75w)zRead a resource by URI. Args: uri: Resource URI to read Returns: ResourceResult with contents Nr)rv read_resourcerQrrrrr)ruurirs rHrzContext.read_resource sS||11#c(;; fcii88 9Z   str: if ctx.client_supports_extension(UI_EXTENSION_ID): return "UI-capable client" return "text-only client" F)rrwrr$client_supports_extension)ru extension_idrrws rHrz!Context.client_supports_extensionCs?& ! ! :**'#:;00>>rJc|jr7|jjr!t|jjddSdS)zGet the client ID if available. client_idN)rrrr{s rHrzContext.client_id^sD ##(<(<(A(A D((--{D A  rJcn|j tdt|jjS)zrGet the unique ID for this request. Raises RuntimeError if MCP request context is not available. zrequest_id is not available because the MCP session has not been established yet. Check `context.request_context` for None before accessing this attribute.)rrrQrr{s rHrzContext.request_idgs<    '\ 4''2233rJc:ddlm}|j}| |j}n$|j |j}n t dt |dd}||S|)|j}|r|jjd}|t|}||_ |S)aGet the MCP session ID for ALL transports. Returns the session ID that can be used as a key for session-based data storage (e.g., Redis) to share data between tool calls within the same client session. Returns: The session ID for StreamableHTTP transports, or a generated ID for other transports. Raises: RuntimeError if no session is available. Example: ```python @server.tool def store_data(data: dict, ctx: Context) -> str: session_id = ctx.session_id redis_client.set(f"session:{session_id}:data", json.dumps(data)) return f"Data stored for session {session_id}" ``` r)uuid4Nzmsession_id is not available because no session exists. This typically means you're outside a request context._fastmcp_state_prefixzmcp-session-id) uuidrrrwrprrrheadersrrQr)rurrrw session_idrs rHrzContext.session_idts0 **  "!))G ]] &mmGI  W&=tD  !   "!))G$__001AB   UWJ)3%rJc|jr|j |jS|j|jjS|j |jSt d)aAccess to the underlying session for advanced usage. In request mode: Returns the session from the active request context. In background task mode: Returns the session stored at Context creation. Raises RuntimeError if no session is available. zsession is not available because the MCP session has not been established yet. Check `context.request_context` for None before accessing this attribute.)r|rprrwrr{s rHrwzContext.sessionsi  " "t}}'@==     +''// / == $==  X  rJcJK|jd|||d{y7w)zSend a `DEBUG`-level message to the connected MCP Client. Messages sent to Clients are also logged to the `fastmcp.server.context.to_client` logger with a level of `DEBUG`.r[rrrrTNrrurrrTs rHr[z Context.debug/hh#    #!#cJK|jd|||d{y7w)zSend a `INFO`-level message to the connected MCP Client. Messages sent to Clients are also logged to the `fastmcp.server.context.to_client` logger with a level of `DEBUG`.r\rNrrs rHr\z Context.infos/hh#    rcJK|jd|||d{y7w)zSend a `WARNING`-level message to the connected MCP Client. Messages sent to Clients are also logged to the `fastmcp.server.context.to_client` logger with a level of `DEBUG`.r^rNrrs rHr^zContext.warnings/hh#    rcJK|jd|||d{y7w)zSend a `ERROR`-level message to the connected MCP Client. Messages sent to Clients are also logged to the `fastmcp.server.context.to_client` logger with a level of `DEBUG`.r_rNrrs rHr_z Context.errorrrcjK|jjd{}|jS7w)zCList the roots available to the server, as indicated by the client.N)rw list_rootsroots)rurs rHrzContext.list_rootss*||..00||1s 313cK|jjtjj |d{y7w)zSend a notification to the client immediately. Args: notification: An MCP notification instance (e.g., ToolListChangedNotification()) N)rwsend_notificationrrServerNotification)ru notifications rHrzContext.send_notification s/ll,,SYY-I-I,-WXXXs str: for i in range(100): await ctx.report_progress(i, 100) # Close connection every 30 iterations to avoid LB timeouts if i % 30 == 0 and i > 0: await ctx.close_sse_stream() await do_work() return "Done" ``` Note: This is a no-op (with a debug log) if not using StreamableHTTP transport with an EventStore configured. zaclose_sse_stream() called but not applicable (requires StreamableHTTP transport with event_store)N)rclose_sse_streamr6r[r{s rHr zContext.close_sse_streamsN>##4+?+?+P+P LLG  ""33555sAA AA T) system_prompt temperature max_tokensmodel_preferencestools tool_choice execute_toolsmask_error_detailstool_concurrencyc JKt|||||||||| |  d{S7w)a Make a single LLM sampling call. This is a stateless function that makes exactly one LLM call and optionally executes any requested tools. Use this for fine-grained control over the sampling loop. Args: messages: The message(s) to send. Can be a string, list of strings, or list of SamplingMessage objects. system_prompt: Optional system prompt for the LLM. temperature: Optional sampling temperature. max_tokens: Maximum tokens to generate. Defaults to 512. model_preferences: Optional model preferences. tools: Optional list of tools the LLM can use. tool_choice: Tool choice mode ("auto", "required", or "none"). execute_tools: If True (default), execute tool calls and append results to history. If False, return immediately with tool_calls available in the step for manual execution. mask_error_details: If True, mask detailed error messages from tool execution. When None (default), uses the global settings value. Tools can raise ToolError to bypass masking. tool_concurrency: Controls parallel execution of tools: - None (default): Sequential execution (one at a time) - 0: Unlimited parallel execution - N > 0: Execute at most N tools concurrently If any tool has sequential=True, all tools execute sequentially regardless of this setting. Returns: SampleStep containing: - .response: The raw LLM response - .history: Messages including input, assistant response, and tool results - .is_tool_use: True if the LLM requested tool execution - .tool_calls: List of tool calls (if any) - .text: The text content (if any) Example: messages = "Research X" while True: step = await ctx.sample_step(messages, tools=[search]) if not step.is_tool_use: print(step.text) break # Continue with tool results messages = step.history ) messagesr r rrrrauto_execute_toolsrrN)r)) rurr r rrrrrrrs rH sample_stepzContext.sample_step>sA@& '#!/#,1-    s #!#)r r rrrrrc Kyw)z 0: Execute at most N tools concurrently If any tool has sequential=True, all tools execute sequentially regardless of this setting. Returns: SamplingResult[T] containing: - .text: The text representation (raw text or JSON for structured) - .result: The typed result (str for text, parsed object for structured) - .history: All messages exchanged during sampling Note: Background task support for sampling is planned for a future release. Currently, sampling in background tasks requires using the low-level session.create_message() API directly. ) rr r rrrrrrN)r(rs rHrzContext.samples>z! '#!/#1-    s " "c KywrerZrur response_types rHelicitzContext.elicit  rc KywrerZr"s rHr$zContext.elicits ORrc KywrerZr"s rHr$zContext.elicit  QTrc KywrerZr"s rHr$zContext.elicitr(rc KywrerZr"s rHr$zContext.elicit r%rc KywrerZr"s rHr$zContext.elicit,r%rcKt|}|jr&|j||jd{}n:|jj ||j|j d{}|jdk(rt||jS|jdk(r tS|jdk(r tStd|j77uw)a Send an elicitation request to the client and await the response. Call this method at any time to request additional information from the user through the client. The client must support elicitation, or the request will error. Note that the MCP protocol only supports simple object schemas with primitive types. You can provide a dataclass, TypedDict, or BaseModel to comply. If you provide a primitive type, an object schema with a single "value" field will be generated for the MCP interaction and automatically deconstructed into the primitive type upon response. If the response_type is None, the generated schema will be that of an empty object in order to comply with the MCP protocol requirements. Clients must send an empty object ("{}")in response. Args: message: A human-readable message explaining what information is needed response_type: The type of the response, which should be a primitive type or dataclass or BaseModel. If it is a primitive type, an object schema with a single "value" field will be generated. Note: This method works transparently in both request and background task contexts. In background task mode (SEP-1686), it will set the task status to "input_required" and wait for the client to provide input. )rschemaN)rrequestedSchemaracceptdeclinecancelzUnexpected elicitation action: ) r#r|_elicit_for_taskr-rwr$ractionr"contentr!r ValueError)rurr#configrs rHr$zContext.elicit9sZ,M:  " "00}}1F  <<.. & #'??/F ==H $'? ? ]]i '&( ( ]]h &') )>v}}oNO O' s"8C-C):C-5C+6A4C-+C-cK|js tdddlm}||j|j |||j d{S7w)aSend an elicitation request from a background task (SEP-1686). This method handles elicitation when running in a Docket worker context, where there's no active MCP request. It: 1. Sets the task status to "input_required" 2. Sends the elicitation request with task metadata 3. Waits for the client to provide input via tasks/sendInput 4. Returns the result and resumes task execution Args: message: The message to display to the user schema: The JSON schema for the expected response Returns: ElicitResult with the user's response Raises: RuntimeError: If not running in a background task context z<_elicit_for_task called but not in a background task contextr)elicit_for_task)rjrwrr-rvN)r|r fastmcp.server.tasks.elicitationr8rrrprv)rurr-r8s rHr2zContext._elicit_for_tasksY0&&N  E$MMMMLL     sA AAAc$|jd|S)z.Create session-prefixed key for state storage.:)r)rukeys rH_make_state_keyzContext._make_state_keys//"!C5))rJ) serializablecK|j|}|s||j|<y|jj|d |jjj |t ||jd{y7#t$r4}dt|jvrtd|d|d|d}~wwxYww)aSet a value in the state store. By default, values are stored in the session-scoped state store and persist across requests within the same MCP session. Values must be JSON-serializable (dicts, lists, strings, numbers, etc.). For non-serializable values (e.g., HTTP clients, database connections), pass ``serializable=False``. These values are stored in a request-scoped dict and only live for the current MCP request (tool call, resource read, or prompt render). They will not be available in subsequent requests. The key is automatically prefixed with the session identifier. N)value)r<r@ttl serializezValue for state key z$ is not serializable. Use set_state(z, value, serializable=False) to store non-serializable values. Note: non-serializable state is request-scoped and will not persist across requests.) r=rtrrv _state_storeputr+ri ExceptionrQlower TypeError)rur<r@r> prefixed_keyes rH set_statezContext.set_states"++C0 05D   -   d3 ,,++//  u-++0    c!flln,*3'2%%(G,KL    s<AC ?B BB C B C/CCC cK|j|}||jvr|j|S|jjj |d{}| |j SdS7w)zGet a value from the state store. Checks request-scoped state first (set with ``serializable=False``), then falls back to the session-scoped state store. Returns None if the key is not found. r<N)r=rtrvrCrr@)rur<rHrs rH get_statezContext.get_statesq++C0 4.. .&&|4 4||00444FF%1v||;t;GsAA1A/A1cK|j|}|jj|d|jjj |d{y7w)zrDelete a value from the state store. Removes from both request-scoped and session-scoped stores. NrL)r=rtrrvrCdelete)rur<rHs rH delete_statezContext.delete_statesO ++C0   d3ll''..<.@@@sAA!AA!c4Kt|d{S7w)z.Load visibility rule dicts from session state.N)_get_visibility_rulesr{s rHrRzContext._get_visibility_ruless*40000 c4Kt|d{S7w)zrgrfrh)r<rQrfr )r<rQrfrh)rfzlist[dict[str, Any]])rfzlist[Visibility])rWset[str] | NonerXrtrYzVersionSpec | NonerZrtr[z=set[Literal['tool', 'resource', 'template', 'prompt']] | Noner\rgrfrh)2rUrVrWrXrirYrxpropertyr|rjrkrvrrrrrrrrrrrrDrrrrrwr[r\r^r_rrr rrrr$r2r=rJrMrPrRrUr.r-r1rZrJrHrcrcs1h$# )-1 #(, 11&1  1 & 1"))$ ' '%N*88##@RV<<&2<DN< <|4*2   >  "=A--$9- -&&&*"&*.   #   (    :((?6   4 466p  :#'*.     (    &#'*.     (    &#'*.     (    &#'*.     (     Y<Y Y%6V%)$(!%GKDH59"*.'+L 7L " L " L  L EL BL 3L L (L %L  L \ %)$(!%GKDH*.'+ K7 K" K " K  KE KB K# K( K% K ! K K %)$(!%GKDH *.'+ J7 J" J " J  JE JB J J( J% J  J J&%)$(!%GKDH,0*.'+H 7H " H " H  H EH BH *H (H %H  7H T   Y   RRR M RR TT!T O TT ,TT1T O TT 1  ' T   H  7 T   DPDPDP DPL& & &  & P* =A(("(59( (T <A13"& $&* $$ $  $ $ $  $ $ $  $ R"& $&* $$ $  $ $ $  $ $ $  $ L&rJcKd|jd}|r |d|dz }tjt||d|j|j |j ||||d{y7w) z'Log a message to the server and client.zSending z to clientz ()z: )rrRrT)rrr6rN)upperr9r_mcp_level_to_python_levelrRrTsend_log_message)rrwrrr msg_prefixs rHrrOsEKKM?*5J;-q)) (/l"TXXJ 'jj  " " - # sA0A:2A83A:)rD TransportTyperfToken[TransportType | None])rMr}rfrh)r@rcrfzGenerator[Context, None, None]rj) rrPrwrrrrrerrerfrh)j __future__rloggingrmcollections.abcrrrr contextlibr contextvarsr r dataclassesr r typingr rr mcp.typesrrrmcp.server.lowlevel.serverrmcp.shared.contextrrrrrr SDKPromptr SDKResourcepydantic.networksrstarlette.requestsrtyping_extensionsr uncalled_forrfastmcp.resources.resourcerfastmcp.server.elicitationrr r!r"r#fastmcp.server.low_levelr$fastmcp.server.samplingr%r&r'fastmcp.server.sampling.runr(r)fastmcp.server.serverr*r+$fastmcp.server.transforms.visibilityr,r-rbr.r^r/rUr0rRr1rdfastmcp.utilities.loggingr2r3fastmcp.utilities.versionsr4rUr6rYgetChildr9r<rQr>r?rAr|rErIrNrPr:INFOWARNINGERRORCRITICALryrfrcrrZrJrHrs"BB%)!))+2- *-$&%&5=LL6@2**!??+?>&> %9 C )S )9/9)T/R,R9: 7A84 -- -$  ++ +]] LLll ]]    !! && F&F& F&Z&#%)      #   rJ