iۺ$UdZddlmZddlZddlZddlZddlZddlmZm Z ddlm Z m Z ddl m Z mZddlmZddlmZmZdd lmZdd lmZmZmZmZmZmZdd lmZdd lm Z dd l!m"Z#ddl$m%Z%ddl&m'Z'ddl(m)Z)m*Z*ddl+m,Z,ddl-m.Z.dd l/m"Z"ddl0m1Z1ddl2m3Z3ddl4m5Z5m6Z6ejne8Z9erddl:m;Z;ddlm?Z?ddl@mAZAddlBmCZCgdZDeddGddZEdkd ZFiZGd!eHd"<dld#ZIdmd$ZJe d%d&ZKd'eHd(<e d)d&ZLd*eHd+<e d,d&ZMd-eHd.<e d/d&ZNd0eHd1<daOd2eHd3<dnd4ZPdod5ZQ dd6lRmSZTdpd7ZVdqd8ZWdrd:ZXdsd<ZYdtd=ZZ du dvd>Z[dwd?Zed@AdpdBZ\e dxdCZ]e dxdDZ^ dydEZ_dzdFZ`GdGdHe)d9ZaGdIdJe)dKZbdrdLZcd{dMZdGdNdOe)dPZed|dQZfGdRdSe)dTZgd}dUZhGdVdWe)d;ZidsdXZjGdYdZe)e'Zkdtd[ZlGd\d]e)emenenfZod~d^ZpeGd_d`eZqGdadbZrGdcdde)ddZSGdedfe)e"ZsddgZtGdhdie)enZuddjZvy#eU$rdZTY:wxYw)aDependency injection for FastMCP. DI features (Depends, CurrentContext, CurrentFastMCP) work without pydocket using the uncalled-for DI engine. Only task-related dependencies (CurrentDocket, CurrentWorker) and background task execution require fastmcp[tasks]. ) annotationsN)AsyncGeneratorCallable)AsyncExitStackasynccontextmanager) ContextVarToken) dataclass)datetimetimezone) lru_cache) TYPE_CHECKINGAnyProtocolcastget_type_hintsruntime_checkable)get_access_token)AuthenticatedUser) AccessToken) request_ctx)Request) Dependencyget_dependency_parameters)_Depends) FastMCPError)_current_http_request)call_sync_fn_in_threadpool)find_kwarg_by_typeis_class_member_of_type)Docket)Worker) ServerSessionContextFastMCP)rCurrentAccessTokenCurrentContext CurrentDocketCurrentFastMCPCurrentHeadersCurrentRequest CurrentWorkerProgressTaskContextInfo TokenClaimr get_contextget_http_headersget_http_request get_serverget_task_contextget_task_sessionis_docket_availableregister_task_sessionrequire_docketresolve_dependenciestransform_context_annotationswithout_injected_parametersT)frozenslotsc(eZdZUdZded< ded<y)r0zInformation about the current background task context. Returned by ``get_task_context()`` when running inside a Docket worker. Contains identifiers needed to communicate with the MCP session. strtask_id session_idN)__name__ __module__ __qualname____doc____annotations__k/Users/bowang/.openclaw/workspace/ChatDev/.venv/lib/python3.12/site-packages/fastmcp/server/dependencies.pyr0r0Rs L2O2rJr0ctsyddlm} |j}ddlm}||j }t|d|dS#t$rYyttf$rYywxYw)aJGet the current task context if running inside a background task worker. This function extracts task information from the Docket execution context. Returns None if not running in a task context (e.g., foreground execution). Returns: TaskContextInfo with task_id and session_id, or None if not in a task. Nr)current_execution)parse_task_keyclient_task_idrC)rBrC) r8docket.dependenciesrMgetfastmcp.server.tasks.keysrNkeyr0 LookupError ValueErrorKeyError)rM executionrN key_partss rKr6r6asv  5%))+ <"9==1 ./ .     !s:A A*A*)A*z%dict[str, weakref.ref[ServerSession]]_task_sessionsc<tj|t|<y)aPRegister a session for Context access in background tasks. Called automatically when a task is submitted to Docket. The session is stored as a weakref so it doesn't prevent garbage collection when the client disconnects. Args: session_id: The session identifier session: The ServerSession instance N)weakrefrefrY)rCsessions rKr9r9s")W!5N:rJcttj|}|y|}|tj|d|S)zGet a registered session by ID if still alive. Args: session_id: The session identifier Returns: The ServerSession if found and alive, None otherwise N)rYrQpop)rCr\r]s rKr7r7s=   Z (C {eG:t, NrJserverdefaultz'ContextVar[weakref.ref[FastMCP] | None]_current_serverdocketzContextVar[Docket | None]_current_docketworkerzContextVar[Worker | None]_current_workertask_access_tokenzContextVar[AccessToken | None]_task_access_tokenz bool | None_DOCKET_AVAILABLEc`t ddl}datStS#t$r daYtSwxYw)zCheck if pydocket is installed.NrTF)rjrd ImportError)rds rKr8r8sC  &  $    & %   &s  --c6tstd|dy)zRaise ImportError with install instructions if docket not available. Args: feature: Description of what requires docket (e.g., "`task=True`", "CurrentDocket()"). Will be included in the error message. znFastMCP background tasks require the `tasks` extra. Install with: pip install 'fastmcp[tasks]'. (Triggered by )N)r8rl)features rKr:r:s-  $IQ (   !rJr/cddlm} tj|} t |d}t}t}|jjD]x\}}|j||j}t||s/t|j t"rJ|j%||j h|j%|z|s|Stj&} g} g} g} g} g}g}g}|jjD]q\}}||vr9||vr|j)t+}n|j)t-}|j.| j0k(r<|j | j2ur| j5|| j5||j.| j6k(r<|j | j2ur| j5|| j5||j.| j8k(r|j5||j.| j:k(r|j5|F|j.| j<k(sa|j5|t| | z| z| z|z|z|z}tj>|rrtj|j@}tCtE|jjG}|j)|g|}||j@_$n|j)|}||_$tK||S#tt f$r|cYSwxYw#t$rt|di}YKwxYw)aTransform ctx: Context into ctx: Context = CurrentContext(). Transforms ALL params typed as Context to use Docket's DI system, unless they already have a Dependency-based default (like CurrentContext()). This unifies the legacy type annotation DI with Docket's Depends() system, allowing both patterns to work through a single resolution path. Note: Only POSITIONAL_OR_KEYWORD parameters are reordered (params with defaults after those without). KEYWORD_ONLY parameters keep their position since Python allows them to have defaults in any order. Args: fn: Function to transform Returns: Function with modified signature (same function object, updated __signature__) rr$Tinclude_extrasrHra) parameters)&fastmcp.server.contextr%inspect signaturerU TypeErrorr ExceptiongetattrsetrtitemsrQ annotationr isinstancerbradd ParameterreplaceOptionalCurrentContextr)kindPOSITIONAL_ONLYemptyappendPOSITIONAL_OR_KEYWORDVAR_POSITIONAL KEYWORD_ONLY VAR_KEYWORDismethod__func__nextitervalues __signature___clear_signature_caches)fnr%sig type_hintsparams_to_transformoptional_context_paramsnameparamr}Ppositional_only_no_defaultpositional_only_with_default positional_or_keyword_no_default"positional_or_keyword_with_defaultvar_positional keyword_only var_keyword new_paramsfunc_sig self_paramnew_sigs rKr<r<s+&/# 8#Bt< %(E(+~~++- e^^D%*:*:; ":w 7emmZ8#''-==(+//5 .  A+-,. 02$24& NLK~~++- e & &.. .D.F G n.> ? ::** *}}'*11%8,33E: ZZ122 2}}'077>299%@ ZZ1++ +  ! !% ( ZZ1>> )    & ZZ1== (   u %7.> # & ' * + - -         $$R[[1$x2299;<= ""z.GJ.G"H$+ !+++4" B IE  "  8R!2B7 8s"M MMMM76M7cddlm}m}|j|d|j|dt j |r9|j|j d|j|j dyy)zClear signature-related caches for a function. Called after modifying a function's signature to ensure downstream code sees the updated signature. r)_parameter_cache_signature_cacheN)uncalled_for.introspectionrrr_rvrr)rrrs rKrr\sc NT"T"R[[$/R[[$/rJr%cLddlm}|j}| td|S)z2Get the current FastMCP Context instance directly.r)_current_contextzNo active context found.)rurrQ RuntimeError)rcontexts rKr2r2ls)7""$G566 NrJr'cptj}| td|}| td|S)zGet the current FastMCP server instance directly. Returns: The active FastMCP server Raises: RuntimeError: If no server in context %No FastMCP server instance in context.FastMCP server instance is no longer availablercrQr) server_refr`s rKr5r5vsA!$$&JBCC \F ~KLL MrJcd}tjt5tjj }ddd|t j}| td|S#1swY.xYw)zuGet the current HTTP request. Tries MCP SDK's request_ctx first, then falls back to FastMCP's HTTP context. NzNo active HTTP request found.) contextlibsuppressrTrrQrequestrr)rs rKr4r4sb G   [ )//#++ * '++-:;; N * )s A((A1cx|r t}nDhd}|r!||Dchc]}|jc}z}td|Ds tdi} t }|j j D](\}}|j}||vst|||<*|Scc}w#t$ricYSwxYw)a]Extract headers from the current HTTP request if available. Never raises an exception, even if there is no active HTTP request (in which case an empty dict is returned). By default, strips problematic headers like `content-length` and `authorization` that cause issues if forwarded to downstream services. If `include_all` is True, all headers are returned. The `include` parameter allows specific headers to be included even if they would normally be excluded. This is useful for proxy transports that need to forward authorization headers to upstream MCP servers. > keep-alive content-typecontent-lengthmcp-session-idproxy-connectiontransfer-encodingproxy-authenticateproxy-authorizationtehostacceptexpectupgrade connection authorizationc3BK|]}|j|k(ywN)lower).0hs rK z#get_http_headers..s;?a1779>?sz"Excluded headers must be lowercase) r{rallrUr4headersr|rAr) include_allincludeexclude_headersrrrrvalue lower_names rKr3r3s"$'E &  7;7a 7; ;O;?;;AB B G"$"??002KD%J0&)%j #3 <  sB&>B+B++ B98B9c d} t}|jjd}t|tr |j }| t}|ltj}|V|jH|jttjtjjkry|S|t|t r|S |j#}t!|d|d|d|jd|jd|jdxsi S#t $rYwxYw#t$$r(}t'd t)|j*d |d}~wwxYw) a)Get the FastMCP access token from the current context. This function first tries to get the token from the current HTTP request's scope, which is more reliable for long-lived connections where the SDK's auth_context_var may become stale after token refresh. Falls back to the SDK's context var if no request is available. In background tasks (Docket workers), falls back to the token snapshot stored in Redis at task submission time. Returns: The access token if an authenticated user is available, None otherwise. Nusertoken client_idscopes expires_atresourceclaims)rrrrrrz3Expected fastmcp.server.auth.auth.AccessToken, got z7. Ensure the SDK is using the correct AccessToken type.)r4scoperQr~r access_tokenr_sdk_get_access_tokenririntr nowr utc timestampr model_dumpryrxtyperD)rrr task_tokenaccess_token_as_dictes rKrrs,0L  "$}}  ( d- .,,L ,. '++-  !$$0((3x||HLL/I/S/S/U+VV z, D +668&w/*;7'1+// =)--j9'++H5;  =    N A$|BTB]B]A^_D D  s+AD/AD>/ D;:D;> E/#E**E/i)maxsizec:ddlm}t|}t}t }|r|j ||r|j |j|sStj}|jjDcgc] \}}||vs |}}}tj|} tjd fd } td} | | _| jD cic]\} } | |vs | dk7s| | c} } | _t!dd | _t!d d | _j*| _t!d | j,| _| Scc}}w#t$rt!di} YwxYwcc} } w)adCreate a wrapper function without injected parameters. Returns a wrapper that excludes Context and Docket dependency parameters, making it safe to use with Pydantic TypeAdapter for schema generation and validation. The wrapper internally handles all dependency resolution and Context injection when called. Handles: - Legacy Context injection (always works) - Depends() injection (always works - uses docket or vendored DI engine) Args: fn: Original function with Context and/or dependencies Returns: Async wrapper function without injected parameters rr$returncJKt|4d{}r!di|d{cdddd{Stfi|d{}tj|r |d{}|cdddd{S7m7]7O7<77#1d{7swYyxYww)NrI)r;rrv isawaitable) user_kwargsresolved_kwargsresultr fn_is_asyncs rKwrapperz,without_injected_parameters..wrapperHs'K88O2/22988 :"PPP&&v.#)\F98829 Q*9888sB#BB#BBB B#BB#B B B*B +B0 B#<B =B#BB#B B B#B B B B#TrrrHrDrrGNrF)rrrr)rur%rrr{rupdatekeysrvrwrtr| SignatureiscoroutinefunctionrryrzrrHrDrGrErF)rr% context_kwargdependency_paramsexcluderrr user_paramsrrresolved_hintskvrs` @rKr=r=s&/'r73M1"5eG M"(--/0     B C!$!5!5!7!7+$4w;N!7 ,G--b1K  <'4@$G'--//A1G3CX 1/Gr:y9Gb)T2GOG"2~w7K7KLG NM4 < %6;<s0 E5!E5 E; FFF;FFc \Kt|}|s|ytjji} t 4d{}tj j|} i}|j D]/\}}||vr ||||< |j|d{||<1i||} | tj j|dddd{tjj|y77e#t$rt$r-} t|dt|} td|d| | d} ~ wwxYw#tj j|wxYw7#1d{7swYxYw#tjj|wxYww)aResolve Docket dependencies for a FastMCP function. Sets up the minimal context needed for Docket's Depends() to work: - A cache for resolved dependencies - An AsyncExitStack for managing context manager lifetimes The Docket instance (for CurrentDocket dependency) is managed separately by the server's lifespan and made available via ContextVar. Note: This does NOT set up Docket's Execution context. If user code needs Docket-specific dependencies like TaskArgument(), TaskKey(), etc., those will fail with clear errors about missing context. Args: fn: The function to resolve dependencies for arguments: The arguments passed to the function Yields: Dictionary of resolved dependencies merged with provided arguments NrDzFailed to resolve dependency 'z' for )rrcacher{rstackr|enter_async_contextrryrzreprrreset) r argumentsr cache_tokenr stack_tokenresolved parameter dependencyerrorfn_namefinal_argumentss rK_resolve_fastmcp_dependenciesr ls02"5 ..$$R(K"*!##u"..,,U3K 2+-->-D-D-F)Iz I-.7 .B+  %494M4M&5/+.G,#>U$yy33J">  !"66zBH%))(3 3 " "3">>>   ;     s0C&B>B#B> B) B%!B)% B>0B'1/B> C&"C&#B>%B)'B>)B;/B2 0B;7B>>"C# C&"C##C&cKtj}|y|jd|d|d} |j4d{}|j|d{}dddd{yt |t r|j St|S7[7D76#1d{7swYFxYw#t$rtjd||dYywxYww)zRestore the origin request ID snapshot for a background task. Returns None if no request ID was captured at submission time. Nrrz:origin_request_idz2Failed to restore origin request ID for task %s:%sTr) rerQrSrr~bytesdecoderAryrr)rCrBrdrequest_id_keyrrequest_id_datas rK_restore_task_origin_request_idr s  "F ~ZZ  |1WI-?@N<<>>U$)IIn$==O">  " ou -"))+ +?## "=">>>  @    s0C&B>B#B> B) B%!B)% B>0B'1B>7C&8B>C& B>"C&#B>%B)'B>)B;/B2 0B;7B>>"C# C&"C##C&c>eZdZUdZdZded<dZded<d dZd dZy) _CurrentContextaAsync context manager for Context dependency. In foreground (request) mode: returns the active context from _current_context. In background (Docket worker) mode: creates a task-aware Context with task_id and restores the access token snapshot from Redis. NContext | None_context Token[AccessToken | None] | None_access_token_cv_tokencKddlm}m}|j}||St }|t |j }t}t|j |jd{}||||j||_ |jjd{t|j |jd{|_ |jStd77J7$w)Nr)r%r)fastmcpr]rBorigin_request_idzNo active context found. This can happen if: - Called outside an MCP request handler - Called in a background task before session was registered Check `context.request_context` for None before accessing.)rur%rrQr6r7rCr5r rBr$ __aenter__rr&r)selfr%rr task_infor]r`r)s rKr*z_CurrentContext.__aenter__+sD#&&(  N%&  &y';'; str: ctx.report_progress(50, 100, "Halfway done") return "Working" ``` r%)rr"rIrJrKr)r)}s,  ?, --rJc*tdtS)zCGet the current FastMCP Context, or None when no context is active.r#)rr6rIrJrKrrs  "9"; <3   /1c KywrrIr/s rKr.z_CurrentDocket.__aexit__  Nrr!r2rDrErFrGr*r.rIrJrKr@r@6  rJr@r!c@tdtdtS)aGet the current Docket instance managed by FastMCP. This dependency provides access to the Docket instance that FastMCP automatically creates for background task scheduling. Returns: A dependency that resolves to the active Docket instance Raises: RuntimeError: If not within a FastMCP server context ImportError: If fastmcp[tasks] not installed Example: ```python from fastmcp.dependencies import CurrentDocket @mcp.tool() async def schedule_task(docket: Docket = CurrentDocket()) -> str: await docket.add(some_function)(arg1, arg2) return "Scheduled" ``` rBr!)r:rr@rIrJrKr*r*s.$% .* ++rJc eZdZdZddZddZy)_CurrentWorkerz,Async context manager for Worker dependency.cfKtdtj}| td|Sw)NCurrentWorker()zNo Worker instance found. Worker is only initialized when there are task-enabled components (task=True). Add task=True to a component to enable Docket infrastructure.)r:rgrQr)r+rfs rKr*z_CurrentWorker.__aenter__rCrDc KywrrIr/s rKr.z_CurrentWorker.__aexit__rFrGNrr"r2rIrIrJrKrMrMrJrJrMr"c@tdtdtS)aGet the current Docket Worker instance managed by FastMCP. This dependency provides access to the Worker instance that FastMCP automatically creates for background task processing. Returns: A dependency that resolves to the active Worker instance Raises: RuntimeError: If not within a FastMCP server context ImportError: If fastmcp[tasks] not installed Example: ```python from fastmcp.dependencies import CurrentWorker @mcp.tool() async def check_worker_status(worker: Worker = CurrentWorker()) -> str: return f"Worker: {worker.name}" ``` rOr")r:rrMrIrJrKr.r.s,$% .* ++rJc eZdZdZddZddZy)_CurrentFastMCPz4Async context manager for FastMCP server dependency.cxKtj}| td|}| td|Sw)Nrrr)r+rr`s rKr*z_CurrentFastMCP.__aenter__sC$((*  FG G >OP P s8:c KywrrIr/s rKr.z_CurrentFastMCP.__aexit__rFrGNrr'r2rIrIrJrKrTrTs> rJrTc6ddlm}t|tS)aGet the current FastMCP server instance. This dependency provides access to the active FastMCP server. Returns: A dependency that resolves to the active FastMCP server Raises: RuntimeError: If no server in context (during resolution) Example: ```python from fastmcp.dependencies import CurrentFastMCP @mcp.tool() async def introspect(server: FastMCP = CurrentFastMCP()) -> str: return f"Server: {server.name}" ``` rr&)fastmcp.server.serverr'rrTr&s rKr+r+s(. * ++rJc eZdZdZddZddZy)_CurrentRequestz2Async context manager for HTTP Request dependency.cKtSwr)r4r+s rKr*z_CurrentRequest.__aenter__ s!!s c KywrrIr/s rKr.z_CurrentRequest.__aexit__#rFrGNrrr2rIrIrJrKr[r[s<" rJr[c2tttS)aGet the current HTTP request. This dependency provides access to the Starlette Request object for the current HTTP request. Only available when running over HTTP transports (SSE or Streamable HTTP). Returns: A dependency that resolves to the active Starlette Request Raises: RuntimeError: If no HTTP request in context (e.g., STDIO transport) Example: ```python from fastmcp.server.dependencies import CurrentRequest from starlette.requests import Request @mcp.tool() async def get_client_ip(request: Request = CurrentRequest()) -> str: return request.client.host if request.client else "Unknown" ``` )rrr[rIrJrKr-r-'s. * ++rJc eZdZdZddZddZy)_CurrentHeadersz2Async context manager for HTTP Headers dependency.c$KtdhSw)Nr)r)r3r]s rKr*z_CurrentHeaders.__aenter__Ds(9::sc KywrrIr/s rKr.z_CurrentHeaders.__aexit__GrFrGNrdict[str, str]r2rIrIrJrKrbrbAs<; rJrbcLttttftS)aGet the current HTTP request headers. This dependency provides access to the HTTP headers for the current request, including the authorization header. Returns an empty dictionary when no HTTP request is available, making it safe to use in code that might run over any transport. Returns: A dependency that resolves to a dictionary of header name -> value Example: ```python from fastmcp.server.dependencies import CurrentHeaders @mcp.tool() async def get_auth_type(headers: dict = CurrentHeaders()) -> str: auth = headers.get("authorization", "") return "Bearer" if auth.startswith("Bearer ") else "None" ``` )rdictrArbrIrJrKr,r,Ks* S#X 1 22rJc`eZdZdZed dZed dZed dZd dZd ddZ ddZ y) ProgressLikezProtocol for progress tracking interface. Defines the common interface between InMemoryProgress (server context) and Docket's Progress (worker context). cy)Current progress value.NrIr]s rKcurrentzProgressLike.currentn rJcy)Total/target progress value.NrIr]s rKtotalzProgressLike.totalsrnrJcy)Current progress message.NrIr]s rKmessagezProgressLike.messagexrnrJc Kyw)1Set the total/target value for progress tracking.NrIr+rqs rK set_totalzProgressLike.set_total}  rGc Kyw)0Atomically increment the current progress value.NrIr+amounts rK incrementzProgressLike.incrementryrGc Kyw#Update the progress status message.NrIr+rts rK set_messagezProgressLike.set_messageryrGNrz int | Nonerrr str | Nonerqrrr4r}rrr4rtrrr4) rDrErFrGpropertyrmrqrtrxr~rrIrJrKrjrjfsR          rJrjcxeZdZdZd dZd dZddZeddZeddZ eddZ ddZ ddd Z dd Z y )InMemoryProgressaIn-memory progress tracker for immediate tool execution. Provides the same interface as Docket's Progress but stores state in memory instead of Redis. Useful for testing and immediate execution where progress doesn't need to be observable across processes. c.d|_d|_d|_y)Nr)_current_total_messager]s rK__init__zInMemoryProgress.__init__s$(  $( rJcK|SwrrIr]s rKr*zInMemoryProgress.__aenter__s  sc KywrrIr/s rKr.zInMemoryProgress.__aexit__rFrGc|jSr)rr]s rKrmzInMemoryProgress.current }}rJc|jSr)rr]s rKrqzInMemoryProgress.totals {{rJc|jSrrr]s rKrtzInMemoryProgress.messagerrJc:K|dkr td||_yw)rvrzTotal must be at least 1N)rUrrws rKrxzInMemoryProgress.set_totals 1978 8 sc~K|dkr td|j||_y|xj|z c_yw)r{rzAmount must be at least 1N)rUrr|s rKr~zInMemoryProgress.increments8 A:89 9 == "DM MMV #Ms;=cK||_ywrrrs rKrzInMemoryProgress.set_messages   N)rr4)rrr2rrrrrrr)rDrErFrGrr*r.rrmrqrtrxr~rrIrJrKrrsa)   $ rJrceZdZUdZdZded<d dZddZeddZ eddZ edd Z dd Z ddd Z dd Zy)r/aFastMCP Progress dependency that works in both server and worker contexts. Handles three execution modes: - In Docket worker: Uses the execution's progress (observable via Redis) - In FastMCP server with Docket: Falls back to in-memory progress - In FastMCP server without Docket: Uses in-memory progress This allows tools to use Progress() regardless of whether they're called immediately or as background tasks, and regardless of whether pydocket is installed. NzProgressLike | None_implc Ktj}|| tdtr-ddlm} |}|j d{|_|St|_|S7#t$rYwxYww)Nz6Progress dependency requires a FastMCP server context.rrp) rcrQrr8rPr/r*rrTr)r+rDocketProgressdocket_progresss rKr*zProgress.__aenter__s$((*  !5WX X  F "0"2#2#=#=#??  &'  @  s:9BA5A3 A5!B3A55 B>BBBcKd|_ywr)rr/s rKr.zProgress.__aexit__s  rcT|jJd|jjS)rl%Progress must be used as a dependency)rrmr]s rKrmzProgress.current*zz%N'NN%zz!!!rJcT|jJd|jjS)rpr)rrqr]s rKrqzProgress.totals*zz%N'NN%zzrJcT|jJd|jjS)rsr)rrtr]s rKrtzProgress.messagerrJc|K|jJd|jj|d{y7w)rvNr)rrxrws rKrxzProgress.set_totals4zz%N'NN%jj""5))) 2<:<c|K|jJd|jj|d{y7w)r{Nr)rr~r|s rKr~zProgress.increments4zz%N'NN%jj""6***rc|K|jJd|jj|d{y7w)rNr)rrrs rKrzProgress.set_messages4zz%N'NN%jj$$W---r)rr/r2rrrrrrr)rDrErFrGrrHr*r.rrmrqrtrxr~rrIrJrKr/r/si "&E %$""   "" * + .rJr/c0eZdZUdZdZded<ddZddZy) _CurrentAccessTokenz1Async context manager for AccessToken dependency.Nr%r&cKt}|Ct}|7t|j|jd{|_t}| t d|S7"w)Nz\No access token found. Ensure authentication is configured and the request is authenticated.)rr6rrCrBr&r)r+rr,s rKr*z_CurrentAccessToken.__aenter__ ss " =(*I$4N(()*;*;5/+)* =4  /s str: return token.claims.get("sub", "unknown") ``` )rrrrIrJrKr(r(&s,  02 33rJc(eZdZdZddZddZddZy) _TokenClaimz@Dependency that extracts a specific claim from the access token.c||_yr) claim_name)r+rs rKrz_TokenClaim.__init__Es $rJc 0Kt}|td|jd|jj |j}|$?A 5zsBBc KywrrIr/s rKr.z_TokenClaim.__aexit__VrFrGN)rrA)rrAr2)rDrErFrGrr*r.rIrJrKrrBsJ%  rJrc4ttt|S)a|Get a specific claim from the access token. This dependency extracts a single claim value from the current access token. It's useful for getting user identifiers, roles, or other token claims without needing the full token object. Args: name: The name of the claim to extract (e.g., "oid", "sub", "email") Returns: A dependency that resolves to the claim value as a string Raises: RuntimeError: If no access token is available or claim is missing Example: ```python from fastmcp.server.dependencies import TokenClaim @mcp.tool() async def add_expense( user_id: str = TokenClaim("oid"), # Azure object ID amount: float, ): # user_id is automatically injected from the token await db.insert({"user_id": user_id, "amount": amount}) ``` )rrAr)rs rKr1r1Zs: [& ''rJ)rzTaskContextInfo | None)rCrAr]r#rr4)rCrArzServerSession | None)rbool)rorArr4)rCallable[..., Any]rr)rrrr4r1rWr_)FN)rrrzset[str] | Nonerrf)rzAccessToken | None)rrrzdict[str, Any]rz$AsyncGenerator[dict[str, Any], None])rCrArBrArr%)rCrArBrArrr<rHrQrer)rrArrA)wrG __future__rrrvloggingr[collections.abcrrrr contextvarsrr dataclassesr r r functoolsr typingrrrrrr'mcp.server.auth.middleware.auth_contextrr&mcp.server.auth.middleware.bearer_authrmcp.server.auth.providerr_SDKAccessTokenmcp.server.lowlevel.serverrstarlette.requestsr uncalled_forrruncalled_for.resolutionrfastmcp.exceptionsrfastmcp.server.authfastmcp.server.httprfastmcp.utilities.async_utilsrfastmcp.utilities.typesrr getLoggerrDrrdr! docket.workerr"mcp.server.sessionr#rur%rYr'__all__r0r6rYrHr9r7rcrergrirjr8r:rPr/rrlr<rr2r5r4r3r=r r;rr r"r6r)rr@r*rMr.rTr+r[r-rhrArbr,rjrrr(rr1rIrJrKrsI#4:)!'XXE3&>,++5DO '  H %$0.- > $d# 3 3$ 3F9;5: 6*zz 0 $*#66 66rAN 4II^A*A*'5A*)A*A*H'''5')''^!%B<>!j+>!Bj)9:8.2=  Z) $,6 Z) $,4  j+  ,2 j) ,4 jc3h0 36  8    F0 0 fC.z*%C.R/*[1/@48 *S/ 0(E$NsJJJ