tPj tUdZddlZddlZddlZddlZddlZddlZddlmZm Z m Z m Z m Z ddlm ZddlmZmZmZddlmZddlmZej,rddlmZGd d eZGd d eZej6j9d dZeed <dZeed<ej6j9ddZ eed<ej6j9ddZ!eed<dZ"eed<dZ#eed<dZ$eed<dZ%eed<de&fdZ'dde(d e)de(fd!Z*de&fd"Z+d#e(de(fd$Z,ejZd%Z.eed&<d'e(de(fd(Z/ddd)d*e e(e(e0e(e(fzfd'e(dzd#e(dzde(e0e(e(fzdzfd+Z1d,Z2eed-<d.e3de e(e3fdzfd/Z4d0e3de&fd1Z5d0e3de&fd2Z6d3eddfd4Z7d5e(d#e(de(fd6Z8d7e3de(fd8Z9d7ede e(fd9Z:d:e(d7ede e(fd;Z;dee(de(dzfd?Z=d@e(de>e(e(ffdAZ?d5e(dBee(de>e(e(fdzfdCZ@d5e(d7edzde(fdDZA dd:e(dEee(dzde&fdFZBdd#e(dGe&ddfdHZCdIe3de(dzfdJZDdIe3de e3dzfdKZEdLe3de(dzfdMZFdLe3dNe(de3fdOZGejZdPZHeedQ<dRe e(e(fdzddfdSZIGdTdUeJZKejZdVZLeedW<dXeedzde>e0e(e(feMe0e(efffdYZNdZe(deOe(fd[ZPd\ee(deOe(fd]ZQdZe(d^e e(e(fde(fd_ZRd`e e(e(fd^e e(e(fde0e(e(ffdaZSde(de(fdbZTdddcdde e(e(fdzdee e(e(fdzde0e(e(fdzfdfZUdgZVeedh<e>e(e)zdifZWdjee>e>eWe(fdifdzde>e>eWe(fdifdzfdkZXddZe3dleWde>e>eWe(fdifdzfdmZY ddZe3dne eWe(fdleWde3fdoZZddZe3dpe)de>e(difdzfdqZ[dIe3de3fdrZ\dIe3dZe3de&fdsZ]e^hdtZ_eedu<e_e^hdvzZ`eedw<dxZaeedy<dzZbeed{<de(dzfd|Zcde(fd}Zdde^e(fd~Zede^e(fdZfdee(de^e(fdZgddddle(de e(e(fdzde(dzddfdZhde e(e(fdzde e(e(ffdZiy)z MCP Server Utilities N)IterableIteratorMappingMutableMappingMutableSequence)Set)AnyFinalProtocol)quote) MCPServerRequestcveZdZedefdZededzfdZededzfdZededzfdZy)_McpServerLikereturncyNselfs q/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/litellm/proxy/_experimental/mcp_server/utils.py server_idz_McpServerLike.server_ids #Ncyrrrs r server_namez_McpServerLike.server_name),rcyrrrs raliasz_McpServerLike.aliass#&rcyrrrs r short_prefixz_McpServerLike.short_prefixs*-r) __name__ __module__ __qualname__propertystrrrrr!rrrrrsZ #3## ,S4Z,, &sTz&& -cDj--rrc`eZdZUedzed<ededzfdZedeeefdzfdZy)McpServerPayloadLikeNrrcyrrrs rrz McpServerPayloadLike.server_name$rrcyrrrs rtool_name_to_display_namez.McpServerPayloadLike.tool_name_to_display_name&sEHr) r"r#r$r&__annotations__r%rrr+rrrr(r(!sD : ,S4Z,, H738+0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_BASE62_ALPHABET4ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_BASE52_ALPHA_ALPHABETrctjjdd}|jj dvS)zReturn True when the short-ID tool prefix mode is enabled. Read at call time (not import time) so tests and runtime config changes take effect without reimporting the module. !LITELLM_USE_SHORT_MCP_TOOL_PREFIX)1trueyeson)osenvirongetstriplower)raws r is_short_mcp_tool_prefix_enabledrFas4  CRHC 99;   "< < 0`` to rehash to a different prefix when the natural hash collides with a prefix already assigned to another server (see ``MCPServerManager._assign_unique_short_prefix``). An empty ``server_id`` raises ``ValueError`` — short prefixes require a stable identifier to be deterministic. z:compute_short_server_prefix requires a non-empty server_idr#utf-8Nbigr;) ValueErrorhashlibsha256encodedigestint from_bytesranger4r8r6divmodlenappendjoinreversed) rrGseedrRvaluecharsposition is_first_charalphabetidxs rcompute_short_server_prefixrbks UVV&!|)I;ay1IDNN4;;w#78??AF NN6"1:u -E !E67$ $@1$DD -:)@PE3x=1 s Xc]# $ 778E? ##rcN tjdy#t$rYywxYw)zF Returns True if the MCP module is available, False otherwise mcpTF) importlib import_module ImportErrorrrris_mcp_availablerhs*& s  $$rc&|jddS)zD Normalize server name by replacing spaces with underscores  _)replace)rs rnormalize_server_namerms   sC ((rz [^a-z0-9_]_MCP_ALIAS_HEADER_INVALID_RErctjd|jj}t jdd|}|jdS)z Sanitize an MCP server alias for x-mcp-{alias}-{header} HTTP headers. Must stay in sync with ui/litellm-dashboard/src/utils/mcpHeaderUtils.ts. rkz_+)rnsubrDrCre)r sanitizeds rsanitize_mcp_alias_for_headerrssF -00ekkm6I6I6KLIuc9-I ??3 r)rrmcp_server_auth_headersc|sy|jDcic]\}}|j|}}}||fD]L}|s|jg}t|}|r||vr|j||D]} | |vs|| ccSNycc}}w)z Resolve server-specific auth headers with case-insensitive matching. Tries the raw alias/server_name (lowercased) and the header-safe sanitized alias so dashboard clients using sanitize_mcp_alias_for_header() still match. N)itemsrDrsrX) rtrrkvnormalized_headers identifier keys_to_tryrrkeys r!lookup_mcp_server_auth_in_headersr}s #:Q:W:W:Y Z$!QA Z Zk* /  !'')* 1*= +5   y ) /C(()#.. / / ![sB tool_allowlist_enforcedMCP_TOOL_ALLOWLIST_ENFORCED_KEYmcp_infoc|yt|tr|St|tr* tj|}t|tr|SdSy#t t f$rYywxYwr) isinstancedictr&jsonloadsrN TypeError)rparseds r_parse_mcp_info_dictrsi(D!(C  $(JJx$8F$FD1v;t; I&  sAA#"A# mcp_servercptt|dd}|syt|jtS)NrF)rgetattrboolrBr)rrs r!is_server_tool_allowlist_enforcedrs0*7:z4+PQH   <= >>rcTt|ddxsg}t|xs t|S)zAWhether server-level allowed_tools whitelist filtering is active. allowed_toolsN)rrr)rrs rserver_applies_tool_allowlistrs+#*:#M#SQSM ,Z 8 OD+> !4!44Pw W]] TJw349Z9Z#G$E$EF $7E%,WmT%JK [%k2 %e,w  !rnamecPt|}tj|t|S)z0Add server name prefix to any MCP resource name.)r separator tool_name)rmr2formatr0)rrformatted_server_names radd_server_prefix_to_namers.#8#E ! ( ()+ ) rserverctr+t|dd}|r|St|dd}|r t|St|dd}|r|St|dd}|r|St|drt|dd}|Sy)ueReturn the prefix for a server. When the short-prefix mode is enabled (``LITELLM_USE_SHORT_MCP_TOOL_PREFIX``) a three-character base62 ID is returned. We prefer the cached ``server.short_prefix`` value when set — that field is populated at registration time by ``MCPServerManager._assign_unique_short_prefix`` and resolves natural-hash collisions deterministically — and only fall back to the natural hash for ad-hoc / temp-server objects without a cached value. In default mode the historical behaviour is preserved: alias if present, else server_name, else server_id. r!Nrrrr;)rFrrbr)rcachedrrrfallback_server_ids rget_server_prefixrs()$+FND$I M'.v{D'I .y9 9&vw=E  %,V]D%IKv{#)0b)I!! rc#Ktdtdzdttffd }|t|Ed{|t |ddEd{t |dd}|r |t |Ed{|t |ddEd{|t |ddEd{||Ed{y77v7O#t $rYXwxYw7E7,7w) awYield every prefix form that may appear in tool names for ``server``. Always includes the *current* prefix returned by ``get_server_prefix``. Additionally yields the historical (alias / server_name / server_id) and short-ID forms so the routing layer can resolve tool names regardless of which prefix mode was active when the client first observed them. r\Nrc3HK|r|vrj||yyywr)add)r\seens r_emitz)iter_known_server_prefixes.._emitHs( U$& HHUOK'5s"r!rrr)setr&rrrrbrN)rrrrs @riter_known_server_prefixesr>s%DS4ZHSM &v.///WV^T:;;;#*6;#EI 8CD D DWVWd3444WV]D9:::Y0; E   5:s;C)CC)CC).CCCC)C#C)8C%9C)C' C)C)C C C)C  C)%C)'C)rc#PK|t|D]}t||yw)aAYield every name that denotes the bare ``tool_name`` on ``server``: the bare name, then its wire spelling under each prefix ``iter_known_server_prefixes`` accepts. ``get_server_prefix`` covers only the currently published one, and that moves with the alias and with ``LITELLM_USE_SHORT_MCP_TOOL_PREFIX``. N)rr)rrprefixs riter_known_tool_name_spellingsr\s. O,V4;' 6::;s$& operation_idcB|jddjS)aReturn the tool name ``_register_openapi_tools`` registers ``operation_id`` under. The single transform between a spec's operationId and the name the gateway serves. Policy recovers the link by replaying this exact function, which is what keeps it from deciding for a tool it does not name: two operationIds that register as two tools necessarily normalize to two names here, because this is the map that registered them. rjrk)rlrD)rs ropenapi_tool_namergs    S ) / / 11rnamesct|ddrtntt||Dchc] }| c}t fd|DdScc}w)aReturn the entry of ``names`` that denotes ``tool_name`` on ``server``, else ``None``. The single question every tool-name-keyed site asks: the allow list, the deny list, ``allowed_params`` and the discovery filter, so discovery hides exactly what dispatch refuses. It spans every spelling routing accepts and no more, because a tool's identity is the exact name routing dispatches; anything looser lets one policy decide two tools. On an OpenAPI server the configured entry holds the spec's operationId while routing holds :func:`openapi_tool_name` of it, so both sides go through that map first. Doing it with the registering function rather than a lookalike is the whole safety argument: a coarser one collapses operationIds that registration keeps apart. Callers read the returned entry rather than testing a container's values, which is what stops an explicitly empty ``allowed_params`` list from reading as "nothing configured". spec_pathNc38K|]}|vs|ywrr).0r normalize spellingss r z(match_known_tool_name..sH$9T?i+GHs)rrr&rnext)rrrspellingrrs @@rmatch_known_tool_namerrsP -4FK,N(TWI.ys&GtD6{&GszCannot connect to MCP server "zt". Your administrator configured this server to require per-user variables, but you haven't set the following yet: z Set your credentials here: )rrrrrYsuper__init__) rrrrrlabel bullet_listmessage __class__s rrz#MCPMissingUserEnvVarsError.__init__lsw#& ""/i!YY&Gw&GG ,UG4Bm+k    !r)r"r#r$__doc__r&rr __classcell__)rs@rrrdsL""4Z " c "  " ""rrz\$\{([A-Za-z_][A-Za-z0-9_]*)\}_ENV_VAR_PATTERNenv_varsci}g}|s||fS|D]}|t|dr|j}nt|tr|}n7|j d}t|t r|s[|j dxsd}|dk(r$|j ||j dd|j d}|d n t |||<||fS) uSplit admin-configured env var entries into globals and per-user specs. Accepts the raw value of ``MCPServer.env_vars`` (list of dicts or Pydantic models). Returns: - ``global_values``: ``{name: value}`` for entries with ``scope=="global"``. - ``user_specs``: list of ``{name, description}`` for entries with ``scope=="user"`` — these are the names the user must fill in. Unknown / malformed entries are skipped silently. model_dumprscopeglobaluser description)rr r\r;)rr rrrBr&rX)r global_values user_specsrEentryrr r\s rparse_admin_env_varsrs,.M.0J j((F ;  3 %*-..*:E T "E yy $$D  '".h F?   tEIIm._subs0kk!n 9 T? "{{1~r)r&rrp)r\rrs ` rinterpolate_env_varsrs5  O   e ,,rheadersc j|jDcic]\}}|t||c}}Scc}}w)zVReturn a copy of ``headers`` with every value passed through ``interpolate_env_vars``.)rvr)r rrwrxs rinterpolate_headersr"s->Emmo NdaA#Ay1 1 NN Ns/ctjjddjd}dt |d}|r||S|S)zBThe frontend URL where a user can fill in their per-user env vars.PROXY_BASE_URLr;/z$/ui/?page=mcp-servers&fill_env_vars=)safe)r@rArBrstripr )rbasepaths rbuild_env_var_setup_urlr*sK**..!126==cBD8yr9R8STD"dVD6?,,r) extra_headersstatic_headersr+r,c Fi}|rE|j|jDcic]\}}t|t|c}}|rE|j|jDcic]\}}t|t|c}}|xsdScc}}wcc}}w)aMerge outbound HTTP headers for MCP calls. This is used when calling out to external MCP servers (or OpenAPI-based MCP tools). Merge rules: - Start with `extra_headers` (typically OAuth2-derived headers) - Overlay `static_headers` (user-configured per MCP server) If both contain the same key, `static_headers` wins. This matches the existing behavior in `MCPServerManager` where `server.static_headers` is applied after any caller-provided headers. N)rrvr&)r+r,mergedrwrxs rmerge_mcp_headersr/s"%'F -2E2E2GH$!Qs1vs1v~HI .2F2F2HI$!Qs1vs1v~IJ >T IJs B *B d!MAX_STRUCTURED_CONTENT_SCAN_DEPTH.groupscbt|}td|Drytd|DS)zAConcatenate child leaf groups, propagating the too-deep sentinel.c3$K|]}|du ywrrrrs rrz'_flatten_leaf_groups..s 3U5D= 3Nc34K|]}||D]}|ywrr)rrleafs rrz'_flatten_leaf_groups.. s"W%53DQVWWW)rany)r2 materializeds r_flatten_leaf_groupsr<s/ -L 3l 33 W<W WWrr)cttkDryt|tr|ffSt|tr"t fd|j DSt|trt fdt|DSy)a Depth-first, deterministically ordered string leaves of a JSON value. Returns ``None`` when the value is nested past ``MAX_STRUCTURED_CONTENT_SCAN_DEPTH``, so the caller blocks rather than letting deeper values through unscanned; an empty tuple means there was simply nothing to scan. A sentinel rather than an exception because this module is reloaded by tests (see the note above the environment-backed constants), which would give a custom exception class a new identity and let it escape a caller's ``except``. Nc3FK|]\}}t|g|ywrjson_string_leaves)rr|rr)s rrz%json_string_leaves..s&#jysTX$6t\t\S\$J#j!c3FK|]\}}t|g|ywrr?)rindexrr)s rrz%json_string_leaves..s(#qQ\QVX\$6t^t^U^$L#qrAr) rWr1rr&rr<rvr enumerate)r\r)s `rr@r@ sv 4y44%u %##j\a\g\g\i#jjj%##q`ijo`p#qqq r replacementsc ft|tr|j||St|tr4|j Dcic]\}}|t ||g||c}}St|t r.t|Dcgc]\}}t ||g||c}}S|Scc}}wcc}}w)zBRebuild a JSON value with the guardrail's rewritten string leaves.)rr&rBrrvwith_json_string_leavesrrD)r\rEr)r|rrCs rrGrG!s %e,,%`e`k`k`mnS\SVX\,T<4NNnn%_hin_opP[PUW['lNdNENKpp Lops B'B- path_depthctkDryt|ts|t|tryt|tt fr t|fSt|t r\td|D}tfd|jD}td|Dry|td|DzSt|tr9tfd|D}td|Drytd |DSy) aStrings in a JSON value that carry meaning but cannot be rewritten. Dictionary keys and non-string scalars: masking either would change the payload's contract rather than redact a value, so a caller scans these and blocks on a match instead of rewriting, matching what the content filter already does for MCP tool call arguments. ``None`` means the value is nested past the scan depth, same contract as ``json_string_leaves``. Nrc3BK|]}t|ts|ywr)rr&)rr|s rrz+json_unrewritable_labels..@sH3:c33G3Hsc3<K|]}t|dzywrMNjson_unrewritable_labelsrrrHs rrz+json_unrewritable_labels..Asa$/j1nEac3$K|]}|du ywrrr5s rrz+json_unrewritable_labels..B1u}1r6c34K|]}||D]}|ywrrrrrs rrz+json_unrewritable_labels..Ds"]U8IW\]e5]5]r9c3<K|]}t|dzywrLrMrOs rrz+json_unrewritable_labels..FsX$/j1nEXrPc3$K|]}|du ywrrr5s rrz+json_unrewritable_labels..GrRr6c34K|]}||D]}|ywrrrTs rrz+json_unrewritable_labels..Is"Wu%2CQVWUWUWr9) r1rrr&rSfloatrrvaluesr:r)r\rHownnesteds ` rrNrN0s55%%-:eS3I%#u&E }%H%HHaRWR^R^R`aa 1&1 1U]f]]]]%XRWXX 1&1 1WWWW rc^t|tr|jdSt|ddS)zNThe ``structuredContent`` of an MCP tool result, or ``None`` when it has none.structuredContentN)rrrBr)rs r"mcp_tool_result_structured_contentr^Ms,&'"zz-.. 6. 55rct|tr||d<yt|dsy t|d|y#tt t f$rYywxYw)a2Replace ``structuredContent`` in place; ``False`` when the shape does not carry it. In place for the same reason the content list is: the logging payload captured before the guardrail ran references this object, so a copy would leave the unmasked value in the spend log and the OTel span. r]TF)rrrsetattrAttributeErrorrrN)rr\s r&set_mcp_tool_result_structured_contentrbTsX&.)&+"# 6. /+U3 Iz 2s 3A  A > keep-alivecontent-lengthtransfer-encodingtetrailerupgrade connection_HOP_BY_HOP_HEADERS> content-typex-forwarded-forhost#_SYNTHETIC_REQUEST_EXCLUDED_HEADERS)z 127.0.0.1i_SYNTHETIC_REQUEST_SERVERzx-mcp-_MCP_SERVER_AUTH_HEADER_PREFIXcX ddlm}|r|jdSdS#t$rYywxYw)z``general_settings.litellm_key_header_name``, the deployment's custom header name for the proxy virtual key, so it is stripped from observability copies like the standard ones.rgeneral_settingsNlitellm_key_header_name)litellm.proxy.proxy_serverrsrgrBrrs r_custom_litellm_key_header_namerv|s<??O    9 :XTXX s  ))cfddlm} |jS#t$r|jcYSwxYw)zThe header name the client passes the upstream MCP credential in, falling back to the default when ``general_settings`` is unavailable (the SDK, outside a running proxy).rMMCPRequestHandler)auth.user_api_key_auth_mcpry$get_mcp_client_side_auth_header_namergLITELLM_MCP_AUTH_HEADER_NAMErxs r!_mcp_client_side_auth_header_namer}s6>> EEGG > ===>s 00c ddlm}|s tS|j d}|j d}t |t r|n|r|fnd}d|D}td|g|DS#t$r tcYSwxYw)aLowercased header names the deployment reads the caller's identity out of. A name here is a claim about who the caller is rather than a secret, and ``get_user_from_headers`` resolves it off the request this module reconstructs, so dropping one would lose end user attribution on the MCP paths that leave ``end_user_id`` unset at connect time. ``user_header_mappings`` is accepted as a bare mapping as well as a list of them, matching ``get_internal_user_header_from_mapping`` and ``get_customer_user_header_from_mapping``. Iterating the bare form without normalizing yields its keys, which would silently exempt nothing.rrruser_header_nameuser_header_mappingsrc3`K|]&}t|ts|jd(yw) header_nameN)rrrB)rmappings rrz)_identity_header_names..s$hG:V]_fKgW[[/hs..c3dK|](}t|ts|s|j*ywr)rr&rDrs rrz)_identity_header_names..s$gd SWY\H]bfTZZ\gs 000)rursrg frozensetrBrr)rs user_header configuredmappingsmappeds r_identity_header_namesrs? {)--.@AK(,,-CDJ$.z4$@jWazmgiHhxhF g{.DV.Dg gg {sA..BBc ddlm}t tdhztfd|j j DS#t$r tcYSwxYw)aLowercased header names that a configured MCP server forwards upstream through its ``extra_headers`` allowlist. The names are chosen by the admin, so no prefix rule can recognize them, and a caller supplied value under one of them is an upstream credential. ``authorization`` is left out because ``clean_headers`` already strips it, and claiming it here would change which header ``authenticated_with_header`` resolves to on the oauth passthrough config, which lists it in ``extra_headers`` by design. Identity headers are left out for the same reason: naming one in ``extra_headers`` forwards the caller's identity upstream, it does not turn that identity into a secret.rM)global_mcp_server_manager authorizationc3K|];}|jxsdD]&}|jvr|j(=yw)rN)r+rD)rrrexempts rrz3_forwarded_upstream_header_names..sM ))/R  ::EEG  {sAA&%A& header_namesc ddlm}t|jj |j j ht j ttfdd|DDS)aLowercased names of the headers in ``header_names`` that carry an upstream MCP credential rather than request context: the configured client side auth header, any header name a configured server forwards upstream via ``extra_headers``, and the per-server ``x-mcp-{alias}-{header}`` family. ``clean_headers`` only knows the credential headers of the chat completions path, so these are dropped on top of it. rMrxc3fK|](}|k(s|vs|jtr|vr|*ywr)rrp)rrclient_side_authforwarded_upstreamnon_credentials rrz/_upstream_credential_headers..s?  # # % % OO: ;N@Z s.1c3<K|]}|jywr)rD)rraw_names rrz/_upstream_credential_headers..sC(X^^%Cs)rzryrLITELLM_MCP_SERVERS_HEADER_NAMErD%LITELLM_MCP_ACCESS_GROUPS_HEADER_NAMEr}r)rryrrrs @@@r_upstream_credential_headersrsx>%  = = C C E  C C I I K N @AGGI @ B ClC r) raw_headers client_iprrrc ddlm}t}tt |r|j ndz|rt |jhn t ztfd|r|jndD}|rd|jdffnd}|dd|dtd d d g||d |r d |dfiSiS)a-A synthetic FastAPI ``Request`` carrying the MCP connection's HTTP headers. The MCP protocol transports do not hand a per-call ``Request`` to the tool handlers, so one is reconstructed from the connection's ``raw_headers``. That lets ``add_litellm_data_to_request`` derive ``metadata.headers``, ``proxy_server_request``, header-based tags, guardrails and trace correlation exactly as on the chat completions path. Hop-by-hop headers describe the original HTTP framing rather than the logical request, so they are dropped, and ``x-forwarded-for`` comes from the resolved ``client_ip`` to avoid spoofing. ``host`` is dropped for the same reason: it is what ``Request.url`` is built from, so forwarding it would let a caller choose the URL every logging callback records. Upstream MCP credentials and the deployment's proxy key header, including a custom ``litellm_key_header_name``, are dropped so they cannot reach a callback or a guardrail through the derived metadata even when a caller omits ``general_settings``. rrrc3K|]M\}}|jvr6|jjdd|jddfOyw)zlatin-1rl)errorsrJN)rDrQ)rrr\excludeds rrz.build_synthetic_mcp_request..sX D% ::@+ &[{'7'7'9b Q R5F9'--/0 1IK Y  4?K--/B IHQ%y'7'7'@ACVXC />QQSQ  .79a.)    =?    rc2ddlm}ddlm}m}m}t |r|jnd|ztdhz}|||t}||jDcic]\}}|j|vs||c}}Scc}}w)aSThe MCP request's client headers, sanitized the way the chat completions path sanitizes them before they reach a logging callback or a guardrail: proxy key headers stripped, including the custom key header name the deployment configured, upstream MCP credentials dropped, and credential-bearing values masked. Client-controlled behaviour flags (``litellm-disable-message-redaction``) are dropped too: these headers are read back out of the metadata to change proxy behaviour, so leaving one in place would let any MCP client turn off the redaction an admin configured. This path carries no key or team object to authorize an opt-out with, so it always strips them. ``host`` goes too, so that a caller cannot name the deployment in the guardrail payload and the spend row the way it could once name the request URL.r)Headers)'UNTRUSTED_REQUEST_HEADER_CONTROL_FIELDS clean_headersredact_credential_headersrrm)rt) starlette.datastructuresr$litellm.proxy.litellm_pre_call_utilsrrrrrrrvrvrD) rrrrrrcleanedrr\s rlogging_safe_mcp_headersrs1 %;[%5%5%7BO 1 2 VH   #  ? AG %W]]_%ukdEX\XbXbXdltXtdEk%u vv%us +B B )rr)F)r)jrrOrerr@rqtypingcollections.abcrrrrrr AbstractSetr r r urllib.parser +litellm.types.mcp_server.mcp_server_managerr TYPE_CHECKINGrrrr(rArBr-r,r.r/r0r2r4r6r8rrFr&rSrbrhrmcompilernrsrr}robjectrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr"r*r/r1 JSONLeafPathr<r@rGrNr^rbrrjrnrorprvr}rrrrrrrrrs XX.''A .X.I8I""$0IK_!``$+E+(* 7WYq(rr#%::>>2Ms#S5S EEH'(e'Z%Z!WV=$=$3$$S$B$)s)s)'1bjj&?e?   " $S#S#X*>%>? :t   4S>D <*CB 6 gc6k.BT.I ?&?T?PfPP (7K(PT(VCccf@ ~ (3- <;c;9;RU;2C2C2PSP)PHSMPVY\`V`P*sCx"C#5QTVYQY?]aKa*3C3$1F333.6:  &s+d2   F+#+T+VZ+,1&1S4Z1&OF4Kd4R"333:3& V 3 6 $.2::.A#B5B738;Lt;SX\B""F%"**%FG%G$%smd"$% 4S>4S#X/ /0$%N0303s808C=SX--S0A-c-"Oc!2OwsCx?POUYZ]_bZbUcO -s-s-/3/338$t+CH%, #s(^d <,/!5.S3Y^$ X U5s!23S89D@ AX 5s" #S ()D0XfL%l\_N_H`beHeBfimBm0   ,+,    FE#s(OVZDZ:6v6&66&T&' U .A9/D.#U$756(00YtY>3>h #h.)C..x}3:-1 2 2c"T)2Tz 2  2jw'#s(*;d*BwwsTWxGXwr