kKj UdZddlmZddlZddlZddlZddlmZmZm Z ddl m Z m Z m Z ddlZddlZddlZddlmZddlmZddlmZdd lmZmZdd lmZdd lmZmZmZmZdd l m!Z!dd l"m#Z#m$Z$ddl%m&Z&m'Z'ddl(m)Z)m*Z*ddl+m,Z,m-Z-ddl.m/Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7ddl8m9Z9m:Z:m;Z;ddlm?Z?m@Z@ddlAmBZBmCZCddlDmEZEddlFmGZGddlHmIZIddlJmKZKmLZLmMZMddlNmOZOddlPmQZQdd lRmSZSdd!lTmUZUdd"lVmWZWmXZXdd#lYmZZZm[Z[dd$l\m]Z]dd%l^m_Z_m`Z`e r dd&lambZbdd'l2mcZce]edZeege#fegee#fzZfdHd(ZgGd)d*eLZhGd+d,eWZiGd-d.e?ZjGd/d0e@ZkGd1d2e:ZlGd3d4Zmd5Znd6eod7<Gd8d9eQZp dId:ZqGd;dZt dLd?ZudMd@Zv dNdAZw dOdBZxdPdCZyGdDdEe#e3ZzGdFdGeze3Z{y)QzProxyProvider for proxying to remote MCP servers. This module provides the `ProxyProvider` class that proxies components from a remote MCP server via a client factory. It also provides proxy component classes that forward execution to remote servers. ) annotationsN) AwaitableCallableSequence) TYPE_CHECKINGAnycast) ServerSession) ClientSession) request_ctx)LifespanContextTRequestContext)McpError)METHOD_NOT_FOUNDBlobResourceContentsElicitRequestFormParamsTextResourceContents)AnyUrl)ClientFastMCP1Server) ElicitResultcreate_elicitation_callback) LogMessagecreate_log_callback) RootsListcreate_roots_callback)create_sampling_callback) client_span)ClientTransportT) ResourceError) MCPConfig)MessagePrompt PromptResult)PromptArgument)ResourceResourceTemplate)ResourceContentResourceResult)expand_uri_template)Context) get_context)CallNext MiddlewareMiddlewareContext)ProviderErrorStrategy)Provider)FastMCP) TaskConfig)Tool ToolResult)FastMCPComponentget_fastmcp_metadata) get_logger) VersionSpecversion_sort_key)Path)ClientTransportcttjjtjjt |S)N)codemessage)rmcptypes ErrorDataINTERNAL_ERRORstr)errors o/Users/ahmed/devFolder/Ultron/claude-voice/.venv/lib/python3.12/site-packages/fastmcp/server/providers/proxy.py_proxy_upstream_errorrGEs:  ))J   c(eZdZddZ ddZy)ProxyInitializeMiddlewarec||_yN)proxy)selfrMs rF__init__z"ProxyInitializeMiddleware.__init__Os  rHcjK|jjd{} t|tr3|j}|%|j |j f|jd<|4d{|jd{dddd{||d{S77>7(7#1d{7swY*xYw#t$rtttjtjtj tj"f$r}t%||d}~wwxYw7w)Nr)rM _get_client isinstanceStatefulProxyClientfastmcp_contextrequest_context_fastmcp _proxy_rc_ref initializer RuntimeError TimeoutErrorhttpx HTTPErroranyioClosedResourceError EndOfStreamBrokenResourceErrorrG)rNcontext call_nextclientctxrEs rF on_initializez'ProxyInitializeMiddleware.on_initializeRszz--// :&"56--?++ /F((+v'')))vw'''/0)vvv     OO  % %     % %   :(.E 9 :(sD3B,D3A C /B.0C 3B4B0B4 C B2C  D3'D1(D3.C 0B42C 4C:B= ;CC AD. D))D..D3N)rM FastMCPProxyreturnNone)raz.MiddlewareContext[mcp.types.InitializeRequest]rbzHCallNext[mcp.types.InitializeRequest, mcp.types.InitializeResult | None]rgz!mcp.types.InitializeResult | None)__name__ __module__ __qualname__rOrerHrFrJrJNs((?( ( +(rHrJceZdZUdZedZded<dZded<dfd Zdd Z dfd Z e dd Z d dd Z dfd ZxZS) ProxyToolz>A Tool that represents and executes a tool on a remote server. forbiddenmoder3 task_configN str | None _backend_namec 2t|di|||_yNrlsuperrO_client_factoryrNclient_factorykwargs __class__s rFrOzProxyTool.__init__ "6"-rHcK|j}tj|rtt|d{}|S7 wz?vvv  s-G1&G%G G% G !G%$D G1G 2G6 G%G:G%< G1G% G% GG%G" GG" G%%G.*G1c\t|d|jxs |jdzSNr)rzfastmcp.proxy.backend_namerxget_span_attributesrtrrNr}s rFrzProxyTool.get_span_attributes2w*,%4*.*<*<*I 0   rHr{ClientFactoryTr|rrgr)r|rrgrn)r{rrzmcp.types.ToolrgrnrL)rdict[str, Any]raContext | Nonergr5rgr)rirjrk__doc__r3rr__annotations__rtrOrQr classmethodrrr __classcell__r}s@rFrnrnysH(k:K: $M:$., + 7E   *#';!; ;  ;z  rHrnceZdZUdZedZded<dZded<dZd ed <dd  dfd Z dd Z dfd Z e ddZ ddZdfd ZxZS) ProxyResourcezEA Resource that represents and reads a resource from a remote server.rorpr3rrNResourceResult | None_cached_contentrs _backend_uri)rc @t|di|||_||_yrv)rxrOryr)rNr{rr|r}s rFrOzProxyResource.__init__s% "6"-.rHcK|j}tj|rtt|d{}|S7 wrrrs rFrQzProxyResource._get_clientrrc |jdi}d|vr,|j i|dt|ji}||d<t |di|S)z3Override to preserve _backend_uri when uri changes.rurirrl)rrrDrrxrrs rFrzProxyResource.model_copys[Hb) F?t008>>DHH >F%F8 w!+F++rHc|||j|j|j|j|jxsd|j |j t|j jdgtd S)zHFactory method to create a ProxyResource from a raw MCP resource schema. text/plainrrorp) r{rrrr mime_typerrrrr) rrrrmimeTyperrr7rr3)rr{ mcp_resources rFfrom_mcp_resourcezProxyResource.from_mcp_resource s{)  ""$$$00"++;|$$""%l&7&78<F?F<F&F!F& F<'F$(C)F< GF<F<!F&$F<&F9 ,F/-F9 4F<<GGcnt|d|jxst|jdzS)Nr)rzfastmcp.proxy.backend_uri)rxrrrDrrs rFrz!ProxyResource.get_span_attributesNs6w*,%4)-):):)Kc$((m0   rH)r{rrrr|rr)r|rrgr)r{rrzmcp.types.Resourcergr)rgr)r)rirjrkrr3rrrrrrOrQrrrrrrrs@rFrrsO(k:K:-1O*1#L*# 26 /& // /  /, & )     (+5Z  rHrceZdZUdZedZded<dZded<dfd Zdd Z dfd Z e dd Z d dd Z dfd ZxZS) ProxyTemplatezWA ResourceTemplate that represents and creates resources from a remote server template.rorpr3rrNrs_backend_uri_templatec 2t|di|||_yrvrwrzs rFrOzProxyTemplate.__init__[r~rHcK|j}tj|rtt|d{}|S7 wrrrs rFrQzProxyTemplate._get_client_rrc |jdi}d|vr#|ji|d|ji}||d<t|di|S)zEOverride to preserve _backend_uri_template when uri_template changes.r uri_templaterrl)rrrrxrrs rFrzProxyTemplate.model_copyfs[Hb) V #(B(B(JKK 79J9JKF%F8 w!+F++rHc|||j|j|j|j|jxsd|j i|j t|j jdgtd S)zHFactory method to create a ProxyTemplate from a raw MCP template schema.rrrorp) r{rrrrrrrrrrr) uriTemplaterrrrrrr7rr3)rr{ mcp_templates rFfrom_mcp_templatezProxyTemplate.from_mcp_templateos~ )%11""$$$00"++;|$$""%l&7&78<G G>GG> G( G"!G(% G>0G%1E,G>G>"G(%G>(G;.G1 /G;6G>c\t|d|jxs |jdzS)Nr)rz"fastmcp.proxy.backend_uri_template)rxrrrrs rFrz!ProxyTemplate.get_span_attributess4w*,%4**?d.?.?0   rHrr)r|rrgr)r{rrzmcp.types.ResourceTemplatergrrL)rrDrrrarrgrr)rirjrkrr3rrrrrOrQrrrrrrrs@rFrrUsa(k:K:(,:,., + ;U   .#' : : :  :  : x  rHrceZdZUdZedZded<dZded<dfd Zdd Z dfd Z e dd Z dd Z dfd ZxZS) ProxyPromptzCA Prompt that represents and renders a prompt from a remote server.rorpr3rrNrsrtc 2t|di|||_yrvrwrzs rFrOzProxyPrompt.__init__r~rHcK|j}tj|rtt|d{}|S7 wrrrs rFrQzProxyPrompt._get_clientrrc |jdi}d|vr#|ji|d|ji}||d<t|di|Srrrs rFrzProxyPrompt.model_copyrrHc |jxsgDcgc]2}t|j|j|jxsd4}}|||j|j |j||j |jt|jjdgtd Scc}w)zDFactory method to create a ProxyPrompt from a raw MCP prompt schema.F)rrrequiredrrorp) r{rrrrrrrrr) rr%rrrrrrr7rr3)rr{ mcp_promptargrs rFfrom_mcp_promptzProxyPrompt.from_mcp_prompts"++1r1  2 XXOO.  2  )"""..""%joo6::62F" 4   s7B<cDK|jxs |j}td|d||5}|jdd|j d{}|4d{|j ||d{}dddd{j Dcgc]#}t|j|j%}}t||j|jcdddS777{7m#1d{7swY}xYwcc}w#1swYyxYww) z6Render the prompt by making a call through the client.z prompts/get z prompts/get) prompt_namerrN)rrole)messagesrr) rtrrrrQ get_promptrr"rrr$rr)rNrrrrcrmrs rFrenderzProxyPrompt.renders))6TYY <. )  $     6 H++--Fv%00yIIv BHAPA 7  !"..[[!  .Ivvv   s-D &DC2 D C4!D$C::C6;C:? D C8 D(D#D( D 2D4D6C:8D:D DD  DDD c\t|d|jxs |jdzSrrrs rFrzProxyPrompt.get_span_attributesrrH)r{rr)r|rrgr)r{rrzmcp.types.Promptrgr)rrrgr$r)rirjrkrr3rrrrtrOrQrrrr rrrs@rFrrsiM(k:K: $M:$., + 9I   02  rHrc$eZdZdZdZddZddZy) _CacheEntryz;A cached sequence of components with a monotonic timestamp.items timestampc ||_||_yrLr)rNrrs rFrOz_CacheEntry.__init__%s "rHcJtj|jz |kSrL)time monotonicr)rNttls rFis_freshz_CacheEntry.is_fresh)s 4>>1S88rHN)rz Sequence[Any]rfloat)rrrgbool)rirjrkr __slots__rOrrlrHrFr r  sE&I#9rHr gr@r_DEFAULT_CACHE_TTLceZdZdZ d dfd ZddZddZ d ddZddZ d ddZ ddZ d dd Z dd Z d dd Z dd ZxZS)raProvider that proxies to a remote MCP server via a client factory. This provider fetches components from a remote server and returns Proxy* component instances that forward execution to the remote server. All components returned by this provider have task_config.mode="forbidden" because tasks cannot be executed through a proxy. Component lists (tools, resources, templates, prompts) are cached so that individual lookups (e.g. during ``call_tool``) can resolve from the cache instead of opening a new backend connection. The cache stores the backend's raw component metadata and is shared across all sessions; per-session visibility and auth filtering are applied after cache lookup by the server layer. The cache is refreshed whenever a ``list_*`` call is made, and entries expire after ``cache_ttl`` seconds (default 300). Set ``cache_ttl=0`` to disable caching. Disabling is recommended for backends whose component lists change dynamically. Example: ```python from fastmcp import FastMCP from fastmcp.server.providers.proxy import ProxyProvider, ProxyClient # Create a proxy provider for a remote server proxy = ProxyProvider(lambda: ProxyClient("http://localhost:8000/mcp")) mcp = FastMCP("Proxy Server") mcp.add_provider(proxy) # Can also add with namespace mcp.add_provider(proxy.with_namespace("remote")) ``` ct|||_||nt|_d|_d|_d|_d|_y)aInitialize a ProxyProvider. Args: client_factory: A callable that returns a Client instance when called. This gives you full control over session creation and reuse. Can be either a synchronous or asynchronous function. cache_ttl: How long (in seconds) to cache component lists for individual lookups. Defaults to 300. Set to 0 to disable caching. N) rxrOr{r _cache_ttl _tools_cache_resources_cache_templates_cache_prompts_cache)rNr{ cache_ttlr}s rFrOzProxyProvider.__init__SsG ,'0'<)BT6:>BFJ:>rHcK|j}tj|rtt|d{}|S7 wrr{rrr rrs rFrQzProxyProvider._get_clientjs:$$&   v &&,/F #/rcK |jd{}|4d{|jd{}|Dcgc]"}tj|j|$}}dddd{ttj|_ |S777jcc}w74#1d{7swYDxYw#t $r+}|j jtk(rg}nYd}~vd}~wwxYww)z&List all tools from the remote server.N) rQ list_toolsrnrr{rrEr>rr rrr)rNrc mcp_toolsttoolses rF _list_toolszProxyProvider._list_toolsus ++--Fv"("3"3"55 MVMVI++D,?,?CYv(t~~/?@ .5vvv  ww||// C:CB! CB#CB.B%B.'B'*B., C7B,8C<%C:!C#C%B.'B.,C.C4B7 5C<C C7 !C2-C:2C77C:cK|j}||j|js$|jd{|j}|J|jDcgc]}|j |k(s|}}|r+|Dcgc] }|j |js|"}}|syt|tS7~cc}wcc}wwN)key) rrrr+rrmatchesversionmaxr:)rNrr1cacher(matchings rF _get_toolzProxyProvider._get_tools!! =t ?""$ $ $%%E   ${{={!affnA{= #+J8awqyy/I8HJ8!122 %>J:=C B>"C "C7C;C  C$C(C  C cK |jd{}|4d{|jd{}|Dcgc]"}tj|j|$}}dddd{ttj|_ |S777jcc}w74#1d{7swYDxYw#t $r+}|j jtk(rg}nYd}~vd}~wwxYww)z*List all resources from the remote server.N) rQlist_resourcesrrr{rrEr>rr rrr)rNrc mcp_resourcesr resourcesr*s rF_list_resourceszProxyProvider._list_resourcess ++--Fv&,&;&;&= = +*"33D4G4GK*v!,It~~7G H. =vvv  ww||//  r,cK|j}||j|js$|jd{|j}|J|jDcgc]}t |j |k(s|}}|r+|Dcgc] }|j|js|"}}|syt|tS7cc}wcc}wwr.) rrrr<rrDrr0r1r2r:)rNrr1r3r:r4s rF _get_resourcezProxyProvider._get_resources%% =t ?&&( ( ())E   ${{@{!c!%%jC.?A{@ #+J8awqyy/I8HJ8!122 )AJs:=CC"C"C C C C-C1C CcK |jd{}|4d{|jd{}|Dcgc]"}tj|j|$}}dddd{ttj|_ |S777jcc}w74#1d{7swYDxYw#t $r+}|j jtk(rg}nYd}~vd}~wwxYww)z3List all resource templates from the remote server.N) rQlist_resource_templatesrrr{rrEr>rr rrr )rNrc mcp_templatesr( templatesr*s rF_list_resource_templatesz&ProxyProvider._list_resource_templatess ++--Fv&,&D&D&F F +*"33D4G4GK*v!,It~~7G H. Fvvv  ww||//  r,cK|j}||j|js$|jd{|j}|J|jDcgc]}|j ||}}|r+|Dcgc] }|j |j s|"}}|syt|tS7cc}wcc}wwr.) r rrrCrr0r1r2r:)rNrr1r3r(r4s rF_get_resource_templatez$ProxyProvider._get_resource_templates%% =t ?//1 1 1))E   ${{I{!aiin.HA{I #+J8awqyy/I8HJ8!122 2JJs:=C C"C "C9C=C  C&C*C  C cK |jd{}|4d{|jd{}|Dcgc]"}tj|j|$}}dddd{ttj|_ |S777jcc}w74#1d{7swYDxYw#t $r+}|j jtk(rg}nYd}~vd}~wwxYww)z(List all prompts from the remote server.N) rQ list_promptsrrr{rrEr>rr rrr!)rNrc mcp_promptsppromptsr*s rF _list_promptszProxyProvider._list_promptss ++--Fv$*$7$7$99 )( //0C0CQG(v*'4>>3CD.9vvv  ww||// r,cK|j}||j|js$|jd{|j}|J|jDcgc]}|j |k(s|}}|r+|Dcgc] }|j |js|"}}|syt|tS7~cc}wcc}wwr.) r!rrrKrrr0r1r2r:)rNrr1r3rIr4s rF _get_promptzProxyProvider._get_prompts## =t ?$$& & &''E   ${{={!affnA{= #+J8awqyy/I8HJ8!122 '>Jr6cKgSw)a5Return empty list since proxy components don't support tasks. Override the base implementation to avoid calling list_tools() during server lifespan initialization, which would open the client before any context is set. All Proxy* components have task_config.mode="forbidden". rlrNs rF get_taskszProxyProvider.get_taskss  srL)r{rr" float | Noner)rgzSequence[Tool])rrDr1VersionSpec | Nonergz Tool | None)rgzSequence[Resource])rrDr1rRrgzResource | None)rgzSequence[ResourceTemplate])rrDr1rRrgzResourceTemplate | None)rgzSequence[Prompt])rrDr1rRrgz Prompt | None)rgzSequence[FastMCPComponent])rirjrkrrOrQr+r5r<r>rCrErKrMrPrrs@rFrr0s J#'?&? ?.$8< 3 3"4 3  3&&7; 3 3!3 3  3&&7; 3 3!3 3  3&&8< 3 3"4 3  3&rHrct|tr|ddlm}ddlm}tj ||zrdj _jr.tturtjdd fd }|Sjrtjdd fd }|Sd fd }|Sttt|d fd }|S) a^Create a client factory from the given target. Internal helper that handles the session strategy based on the target type: - Connected Client: reuses existing session (with warning about context mixing) - Disconnected Client: creates fresh sessions per request - Other targets: creates ProxyClient and fresh sessions per request rStreamableHttpTransport SSETransportTzqProxy detected connected ProxyClient - creating fresh sessions for each request to avoid request context leakage.c$jSrLnewrcsrFfresh_client_factoryz4_create_client_factory..fresh_client_factory?szz|#rHzProxy detected connected client - reusing existing session for all requests. This may cause context mixing in concurrent scenarios.cSrLrlr[srFreuse_client_factoryz4_create_client_factory..reuse_client_factoryJs rHc$jSrLrYr[srFr\z4_create_client_factory..fresh_client_factoryOs::< rHc$jSrLrY) base_clientsrFproxy_client_factoryz4_create_client_factory..proxy_client_factoryWs??$ $rHr)rRrfastmcp.client.transports.httprUfastmcp.client.transports.sserW transportforward_incoming_headers is_connectedr ProxyClientloggerinfor r)targetrUrWr\r^rbrarcs @@rF_create_client_factoryrls(&&! K> f&&(?,(N O8$,*>: (# 8>? &&(rHcK|j}tj|rtt|d{}|S7 wrLr$rs rFrQzFastMCPProxy._get_clients:$$&   v &&,/F #/rc| dfd }|jjtjj<y)NcRKjd{}|4d{|jd{dddd{tjj tjj S7r7i7S7E#1d{7swYUxYwwrL)rQpingr@rA ServerResult EmptyResult)_requestrcrNs rF ping_remotez;FastMCPProxy._setup_proxy_ping_handler..ping_remotesq ++--Fvkkm##v99))#))*?*?*AB B.#vvvsdB'B  B'B B'BBB B' B AB' B'BB'B$B B$ B')r{zmcp.types.PingRequestrgzmcp.types.ServerResult) _mcp_serverrequest_handlersr@rA PingRequest)rNr|s` rFrsz&FastMCPProxy._setup_proxy_ping_handlers? C+ C # CDO))#))*?*?@rH)r{rror0rrgrh)rirjrkrrOrQrsrrs@rFrfrfbs2,:@ )')"7 ): OrHrfcRKt}|jd{S7w)zKForward list roots request from remote server to proxy's connected clients.N)r, list_roots)rards rFdefault_proxy_roots_handlerrs" -C! !! !s '%'cbKt}|jt||j|j|j |j d{}tjjd|jxsd}tjjdd|S7Uw) zIForward sampling request from remote server to proxy's connected clients.) system_prompt temperature max_tokensmodel_preferencesNr)rr assistantzfastmcp-client)rmodelr) r,samplelist systemPromptr maxTokensmodelPreferencesr@rA TextContentrCreateMessageResult)rrrardrrs rFdefault_proxy_sampling_handlerrs -C:: X))&&## 11 Fii##fkk6GR#HG 99 ( (  ) sAB/B-AB/cKt}t|tr |jndid}|jj |||j d{}t|j|jS7%w)zLForward elicitation request from remote server to proxy's connected clients.object)r properties)r?requestedSchemarelated_request_idN)actionr) r,rRrrsessionelicit request_idrrr)r? response_typerrardrequested_schemars rF!default_proxy_elicitation_handlerrs} -C f5 6 b 1 ;;%%(>>&F v}}fnn EE sABA?&BcKt}|jjd}|jjd}|j||j|j |d{y7w)zIForward log notification from remote server to proxy's connected clients.msgextra)level logger_namerN)r,datarlogrri)r?rdrrs rFdefault_proxy_log_handlerrsW -C ,,  5 !C LL  W %E ''#W]]e' TTTsA-A7/A50A7cZKt}|j|||d{y7w)zNForward progress notification from remote server to proxy's connected clients.N)r,report_progress)progresstotalr?rds rFdefault_proxy_progress_handlerrs' -C  hw 777s !+)+cFddl}ddlm}m}ddlm}|d}|y|\}} t j}|j|jurq|j|jk7rWt j||} | 8|j|| |j|j| yyyy#t$rXt j||} | 7|j|| |j|j| YywxYw)uSet the ``request_ctx``, ``_current_context`` and ``_current_server`` ContextVars from stashed values. Called at the start of proxy handler invocations in ``StatefulProxyClient`` to fix stale ContextVars in the receive-loop task. Only overrides when the ContextVar is genuinely stale (same session, different request_id) to avoid corrupting the concurrent case where multiple sessions share the same ref via ``copy.copy``. We stash a ``(RequestContext, weakref[FastMCP])`` tuple — never a ``Context`` instance — because ``Context`` properties are themselves ContextVar-dependent and would resolve stale values in the receive loop. Instead we construct a fresh ``Context`` here after restoring ``request_ctx``, so its property accesses read the correct values. This is a set-only repair of a long-lived task's ContextVars, not a scope: we never ``reset()`` because the prior values are stale and the loop keeps running. ``_current_server`` is restored alongside ``_current_context`` so handlers that resolve the server via dependency injection (e.g. ``get_server()``) see the right instance; it is set directly rather than via ``Context.__aenter__`` to avoid opening a context-manager lifecycle on an unscoped path. rN)r+_current_context)_current_server) weakreffastmcp.server.contextr+rfastmcp.server.dependenciesrr r LookupErrorsetrefrr) rc_refrr+rrstashedrc fastmcp_ref current_rcfastmcps rF_restore_request_contextrs4@;QiGOB  __& RZZ'J,A,AR]],R-    !1 2    G 4 5 -S' -    !1 2    G 4 5 sB??AD D cdfd }|S)zWrap a proxy handler to restore request_ctx before delegating. The wrapper is a plain ``async def`` so it passes ``inspect.isfunction()`` checks in handler registration paths (e.g., ``create_roots_callback``). cFKt|i|d{S7wrL)r)argsr|handlerrs rFwrapperz(_make_restoring_handler..wrapper-s% (d-f----s !!)rrr|rrgrrl)rrrs`` rF_make_restoring_handlerr%s. NrHc(eZdZdZ dfd ZxZS)rhzA proxy client that forwards advanced interactions between a remote MCP server and the proxy's connected clients. Supports forwarding roots, sampling, elicitation, logging, and progress. c Fd|vr|j|d<d|vr t|d<d|vr t|d<d|vr t|d<d|vr t|d<d|vr t |d<t |d d|i|dd lm }dd l m }t|j||zrd |j_yy) Nrrootssampling_handlerelicitation_handler log_handlerprogress_handlerrerrTrVTrl) generate_namerrrrrrxrOrcrUrdrWrRrerf)rNrer|rUrWr}s rFrOzProxyClient.__init__:s  !//1F6N & 9F7O V +)GF% &  .,MF( )  &$=F= ! V +)GF% & 7977 K> dnn&= &L M6:DNN 3 NrH)rezcClientTransportT | FastMCP[Any] | FastMCP1Server | AnyUrl | Path | MCPConfig | dict[str, Any] | str)rirjrkrrOrrs@rFrhrh4s !;!;!;rHrhcdeZdZUdZded<ded<d fd Zd dZdfd Zd d Zd Z dd Z xZ S)rSa A proxy client that provides a stateful client factory for the proxy server. The stateful proxy client bound its copy to the server session. And it will be disconnected when the session is exited. This is useful to proxy a stateful mcp server such as the Playwright MCP server. Note that it is essential to ensure that the proxy server itself is also stateful. Because session reuse means the receive-loop task inherits a stale ``request_ctx`` ContextVar snapshot, the default proxy handlers are replaced with versions that restore the ContextVar before forwarding. ``ProxyTool.run`` stashes the current ``RequestContext`` in ``_proxy_rc_ref`` before each backend call, and the handlers consult it to detect (and correct) staleness. list[Any]rWzset[str]_proxy_restoring_handler_keysc,dg|_t|_dtfdtfdt fdt fdtffD]>\}}||vs t||j||<|jj|@t|,|i|i|_ y)Nrrrrr) rWrrrrrrrraddrxrO_caches)rNrr|r/ default_fnr}s rFrOzStatefulProxyClient.__init__{s#V-0U* 1 2 !? @ "$E F 5 6 !? @  OC& 5j$BTBTUs 2266s;  $)&)FH rHcPd|jvr0ttt|j|j d<d|jvr0t tt|j|j d<d|jvr0ttt|j|j d<d|jvr0ttt|j|j d<d |jvr tt|j|_ yy) Nrlist_roots_callbackrsampling_callbackrelicitation_callbackrlogging_callbackr)rrrrrW_session_kwargsrrrrrrr_progress_handlerrOs rF_bind_restoring_handlersz,StatefulProxyClient._bind_restoring_handlerss d88 8:O'(CTEWEWX;D !6 7 !C!C C8P'2D4F4F9D !4 5 !D$F$F F;V'5t7I7I<D !7 8 D>> >7J'(A4CUCUV8D !3 4 !C!C C%<.0B0B&D " DrHc~tttt|}dg|_|j |SrL)r rSrrxrZrWr)rN new_clientr}s rFrZzStatefulProxyClient.news8-.>?O $(6  ++-rHc Kyw)zzThe stateful proxy client will be forced disconnected when the session is exited. So we do nothing here. Nrl)rNexc_type exc_value tracebacks rF __aexit__zStatefulProxyClient.__aexit__sscK|jrE|jj\}}|jdd{|jrDyy7w)z3Clear all cached clients and force disconnect them.TforceN)rpopitem _disconnect)rN_r3s rFclearzStatefulProxyClient.clearsFll||++-HAu##$#/ / /ll /s?AAAAc&tjjjd[j t j dj<fd}jj|S)zCreate a new stateful proxy client instance with the same configuration. Use this method as the client factory for stateful proxy server. Nz created for cKjjdtjdt j d5j dd{dddy7 #1swYyxYww)Nz will be disconnectT)shieldr)rpopridebugr] CancelScoper) proxy_clientrNrsrF_on_session_exitz:StatefulProxyClient.new_stateful.._on_session_exitsj   $/ ~-@AB &&d3&222>>>43>43s0A BA4$A2%A4) B2A44A=9B) r,rrrrZrir _exit_stackpush_async_callback)rNrrrs` @@rF new_statefulz StatefulProxyClient.new_statefuls -''||''6  88:L LLL>wi@ A$0DLL ! ?    3 34D ErH)rrr|rr)rgz%StatefulProxyClient[ClientTransportT])rgzClient[ClientTransportT]) rirjrkrrrOrrZrrrrrs@rFrSrS^s52#++I&4  0 rHrS)rE Exceptionrgr)rkz}Client[ClientTransportT] | ClientTransport | FastMCP[Any] | FastMCP1Server | AnyUrl | Path | MCPConfig | dict[str, Any] | strrgr)ra/RequestContext[ClientSession, LifespanContextT]rgr)rzlist[mcp.types.SamplingMessage]rz$mcp.types.CreateMessageRequestParamsrarrgzmcp.types.CreateMessageResult) r?rDrrrzmcp.types.ElicitRequestParamsrarrgr)r?rrgrh)rrrrQr?rsrgrh)rrrgrh)rrrrrgr)|r __future__rrrrcollections.abcrrrtypingrrr r]r[ mcp.typesr@r mcp.client.sessionr mcp.server.lowlevel.serverr mcp.shared.contextr rmcp.shared.exceptionsrrrrrpydantic.networksrfastmcp.client.clientrrfastmcp.client.elicitationrrfastmcp.client.loggingrrfastmcp.client.rootsrrfastmcp.client.samplingrfastmcp.client.telemetryrfastmcp.client.transportsrfastmcp.exceptionsr fastmcp.mcp_configr!fastmcp.promptsr"r#r$fastmcp.prompts.baser%fastmcp.resourcesr&r'fastmcp.resources.baser(r)fastmcp.resources.templater*rr+rr,fastmcp.server.middlewarer-r.r/"fastmcp.server.providers.aggregater0fastmcp.server.providers.baser1fastmcp.server.serverr2fastmcp.server.tasks.configr3fastmcp.tools.baser4r5fastmcp.utilities.componentsr6r7fastmcp.utilities.loggingr8fastmcp.utilities.versionsr9r:pathlibr;r<ririrrGrJrnrrrr rrrrlrfrrrrrrrrhrSrlrHrFrs\#  99++ ,2?* %8PBA<06,(99/8B:*3MMD2)2/O0D9 H "f*%Yv5F1F(GG#( #(Vn n bh Hh Vp $p fP &P p 9 9"E!_H_T@$ @$@$P?O7?ON" <""- 0=# .F FF *F= F  F,U88 88 826 26 26j ';&)*';Tv+&67vrH