Jj_ UdZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlmZddlmZddlmZmZmZmZmZddlmZejeZdZdaeeed<e jZ d efd Z!d e"d dfd Z#d Z$d Z%d Z&d Z'd Z(d Z)dZ* ddl+m,Z,m-Z-ddl.m/Z/dZ$ ddl0m1Z1dZ%n #e2$rd Z%YnwxYw ddl0m3Z3dZ4n #e2$rd Z4YnwxYw ddl5m*Z*n #e2$re6dYnwxYw ddl7m8Z8n"#e2$rdZ8e6dYnwxYw ddl5m9Z9m:Z:m;Z;mZ>m?Z?dZ&n #e2$re6dYnwxYw ddl5m@Z@mAZAdZ(n #e2$re6dYnwxYw ddl5mBZBmCZCmDZDmEZEdZ'n #e2$re6dYnwxYwn #e2$re6dYnwxYwd eFfdZGeGZ)e$re)se6d d eFfd!ZHeHZIejJejKejKejLejMejMejMejMd"ZNd#ZOd$ZPd%ZQd&ZRd$ZSd'ZTd%ZUeVhd(ZWeVhd)ZXe jYd*e jZZ[e jYd+Z\d,e"d e"fd-Z]d.ee^d e^fd/Z_d0e"d e"fd1Z`d2ead e"fd3Zb dd4l5mcZdn #ee$rd5ZdYnwxYwd2ead eFfd6Zfe jYd7e jgd8fe jYd9e jgd:fe jYd;e jgdfe jYd?e jgd@fe jYdAe jgdBfe jYdCe jgdDfe jYdEe jgdFfe jYdGe jgdHfe jYdIe jgdJfg Zhd e"dKe"dLe"d ee"fdMZidNe^dOe"d e^fdPZjdQe"dNe^d eke"e^ffdRZldSe"d e"fdTZmd e"fdUZnGdVdWeoZpGdXdYeqZrd e"dZed e"fd[Zsd e"d\e^fd]Ztd2ead e"fd^Zuevd_fd`ZwGdadbZxdce^d e"d e"fddZyGdedfZzGdgdhZ{iZ|ee"e{fedi<e}Z~e}e"edj<iZee"e"fedk<iZee"evfedl<iZee"efedm<d&ZdnZd e"d dfdoZd e"d dfdpZdqed eFfdrZdsaekedt<d ekfduZd2ead eFfdvZd e"d2eadwe"fdxZdyZekedz<d2ead eFfd{Zd e"d2eadwe"fd|Ze}Ze}ed}<iZee"e"fed~<daeejed<daee jed<e jZiZeeve"fed<e}Ze}ed<iZeevevfed<d e}fdZdZeke"dfed<de}d e}fdZdZdZddZddefdZd e"fdZdZdee"e^fd ee"e^ffdZd ee"e^ffdZde"d\e^d e{fdZd e"dKe"defdZd e"defdZd e"defdZd e"defdZd e"defdZd e"fdZdce^dzd e^fdZde"d e"fdZdZdZd e"dKe"d e"fdZd e"d e^fdZd e"d ee^fdZdede"d e}e"fdZddedeFd eFfdZdddddZdddddZdKe"d e"d dfdZdKe"d dfdZd e"dqe{d\e^d ee^fdZd ee"fdZde"dqe{d\e^d ee"fdZde"d\e^d ee"fdZdee"e^fd ee"fdZd ee"fdZdKe"d eFfdZd ee^fdZd ee"eekffdZe jZd eFfdZdddddeFd e}fdZdede}d e}fdĄZdńZddeFd dfdDŽZd eFfdȄZd dɜdeFd eFfd˄ZdS)a MCP (Model Context Protocol) Client Support Connects to external MCP servers via stdio, HTTP/StreamableHTTP, or SSE transport, discovers their tools, and registers them into the hermes-agent tool registry so the agent can call them like any built-in tool. Configuration is read from ~/.hermes/config.yaml under the ``mcp_servers`` key. The ``mcp`` Python package is optional -- if not installed, this module is a no-op and logs a debug message. Example config:: mcp_servers: filesystem: command: "npx" args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"] env: {} timeout: 120 # per-tool-call timeout in seconds (default: 300) connect_timeout: 60 # initial connection timeout (default: 60) keepalive_interval: 10 # liveness ping cadence in seconds (default: # 180). Set below the server's session TTL for # servers that GC idle sessions quickly (e.g. # Unreal Engine editor MCP, ~15s). Floored at 5s. github: command: "npx" args: ["-y", "@modelcontextprotocol/server-github"] env: GITHUB_PERSONAL_ACCESS_TOKEN: "ghp_..." supports_parallel_tool_calls: true # tools from this server may run concurrently remote_api: url: "https://my-mcp-server.example.com/mcp" headers: Authorization: "Bearer sk-..." timeout: 180 searxng: url: "http://localhost:8000/sse" transport: sse # use SSE transport instead of Streamable HTTP timeout: 180 connect_timeout: 10 command: "npx" args: ["-y", "analysis-server"] sampling: # server-initiated LLM requests enabled: true # default: true model: "gemini-3-flash" # override model (optional) max_tokens_cap: 4096 # max tokens per request timeout: 30 # LLM call timeout (seconds) max_rpm: 10 # max requests per minute allowed_models: [] # model whitelist (empty = all) max_tool_rounds: 5 # tool loop limit (0 = disable) log_level: "info" # audit verbosity Features: - Stdio transport (command + args) and HTTP/StreamableHTTP transport (url) - SSE transport (transport: sse) for MCP servers using the SSE protocol - Automatic reconnection with exponential backoff (up to 5 retries) - Environment variable filtering for stdio subprocesses (security) - Credential stripping in error messages returned to the LLM - Configurable per-server timeouts for tool calls and connections - Thread-safe architecture with dedicated background event loop - Sampling support: MCP servers can request LLM completions via sampling/createMessage (text and tool-use responses) - Parallel tool call opt-in: per-server ``supports_parallel_tool_calls`` flag allows concurrent execution of tools from the same server Architecture: A dedicated background event loop (_mcp_loop) runs in a daemon thread. Each MCP server runs as a long-lived asyncio Task on this loop, keeping its transport context alive. Tool call coroutines are scheduled onto the loop via ``run_coroutine_threadsafe()``. On shutdown, each server Task is signalled to exit its ``async with`` block, ensuring the anyio cancel-scope cleanup happens in the *same* Task that opened the connection (required by anyio). Thread safety: _servers and _mcp_loop/_mcp_thread are accessed from both the MCP background thread and caller threads. All mutations are protected by _lock so the code is safe regardless of GIL presence (e.g. Python 3.13+ free-threading). N)Callable)datetime)Any CoroutineDictListOptional)urlparseg(@_mcp_stderr_log_fhreturnct5ttcdddS ddlm}|dz }|dd|dz }t |dd d d }||anl#t$r_}t d | t tj dd an#t$rtj aYnwxYwYd}~nd}~wwxYwtcdddS#1swxYwYdS)a^Return a shared append-mode file handle for MCP subprocess stderr. Opened once per process and reused for every stdio server. Must have a real OS-level file descriptor (``fileno()``) because asyncio's subprocess machinery wires the child's stderr directly to that fd. Falls back to ``/dev/null`` if opening the log file fails. Nr)get_hermes_homelogsT)parentsexist_okzmcp-stderr.logautf-8replace)encodingerrors bufferingz0Failed to open MCP stderr log, using devnull: %swr)_mcp_stderr_log_lockr hermes_constantsrmkdiropenfileno Exceptionloggerdebugosdevnullsysstderr)rlog_dirlog_pathfhexcs 4/home/rurouni/.hermes/hermes-agent/tools/mcp_tool.py_get_mcp_stderr_logr,s ""  )%"""""""" 0 8 8 8 8 8 8%o''&0G MM$M 6 6 6!11HhgiSTUUUB IIKKK!#   0 0 0 LLKS Q Q Q 0%)"*cG%L%L%L"" 0 0 0&)Z""" 0  0"/""""""""""""""""""s_C=AA>=C=> C'C"$CC"CC"CC"C="C'' C==DD server_namect} tjd}|d|d|d|dS#t $rYdSwxYw)aWrite a human-readable session marker before launching a server. Gives operators a way to find each server's output in the shared ``mcp-stderr.log`` file without needing per-line prefixes (which would require a pipe + reader thread and complicate shutdown). z%Y-%m-%d %H:%M:%Sz ===== [z] starting MCP server 'z' ===== N)r,rnowstrftimewriteflushr )r-r)tss r+_write_stderr_log_headerr4s   B \^^ $ $%8 9 9 NRNN NNNOOO       sAA(( A65A6Fz 2025-03-26) ClientSessionStdioServerParameters) stdio_clientT)streamablehttp_client)streamable_http_client)LATEST_PROTOCOL_VERSIONzRmcp.types.LATEST_PROTOCOL_VERSION not available -- using fallback protocol version) sse_clientzAmcp.client.sse.sse_client not available -- SSE transport disabled)CreateMessageResultCreateMessageResultWithTools ErrorDataSamplingCapabilitySamplingToolsCapability TextContentToolUseContentz5MCP sampling types not available -- sampling disabled)ElicitRequestParams ElicitResultz;MCP elicitation types not available -- elicitation disabled)ServerNotificationToolListChangedNotificationPromptListChangedNotificationResourceListChangedNotificationzGMCP notification types not available -- dynamic tool discovery disabledz6mcp package not installed -- MCP tool support disabledctsdS dtjtjvS#t t f$rYdSwxYw)zCheck if ClientSession accepts ``message_handler`` kwarg. Inspects the constructor signature for backward compatibility with older MCP SDK versions that don't support notification handlers. Fmessage_handler_MCP_AVAILABLEinspect signaturer5 parameters TypeError ValueErrorr+_check_message_handler_supportrT sV u G$5m$D$D$OOO z "uu+AAzKMCP SDK does not support message_handler -- dynamic tool discovery disabledctsdS dtjtjvS#t t f$rYdSwxYw)aeCheck if ClientSession accepts the ``logging_callback`` kwarg. Mirrors ``_check_message_handler_support`` for backward compatibility with older MCP SDK versions. Without a logging_callback, the SDK's default handler silently discards every ``notifications/message`` a server emits, so server-side diagnostics never reach Hermes' logs. Flogging_callbackrKrRrSr+_check_logging_callback_supportrXsV u!W%6}%E%E%PPP z "uurU)r"infonoticewarningerrorcriticalalert emergency,<>HOMELANGPATHTERMUSERSHELLLC_ALLTMPDIR>PROGRAMFILES(X86)COMMONPROGRAMFILES(X86)OSTMPTEMPPUBLICWINDIRAPPDATACOMSPECPATHEXTHOMEPATHUSERNAME HOMEDRIVE SYSTEMROOT USERDOMAIN PROGRAMDATA SYSTEMDRIVE USERPROFILE COMPUTERNAME LOCALAPPDATA PROGRAMFILES PROGRAMW6432ALLUSERSPROFILECOMMONPROGRAMFILESCOMMONPROGRAMW6432NUMBER_OF_PROCESSORSPROCESSOR_ARCHITECTUREz(?:ghp_[A-Za-z0-9_]{1,255}|sk-[A-Za-z0-9_]{1,255}|Bearer\s+\S+|token=[^\s&,;\"']{1,255}|key=[^\s&,;\"']{1,255}|API_KEY=[^\s&,;\"']{1,255}|password=[^\s&,;\"']{1,255}|secret=[^\s&,;\"']{1,255})z \$\{([^}]+)\}refc|}|dr)|tdd}|S)aNormalize a ``${...}`` reference body into an env-var name. Accepts Cursor-style ``${env:VAR}`` in addition to plain ``${VAR}`` by stripping a leading ``env:`` prefix. The result is the bare variable name to look up in the secret scope / ``os.environ``. zenv:N)strip startswithlen)rs r+ _env_ref_namersJ ))++C ~~f(#f++,,%%'' JrSuser_envci}tjD]C\}}|tvs0|t vs|dr|||<D|r|||S)aBuild a filtered environment dict for stdio subprocesses. Only passes through safe baseline variables (PATH, HOME, etc.) and XDG_* variables from the current process environment, plus any variables explicitly specified by the user in the server config. This prevents accidentally leaking secrets like API keys, tokens, or credentials to MCP server subprocesses. XDG_)r#environitems_SAFE_ENV_KEYSupper_SAFE_ENV_KEYS_CASE_INSENSITIVErupdate)renvkeyvalues r+_build_safe_envrs Cj&&(( U > ! !yy{{===~~f%%>CH 8 JrStextc8td|S)zStrip credential-like patterns from error text before returning to LLM. Replaces tokens, keys, and other secrets with [REDACTED] to prevent accidental credential exposure in tool error responses. z [REDACTED])_CREDENTIAL_PATTERNsubrs r+_sanitize_errorrs  " "< 6 66rSr*cjt|}|r|nt|S)aXReturn a non-empty human-readable string for *exc*. Some exception classes (e.g. ``anyio.ClosedResourceError``) are raised without a message argument, so ``str(exc)`` is ``""``. This helper falls back to ``repr(exc)`` so that error messages shown to the user and logged to disk always carry *some* diagnostic information. )strrrepr)r*rs r+_exc_strrs. s88>>  D &44T#YY&rS)METHOD_NOT_FOUNDict|dd}t|dd}|tkrdSt|}|sdStt|vp d|vpd|vpd|vS) uReturn True if *exc* is a JSON-RPC ``method not found`` (-32601). ``ping`` is an *optional* MCP utility (spec: "optional ping mechanism"). A server that doesn't implement it answers a ping with -32601 rather than an empty result. Structurally inspect ``McpError.error.code`` first, then fall back to a substring match so detection survives SDK version drift and servers that surface the condition as a plain message. The substring fallback matters when a server reports method-not-found without a structural ``-32601`` code (e.g. surfaced as a plain exception string). Besides the canonical "method not found", many JSON-RPC implementations phrase it as "Unknown method: " — agentmemory's MCP server is one such case (#50028). Without matching that phrasing the ping→list_tools fallback never latches and the keepalive reconnect-loops. r\NcodeTFzmethod not foundzunknown methodznot found: ping)getattr_JSONRPC_METHOD_NOT_FOUNDrlower)r*errrmsgs r+_is_method_not_found_errorrs" #w % %C 3 % %D (((t c((..  C u %&&#- $  $ $ s " $  # rSz)ignore\s+(all\s+)?previous\s+instructionsz8prompt override attempt ('ignore previous instructions')zyou\s+are\s+now\s+az.identity override attempt ('you are now a...')z1your\s+new\s+(task|role|instructions?)\s+(is|are)ztask override attemptz system\s*:\s*zsystem prompt injection attemptz <\s*(system|human|assistant)\s*>zrole tag injection attemptz'do\s+not\s+(tell|inform|mention|reveal)zconcealment instructionz(curl|wget|fetch)\s+https?://znetwork command in descriptionzbase64\.(b64decode|decodebytes)zbase64 decode referencezexec\s*\(|eval\s*\(zcode execution referencez&import\s+(subprocess|os|shutil|socket)zdangerous import reference tool_name descriptioncg}|s|StD]/\}}||r||0|r1td||d|||S)zxScan an MCP tool description for prompt injection patterns. Returns a list of finding strings (empty = clean). uUMCP server '%s' tool '%s': suspicious description content — %s. Description: %.200s; )_MCP_INJECTION_PATTERNSsearchappendr!r[join)r-rrfindingspatternreasons r+_scan_mcp_descriptionrs H 2$$ >>+ & & $ OOF # # #  " DIIh$7$7     OrSr directoryc t|pi}|s|S|dd}d|tjD}||vr|g|}|rtj|n||d<|S)z=Prepend *directory* to env PATH if it is not already present.rgcg|]}||SrRrR).0parts r+ z!_prepend_path..,s A A AdD AT A A ArS)dictgetsplitr#pathsepr)rrupdatedexistingpartss r+ _prepend_pathr%s39"ooG {{62&&H A AhnnRZ88 A A AE#U#05Dbjooe,,,9GFO NrScommandc tjt|}t |pi}tj|vrpd|vr|dnd}tj||}|r|}nF|dvrAtjtj dtj tjdd}tj |dd |tj tjdd d |tj tjd d d |g}|D]D}tj |r#tj |tj r|}nEtj|} | rt|| }||fS) zResolve a stdio MCP command against the exact subprocess environment. This primarily exists to make bare ``npx``/``npm``/``node`` commands work reliably even when MCP subprocesses run under a filtered PATH. rgN)path>npmnpxnode HERMES_HOME~z.hermesrbinz.localusrlocal)r#r expanduserrrrsepshutilwhichgetenvrisfileaccessX_OKdirnamer) rrresolved_command resolved_envpath_arg which_hit hermes_home candidates candidate command_dirs r+_resolve_stdio_commandr3s w))#g,,*<*<*>*>?? r??L v%%%+1\+A+A<''tL!1AAA  (   !7 7 7',, !27<<0B0B30G0G#S#SK  [&%9IJJ RW//44hGWXX RVUGU>),,9bg1N1N'0$E'//"233K@$\;?? \ ))rS mime_typecddl}|pdddd}|dvrdS||pdS) z>Return a reasonable file extension for an MCP image MIME type.rNr;r> image/jpg image/jpegz.jpgz.png) mimetypesrrrguess_extension)rr normalizeds r+"_mcp_image_extension_for_mime_typergsn/r((a00399;;AACCJ000v  $ $Z 0 0 :F:rScddl}t|dd}t|dd}t|pdddd}||dsdS ||}n;#ttf$r'}t d ||Yd}~dSd}~wwxYw dd l m }||t| }nY#t$rtd YdSt"$r&}t d |Yd}~dSd}~wwxYwd|S)aCache an MCP ``ImageContent`` block to the shared image cache and return a ``MEDIA:`` tag that Hermes gateways know how to render. Returns an empty string when *block* is not an image, when the base64 payload is malformed, or when the cache helper rejects the bytes (e.g. non-image MIME masquerading as an image). Errors are logged, not raised: a single bad block shouldn't kill the tool result, and the caller will fall through to any text blocks that did parse. rNdatamimeTyperrrzimage/z&MCP image block decode failed (%s): %s)cache_image_from_bytes)extu@MCP image caching skipped — gateway.platforms.base unavailablez MCP image block cache failed: %szMEDIA:)base64rrrrrr b64decoderPrQr!r[gateway.platforms.baserr ImportErrorr"r ) blockrrrnormalized_mime raw_bytesr*r image_paths r+_cache_mcp_image_blockrpsMMM 5&$ ' 'Dz400I)/r**00a88;AACCIIKKO |?55h??|r$$T** z "?RUVVVrrrrrAAAAAA++ 2?CC      WXXXrr 93???rrrrr !J  s6B&&C7CC" D$E* E3EEceZdZdZdS)InvalidMcpUrlErrora Raised when a remote MCP server's ``url`` cannot be parsed as http(s)://. Validated once at startup so we fail fast with a clear message instead of burning through the reconnect-backoff loop on every attempt. (Ported from anomalyco/opencode#25019.) N__name__ __module__ __qualname____doc__rRrSr+rrsrSrceZdZdZdS)NonMcpEndpointErroranRaised when an HTTP MCP URL serves a non-MCP response. A genuine MCP Streamable-HTTP endpoint answers with ``application/json`` or ``text/event-stream``. Anything else on a 2xx response (typically ``text/html`` from a web-app root) means the configured ``url`` points at the wrong place. This is non-retryable: every attempt returns the same page, so the reconnect-backoff loop is skipped and the server is reported failed immediately with an actionable message. Subclasses :class:`ConnectionError` so callers that only catch the broad class still treat it as a connection problem. NrrRrSr+rrs    rSrurlc 0t|ts'td|dt|j|}|std|d t |}n,#t$r}td|d|d|d|d}~wwxYw|j dvrtd|d |jd|d|j std|d |d|j std|d |d|S) utReturn the URL as a string if it's a valid http(s) remote MCP URL. Raises :class:`InvalidMcpUrlError` otherwise with a message naming the offending server, so users can spot the bad entry in their config. Accepts: - ``http://host`` / ``https://host`` with optional port, path, query - IPv4, IPv6 (bracketed), DNS hostnames Rejects: - Non-string values (``None``, dicts, ints) - Missing scheme (``example.com/mcp``) - Non-http(s) schemes (``file://``, ``ws://``, ``stdio:`` — stdio servers use the ``command`` key, not ``url``) - Empty host (``http://``, ``https:///path``) zInvalid MCP URL for 'z': expected a string, got z ': empty url':  ()N>httphttpsz%': scheme must be http or https, got z': missing host (z': missing hostname () isinstancerrtyperrr r schemernetlochostname)r-rstrippedparsedr*s r+_validate_remote_mcp_urlrs" c3     $K $ $Cyy! $ $   yy{{H   =K = = =   (##  HK H HH H H# H H H   }$555  ;K ; ; - ; ;-5 ; ; ;    =  OK O O( O O O   ?   K         Os'A77 B BB configc|d}|d}||dSdtdtdtffd }t|tt fr|t dd t|d kr(||d d }||d d}||fSt|dkrY||d d }||d d}|d }t|tst dd|||fSt ddt|d||d}|||d}||fS|S)usResolve the ``client_cert`` / ``client_key`` config for mTLS. Returns whatever ``httpx``'s ``cert=`` parameter accepts, or ``None`` when no client certificate is configured: - ``None`` if neither ``client_cert`` nor ``client_key`` is set. - A single absolute path string if ``client_cert`` is a string and ``client_key`` is unset (PEM file with cert + key combined). - A ``(cert_path, key_path)`` tuple when both are set, or when ``client_cert`` is a 2-element list/tuple. - A ``(cert_path, key_path, password)`` tuple when ``client_cert`` is a 3-element list/tuple — the third element is the key passphrase. User paths support ``~`` expansion. Missing files raise ``FileNotFoundError`` with a server-scoped message so the failure surfaces as a clear setup error rather than an opaque TLS handshake error. client_cert client_keyNrlabelr c t|tr|s+tdd|dt |jdt j|}t j |stdd|d||S)N MCP server 'rz& must be a non-empty string path (got r z not found at ) r rrrQrrr#rrrFileNotFoundError)rrexpandedr-s r+_expandz%_resolve_client_cert.._expands$$$ DJJLL ;{;;u;;$(JJ$7;;; 7%%djjll33w~~h'' # {  u     rSrzY': specify either client_cert as a list [cert, key] OR client_cert + client_key, not bothrzclient_cert[0]rzclient_cert[1]rcz3': client_cert[2] (key passphrase) must be a stringz8': client_cert list form must have 2 or 3 elements (got r )rrrr listtuplerQr)r-rraw_certraw_keyr cert_pathkey_pathpasswords` r+_resolve_client_certr's$zz-((Hjj&&GGOt c # #      (T5M**  L{LLL  x==A   -=>>Iwx{,<==Hx( ( x==A   -=>>Iwx{,<==H{Hh,,  4;444x2 2 3; 3 3"%h-- 3 3 3   -00I77L118$$ rScdtdttffd dtdttffd |}|r;d|d}tj|dvr|dz }t|Sg}|D]}||vr||td |d d S) zERender nested MCP connection errors into an actionable short message.currentr ct|dd}|r|D]}|}|r|cSdSt|tr^t|ddrt|jSt jdt|}|r|dSdD]9}t||d}t|tr|}|r|cS:dS)N exceptionsfilenamez$No such file or directory: '([^']+)'r __cause__ __context__) rr rrr,rergroup BaseException)r)nestedchildmissingmatchattr nested_exc _find_missings r+r9z,_format_connect_error.._find_missing9s,55   # #'-..#"NNN#4 g0 1 1 &w D11 -7+,,,IEs7||TTE &{{1~~%0 # #D $55J*m44 #'- 33#"NNNtrSct|dd}|r'g}|D] }||!|Sg}t|}|r||dD]F}t||d}t |t r||G|p |jjgS)Nr+r-) rextendrrrr r2 __class__r) r)r3 flattenedr4messagesrr7r8_flatten_messagess r+r?z0_format_connect_error.._flatten_messagesOs,55  #%I ; ;  !2!25!9!9:::: 7||!!##  " OOD ! ! !0 ? ?D $55J*m44 ? 1 1* = =>>>7G-677rSzmissing executable ''>rrrz (ensure Node.js is installed and PATH includes its bin directory, or set mcp_servers..command to an absolute path and include that directory in mcp_servers..env.PATH)rNrc) r2r rrr#rbasenamerrr)r*r5messagededupeditemr9r?s @@r+_format_connect_errorrE6s(}#,8=8T#Y888888"mC  G(3333 7  G $ $(> > > A G w'''G!!#&&!! w   NN4 499WRaR[11 2 22rSrc ||}t|trtj|s|St ||S#t t tf$r|cYSwxYw)zCoerce a config value to a numeric type, returning *default* on failure. Handles string values from YAML (e.g. ``"10"`` instead of ``10``), non-finite floats, and values below *minimum*. )r floatmathisfinitemaxrPrQ OverflowError)rdefaultcoerceminimumresults r+ _safe_numericrPvsw  fe $ $ T]6-B-B N67### z= 1s5AAA$#A$ceZdZdZddddZdedefdZd efd Z d e efd Z e d efd Z d eefd Ze ddedefdZdZdZd efdZdZdS)SamplingHandlera+Handles sampling/createMessage requests for a single MCP server. Each MCPServerTask that has sampling enabled creates one SamplingHandler. The handler is callable and passed directly to ``ClientSession`` as the ``sampling_callback``. All state (rate-limit timestamps, metrics, tool-loop counters) lives on the instance -- no module-level globals. The callback is async and runs on the MCP background event loop. The sync LLM call is offloaded to a thread via ``asyncio.to_thread()`` so it doesn't block the event loop. endTurn maxTokenstoolUse)stoplength tool_callsr-rc&||_t|dddt|_t|dddt |_t|dddt|_t|dddtd |_|d |_ |d g|_ tj tj tjd }|t|ddtj |_g|_d |_d d d d d|_dS)Nmax_rpm timeoutmax_tokens_capimax_tool_roundsrbr)rNmodelallowed_models)r"rYr[ log_levelrY)requestsr tokens_usedtool_use_count)r-rPrintrZrGr\r^r_model_overrideraloggingDEBUGINFOWARNINGrr audit_level_rate_timestamps_tool_loop_countmetrics)selfr-r _log_levelss r+__init__zSamplingHandler.__init__sM&$VZZ 2%>%>CHH $VZZ 2%>%>EJJ +FJJ7G,N,NPTVYZZ, JJ(! , ,aa   %jj11$jj)92>> ' w|PWP_`` &??  ;// 0 0 6 6 8 8',   .0 !$%1XYZZ rSr ctj}|dz fd|jD|jdd<t|j|jkrdS|j|dS)zASliding-window rate limiter. Returns True if request is allowed.rac g|] }|k| SrRrR)rtwindows r+rz5SamplingHandler._check_rate_limit..s#S#S#S!F A rSNFT)timermrrZr)rpr/rvs @r+_check_rate_limitz!SamplingHandler._check_rate_limitsxikkr#S#S#S#St/D#S#S#Saaa t$ % % 5 55 $$S)))trSc|jr|jS|rAt|dr1|jr*|jD]"}t|dr|jr |jcS#dS)z3Config override > server hint > None (use default).hintsnameN)rghasattrrzr{)rp preferenceshints r+_resolve_modelzSamplingHandler._resolve_modelsz   '& &  %7;88 %[=N %#) % %4((%TY%9$$$trSct|dr|jdSt|jtr|jn|jg}dd|DS)z,Extract text from a ToolResultContent block.contentNr c3DK|]}t|d|jVdS)rNr|rrrDs r+ z.s3NNtf8M8MNNNNNNNrS)r|rr r r)rrs r+_extract_tool_result_textz)SamplingHandler._extract_tool_result_textscui(( EM,A2!+EM4!@!@U u}oyyNNuNNNNNNrSc Hg}|jD]}t|dr|jn(t|jt r|jn|jg}d|D}d|D}d|D}|D]3}|d|j||d4|rg} |D]} | t| ddt| d | j t| j trtj| j d nt!| j d d |j| d} d|D} | rd| | d<|| t|rt|dkr@t|ddr*||j|djdg} |D]}t|dr| d|jd0t|dr;t|dr+| ddd|jd|jid{t,dt1|j| r||j| d|S)aLConvert MCP SamplingMessages to OpenAI format. Uses ``msg.content_as_list`` (SDK helper) so single-block and list-of-blocks are handled uniformly. Dispatches per block type with ``isinstance`` on real SDK types when available, falling back to duck-typing via ``hasattr`` for compatibility. content_as_listc2g|]}t|d|S) toolUseIdr|rbs r+rz5SamplingHandler._convert_messages..s'III!K1H1HIAIIIrScrg|]4}t|dt|d"t|d2|5S)r{inputrrrs r+rz5SamplingHandler._convert_messages..sIyyyqga.@.@yWQPWEXEXyahijlwaxaxyyyyrScrg|]4}t|dt|drt|d2|5S)rr{rrrs r+rz5SamplingHandler._convert_messages..srEEEAwq+7N7NEX_`aciXjXjEovwx{BpCpCEaEEErStool)role tool_call_idridcall_functionF ensure_asciir{ arguments)rrr)rrXc<g|]}t|d|jSrrrs r+rz5SamplingHandler._convert_messages..s)SSS6@R@RSafSSSrSrrrrrrrrrrr image_urlrzdata:z;base64,)rrz5Unsupported sampling content block type: %s (skipped))r>r|rr rr rrrrrr{rrjsondumpsrrrrrrr!r[rr)rpparamsr>rblocks tool_results tool_usescontent_blockstrtc_listtumsg_dict text_partsrrs r+_convert_messagesz!SamplingHandler._convert_messagessi "?8 N8 NC,3C9J,K,KS(()#+t<<O 3;-  JIvIIILyyFyyyIEEEEEN#  "$&L#==bAA!!% N#BNN%b$0FG 0F0FGG *$&GU_`b`hjnUoUo*CBH5)Q)Q)Q)Quxy{zBvCvC%%$$+.('!J!JSSnSSS @*.))J*?*?HY')))) N~&&!++q8I60R0R+OOSX.QRBSBX$Y$YZZZZE!/  "5&11 !LL&%*)M)MNNNN$UF33 z8R8R !LL(3.35aU^5a5aUZU_5a5a-b** #NN W $U 4N e(L(LMMMrSrBrcPtrt||St|)z1Return ErrorData (MCP spec) or raise as fallback.)rrB)_MCP_SAMPLING_TYPESr>r )rBrs r+_errorzSamplingHandler._errors-  9$888 8   rSc |jdxxdz cc<|jdkr%d|_|d|jdS|xjdz c_|j|jkr-d|_|d|jd|jdSg}|jjD]}|jj}t|trW tj |}ni#tj tf$r(td |j|d |i}Yn,wxYwt|t"r|nd t|i}|t'd |j|jj| t|jd |j|jt3t3|ddddt5|t7d||jdS)zEBuild a CreateMessageResultWithTools from an LLM tool_calls response.rerrz Tool loops disabled for server 'z' (max_tool_rounds=0)z%Tool loop limit exceeded for server 'z' (max z rounds)zRMCP server '%s': malformed tool_calls arguments from LLM (wrapping as raw): %.100s_rawtool_use)rrr{rzEMCP server '%s' sampling response: model=%s, tokens=%s, tool_calls=%dusageN total_tokens? assistantrUrrr` stopReason)ror_rnrr-rBrXrrr rrloadsJSONDecodeErrorrQr!r[rrrBrr{logrlr`rrr=)rpchoiceresponsertcargsrs r+_build_tool_use_resultz&SamplingHandler._build_tool_use_resultsO %&&&!+&&&  1 $ $$%D !;;Z43CZZZ  "  4#7 7 7$%D !;;78H77,777  .+  B;(D$$$ Q,!Z--FF,j9,,,NN=($ %d^FFF ,",D$!7!7Pfc$ii=P  ! !.5[% ###        S  hn GHgt44nc J J       ,".     sC;DDc fd|_|jjpd}t|jd|j|jtt|ddddtdtd t| |j|j |jd  S) z8Build a CreateMessageResult from a normal text response.rrz6MCP server '%s' sampling response: model=%s, tokens=%srNrrrrrrSr)rnrBrr!rrlr-r`rr<rAr_STOP_REASON_MAPr finish_reason)rprr response_texts r+_build_text_resultz"SamplingHandler._build_text_resultTs !.4"    D  hn GHgt44nc J J    #V/-2P2PQQQ.,001EyQQ     rSc@|ttdS)zjdxxdz cc<djdjdcYSt<$rQ}jdxxdz cc<dt?tA|cYd}~Sd}~wwxYwt|dds3jdxxdz cc<djdS|j!d }jd xxdz cc<tt|d!dd"d } tE| tFrjd#xx| z cc<|j$d$kr7t|j%d$r"|j%j&r'||S(||S)%zSampling callback invoked by the MCP SDK. Conforms to ``SamplingFnT`` protocol. Returns ``CreateMessageResult``, ``CreateMessageResultWithTools``, or ``ErrorData``. z5MCP server '%s' sampling rate limit exceeded (%d/min)rrz)Sampling rate limit exceeded for server 'z' (z requests/minute)modelPreferencesNr)call_llmrz:MCP server '%s' requested model '%s' not in allowed_modelszModel 'z' not allowed for server 'z '. Allowed: , systemPromptsystemr temperaturerc g|]G}dt|ddt|ddpdtt|ddddHS)rr{rr inputSchemaNr{rrOrr)r_normalize_mcp_input_schemarrus r+rz,SamplingHandler.__call__..s}   ' '62 6 6'.q-'D'D'J&A#A}d;;''!!     rSzFMCP server '%s' sampling request: model=%s, max_tokens=%d, messages=%dc 6dpdjS)Nmcp)taskr`r>r max_tokensrr\r\)rcall_temperature call_toolsrr>resolved_modelrpsr+ _sync_callz,SamplingHandler.__call__.._sync_calls88$,!,%   rSrz"Sampling LLM call timed out after zs for server 'r@zSampling LLM call failed: choicesz5LLM returned empty response (no choices) for server 'rcrrrdrX))rxr!r[r-rZrorrragent.auxiliary_clientrrgrarrr|rinsertminrTr^rrrlrasynciowait_for to_threadr\ TimeoutErrorr rrrr rfrrBrXrr)rpcontextrr` server_toolsrrr*rrrrrrr>rs` @@@@@@r+__call__zSamplingHandler.__call__tst%%''  NNG $,    L " " "a ' " " ";;4D nDL_6_6_ NNL .    L " " "a ' " " ";;S.SS$SS26))D * * Sv/B S OOAV=PQQ R R R)4+>??  6= ) ) 2f.@.L%1  vw55    &   J    T  nj#h--               $-!*--t|HH#    L " " "a ' " " ";;3T\33#/333       L " " "a ' " " ";;M_Xc]]-K-KMM       xD11  L " " "a ' " " ";;($(((  !!$ Z   A%   wx$??QRSS lC ( ( 8 L ' ' '< 7 ' ' '  L 0 0 55 1) 1..vx@@ @&&vx888s&3IA K8 K8'AK3-K83K8N)r)rrrrrrrrrboolrxr r staticmethodrrrrfrrrrrrRrSr+rRrRse  !*[PYZZ[C[[[[[.4Xc]OCOOO\OC4:CCCCN!!!3!!!\!7 7 7 r   *     }9}9}9}9}9rSrRschemacNt|tr|dnd}t|tr|sd|dSd|dg}|D]\}}d}d}t|trJt |ddpd}t |d dpd}|rd |d nd}|r|d ||d ||d ||d|S)a%Render a JSON-schema-ish requested_schema to a human-readable field list. Elicitation schemas are restricted to a flat object with named top-level properties. We surface field names, types, and descriptions so the user can tell what the server is asking for before approving. propertiesNz"Approval requested by MCP server 'z'.z Fields requested by MCP server 'z':rrrr r z - : r)r rrrrrr) rr-propslines field_name field_spec field_type field_descsuffixs r+"_format_elicitation_schema_summaryrsd)364(@(@ JFJJ| $ $ $dE eT " "D%DCKCCCC ? ? ? ? @E"'++-- 6 6 J  j$ ' ' FZ^^FB77=2>>JZ^^M2>>D"EEJ'19#j####r  6 LLB BFBBjBB C C C C LL4 4F44 5 5 5 5 99U  rScJeZdZdZdZd dedededfdZd efd Z d Z dS) ElicitationHandleraHandles ``elicitation/create`` requests for a single MCP server. Each ``MCPServerTask`` that has elicitation enabled creates one handler. The handler is callable and passed directly to ``ClientSession`` as the ``elicitation_callback`` (added in mcp Python SDK 1.11.0). Elicitation lets a server ask the client to collect structured input from the user mid-tool-call (e.g. payment authorization, OAuth confirmation). Form-mode elicitations are routed through Hermes' existing approval system (``tools.approval.prompt_dangerous_approval``), which surfaces the prompt on whichever surface the active session uses -- CLI, TUI, Telegram, Slack, etc. URL-mode elicitations are declined as unsupported. Failure modes are fail-closed: any timeout, exception, or unexpected state returns ``decline``/``cancel`` rather than silently accepting. The server treats this as the user not approving. rbNr-rowner MCPServerTaskc||_t|dddt|_||_ddddd|_dS)Nr\r`r)rcaccepteddeclinedr)r-rPrrGr\rro)rpr-rrs r+rrzElicitationHandler.__init__+sT&%VZZ 3%?%?eLL      rSr c d|iS)z?Return kwargs to pass to ClientSession for elicitation support.elicitation_callbackrRrs r+rz!ElicitationHandler.session_kwargs<s &--rSc Kjdxxdz cc<t|dd}|dkrEtdjjdxxdz cc<t d St|d d p d jd  t|dipi}t |j tdjt dd ddlm n]#t$rP}t dj|jdxxdz cc<t d cYd}~Sd}~wwxYwj rtj ddnddtf fd } tjtj|jjzd{V}n#tj$r[tdjt+jjdxxdz cc<t d cYSt$rR}t dj|djdxxdz cc<t d cYd}~Sd}~wwxYw|dkr&jd xxdz cc<t di!S|dkr%jdxxdz cc<t d Sjdxxdz cc<t d S)"zElicitation callback invoked by the MCP SDK. Conforms to ``ElicitationFnT`` protocol. Returns ``ElicitResult`` or ``ErrorData``. rcrmodeformrz`MCP server '%s' requested URL-mode elicitation; declining (URL-mode elicitation not implemented)rdecline)actionrBrrz' is requesting your approvalrequested_schemaz'MCP server '%s' elicitation request: %sNr)request_elicitation_consentz._invoke_consents22$' $5$5At/?AA ==??&&+ #DL 1 1=4+;== ' rSrz/MCP server '%s' elicitation timed out after %dscancelz&MCP server '%s' elicitation failed: %sTexc_infoacceptr)r r)rorr!rYr-rDrrtools.approvalr r r\rrrrrr\_OUTER_TIMEOUT_GRACE_SECONDSrr[rf) rprrrrr*ranswerrrrBr s ` @@@@r+rzElicitationHandler.__call__@s Z   A%   vvv.. 5== KKC     L $ $ $ ) $ $ $y111 1&)R00 J4+ J J J !3R88>B8AQRR  5  og66tt<    2 B B B B B B B 2 2 2 LLN #    L " " "a ' " " "y111 1 1 1 1 1 1  2*JN]74:'>EEEY]           $ 2"+!/22 t'HHFF# 1 1 1 NNA #dl"3"3    L " " "a ' " " "x000 0 0 0 2 2 2 LL8 #     L " " "a ' " " "y111 1 1 1 1 1 1  2 X   L $ $ $ ) $ $ $x<<< < X   L " " "a ' " " "x000 0 Z   A%   9----sE4C;; EAE EE ;GA'J . J 7AJ>J J N) rrrrrrrr rrrrrRrSr+rrs,$%   C  h>W    ".....l.l.l.l.l.rSrc eZdZdZdZdefdZdefdZdefdZ dZ de j fd Z d Zd Zd Zd"dZdefdZdefdZdefdZdZd dd dddedeedededd f dZdefdZdZdefdZdefdZd Zd"d!Zd S)#racManages a single MCP server connection in a dedicated asyncio Task. The entire connection lifecycle (connect, discover, serve, disconnect) runs inside one asyncio Task so that anyio cancel-scopes created by the transport client are entered and exited in the same Task context. Supports both stdio and HTTP/StreamableHTTP transports. )r{session tool_timeout_task_ready_shutdown_event_reconnect_event_toolsr_config _sampling _elicitation_registered_tool_names _auth_type _refresh_lock _rpc_lock_pending_refresh_tasksr initialize_result_ping_unsupportedr{c||_d|_t|_d|_t j|_t j|_t j|_ g|_ d|_ i|_ d|_ d|_g|_d|_t j|_t j|_t)|_d|_d|_d|_dS)NrF)r{r_DEFAULT_TOOL_TIMEOUTrr rEventr!r"r#r$rr%r&r'r(r)Lockr*r+setr,r r-r.)rpr{s r+rrzMCPServerTask.__init__s &* #8-1 moo &} !(  +/  48:>13#!$\^^!9<#EI" 15 (-rSr cd|jvS)z)Check if this server uses HTTP transport.r)r%rs r+_is_httpzMCPServerTask._is_https $$rSch|j}|t|ddnd}|dSt|ddduS)uWhether the server advertises the ``tools`` capability. Per the MCP spec, ``InitializeResult.capabilities.tools`` is non-None iff the server implements the ``tools/*`` request family. Prompt-only or resource-only servers omit it, and calling ``tools/list`` against them raises ``McpError(-32601 Method not found)`` — which previously killed the connection during discovery and made every keepalive fail. (Ported from anomalyco/opencode#31271.) Returns True when no capability info was captured (legacy fallback: preserve the old always-call-list_tools behavior rather than regress any server that was working before this gate). N capabilitiesTr)r-r)rp init_resultcapss r+_advertises_toolszMCPServerTask._advertises_toolssI, =H=Tw{ND999Z^ <4tWd++477rScK |d{VdS#tj$rt$r$td|jYdSwxYw)zBRun a dynamic tool refresh and log failures from background tasks.Nz,MCP server '%s': dynamic tool refresh failed)_refresh_toolsrCancelledErrorr r! exceptionr{rs r+_refresh_tools_taskz!MCPServerTask._refresh_tools_tasks X%%'' ' ' ' ' ' ' ' ' '%     X X X   KTY W W W W W W Xs 9AActj|}|j|||jj|S)zCSchedule a background tool refresh and keep it strongly referenced.)r create_taskr?r,addadd_done_callbackdiscardrprs r+_schedule_tools_refreshz%MCPServerTask._schedule_tools_refreshsT"4#;#;#=#=>> #''--- t:BCCC rScfd}|S)aBuild a ``logging_callback`` for ``ClientSession``. Routes MCP ``notifications/message`` log notifications from the server into Hermes' logging (agent.log via hermes_logging), tagged with the server name. Without this, the SDK's default callback silently discards them, so server-side warnings/errors during a tool call were invisible. Port of anomalyco/opencode#34529. c K ttt|ddt j}t|dd}t|tsD tj |dt}n&#ttf$rt|}YnwxYwt|dkr |dddz}t|dd}|r j d |nj }t|d ||dS#t $r&td j d YdSwxYw)NlevelrYrF)rrLiz... [truncated]r!/zMCP server log [%s]: %sz/Failed to handle MCP log notification from '%s'Tr)_MCP_LOG_LEVEL_MAPrrrrrhrjr rrrPrQrr{r!rr r")rrIr logger_nameoriginrps r+_on_logz5MCPServerTask._make_logging_callback.._on_log/s *..8899??AA7<vvt44!$,,))#z$UCPPP%z2)))"4yy)t99t##;)::D%fh== 9DSDI55 555$) 5";VTJJJJJ    EI s7A9D'?BD' B?<D'>B??A&D'',EErR)rprNs` r+_make_logging_callbackz$MCPServerTask._make_logging_callback&s#     .rScfd}|S)aBuild a ``message_handler`` callback for ``ClientSession``. Dispatches on notification type. Only ``ToolListChangedNotification`` triggers a refresh; prompt and resource change notifications are logged as stubs for future work. cK t|tr#tdj|dSt rt|t r|jxtdxS\t dj tj dd{VdSxtdx%\tdjdStdx$\tdjdS dSdSdS#t$r$tdjYdSwxYw)Nz'MCP message handler (%s): exception: %srRz9MCP server '%s': received tools/list_changed notificationrz/MCP server '%s': prompts/list_changed (ignored)z1MCP server '%s': resources/list_changed (ignored)z%Error in MCP message handler for '%s')r r r!r"r{_MCP_NOTIFICATION_TYPESrErootrFrYrFrsleeprGrHr>)rBrps r+_handlerz5MCPServerTask._make_message_handler.._handlerOs Ugy11LL!JDIW^___F*!z'CU/V/V!!,:8::::::"KK [ $ !88:::#*-"2"2222222222%;&=:<<<<<<"LL)Z\`\efffff=<>>>>>"LL)\^b^ghhhhh? D5!!!!6 U U U  !H$)TTTTTT Us)6D%A>D%=/D%.-D%D%%*EErR)rprUs` r+_make_message_handlerz#MCPServerTask._make_message_handlerHs)! U! U! U! U! UDrSc `Kddlm}sdSj4d{Vt j}j4d{Vjd{V}dddd{Vn#1d{VswxYwYt|dr|j ng}|fd|Dz }|D]&}| |t|'|_ tjj_t j}||z }||z } g} |r8| ddt'|| r8| ddt'| | r5t(d jd | n3t(d jt/jdddd{VdS#1d{VswxYwYdS) uaRe-fetch tools from the server and update the registry. Called when the server sends ``notifications/tools/list_changed``. The lock prevents overlapping refreshes from rapid-fire notifications. After the initial ``await`` (list_tools), all mutations are synchronous — atomic from the event loop's perspective. rregistryNrcDh|]}tj|jSrR)mcp_prefixed_tool_namer{)rrrps r+ z/MCPServerTask._refresh_tools..s7111'ty$)<<111rSzadded: rz removed: uUMCP server '%s': tools changed dynamically — %s. Verify these changes are expected.rz>MCP server '%s': dynamically refreshed %d tool(s) (no changes))tools.registryrYr:r*r3r(r+r list_toolsr|r deregister_forget_mcp_tool_serverr$_register_server_toolsr{r%rrsortedr!r[rYr) rprYold_tool_names tools_result new_mcp_toolsstale_tool_namesrnew_tool_namesaddedremovedchangess ` r+r<zMCPServerTask._refresh_toolsss ,+++++%%''  F%1 1 1 1 1 1 1 1  !<==N~ ? ? ? ? ? ? ? ?%)\%<%<%>%>>>>>>>  ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?29,2P2PXL..VXM .1111)111  . 3 3 ##I...' 2222(DK*@ 4++D ' !!<==N"^3E$~5GG EC6%==)A)ACCDDD IG499VG__+E+EGGHHH 9Ityy11  TIs4#>??]1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 s6"H B/H B HB E;H H'*H'NcK|js tj|jdd{VdS#t $rV}t |s|sd|_t d|j Yd}~nd}~wwxYwtj|j dd{VdS)ubExercise the session to detect a stale/expired connection. Uses ``ping`` (cheap, transport-agnostic liveness) by default. ``ping`` is an OPTIONAL MCP utility: a server that doesn't implement it answers JSON-RPC -32601. The first time that happens we latch ``_ping_unsupported`` and fall back to the pre-ping probe — capability permitting, ``list_tools``; otherwise ``ping`` is the only option and the -32601 propagates (a server advertising neither a working ping nor tools has no liveness primitive left). The latch resets on each fresh transport connection so a server that gains ping support after a reconnect is re-probed with the cheap path. Raises on a genuine connection failure so the caller triggers a reconnect; returns normally when the session is alive. >@rNTz~MCP server '%s': does not implement the optional 'ping' utility (-32601); using 'list_tools' for keepalive on this connection.) r.rrr send_pingr rr:r!rYr{r^)rpr*s r+_keepalive_probezMCPServerTask._keepalive_probes %  &t|'='='?'?NNNNNNNNNN   2#66--//)-& 'I  $t|6688$GGGGGGGGGGGGs3A B  A BB c JKttt|jdt }t j|j }t j|j } t j ||h|t j d{V\}}|rnu|j rm | d{VnQ#t$rD}td|j||j Yd}~n d}~wwxYw||fD]P}|s:| |d{V4#t jtf$rYLwxYwQnZ#||fD]P}|s:| |d{V4#t jtf$rYLwxYwQwxYw|jrdS|j dS)u1Block until either _shutdown_event or _reconnect_event fires. Returns: "shutdown" if the server should exit the run loop entirely. "reconnect" if the server should tear down the current MCP session and re-enter the transport (fresh OAuth tokens, new session ID, etc.). The reconnect event is cleared before return so the next cycle starts with a fresh signal. Shutdown takes precedence if both events are set simultaneously. Periodically sends a lightweight keepalive (``ping``, with a ``list_tools`` fallback for servers that don't implement the optional ping utility — see :meth:`_keepalive_probe`) to prevent TCP/session state from going stale during idle periods (#17003). If the keepalive fails, triggers a reconnect. The cadence is ``keepalive_interval`` from server config (default :data:`_DEFAULT_KEEPALIVE_INTERVAL`, floored at :data:`_MIN_KEEPALIVE_INTERVAL`). Servers that GC idle sessions on a short TTL (e.g. Unreal Engine's editor MCP, ~15s) need an interval below that TTL, otherwise every idle tool call lands on an already-expired session and pays the full reconnect path. keepalive_intervalT)r\ return_whenNz:MCP server '%s' keepalive failed, triggering reconnect: %sshutdown reconnect)rJ_MIN_KEEPALIVE_INTERVALrGr%r_DEFAULT_KEEPALIVE_INTERVALrrAr"waitr#FIRST_COMPLETEDrrnr r!r[r{r3donerr=is_setclear)rprp shutdown_taskreconnect_taskrx_pendingr*rus r+_wait_for_lifecycle_eventz'MCPServerTask._wait_for_lifecycle_events@! # $,""#79TUU V V    +D,@,E,E,G,GHH  ,T-B-G-G-I-IJJ$  '.|"N3. ' 7(((""""""h <  "335555555555$7 Is -11333) :$^4  vvxxHHJJJ#2I>  m^4  vvxxHHJJJ#2I>     & & ( ( : ##%%%{sl7FC-,F- D;7:D61F6D;;F.E77FF/G,G G,G' $G,&G' 'G,cKtj|j}tj|j} tj||htjd{V||fD]P}|s:| |d{V4#tjtf$rYLwxYwQnZ#||fD]P}|s:| |d{V4#tjtf$rYLwxYwQwxYw|j rdS|j dS)uBlock until a reconnect or shutdown is requested while parked. Used by :meth:`run` after the reconnect budget is exhausted. The task stays alive (so ``_reconnect_event`` always has a listener) but does no work until something explicitly asks it to come back — the circuit-breaker half-open probe, OAuth recovery, or a manual ``/mcp`` refresh. Returns: ``"shutdown"`` if the server should exit the run loop entirely, ``"reconnect"`` if it should rebuild the transport. The reconnect event is cleared before returning so the next park cycle starts from a fresh signal. Shutdown takes precedence. )rqNrrrs) r ensure_futurer"rvr#rwrxrr=r ryrz)rpr{r|rus r+_wait_for_reconnect_or_shutdownz-MCPServerTask._wait_for_reconnect_or_shutdown0s -d.B.G.G.I.IJJ  .t/D/I/I/K/KLL ,/#3        $^4  vvxxHHJJJ#2I>  m^4  vvxxHHJJJ#2I>     & & ( ( : ##%%%{sB(C1B::CC/D/DD/D* 'D/)D* *D/rc Ktstd|jd|d}|dg}|d}|st d|jdt |}t ||\}}ddlm} tj tj |||t d {V}n=#tj $r+td |jtd }YnwxYw|rt d|jd |t!|||r|nd }|jr|jni} |jr,| |jt*rt,r|| d<t0r|| d<t5} t7} t9|jt;} t=|| 4d {V\} }t?t5| z } | ri}| D]7} tAj!|||<#tDtFtHf$rY4wxYwtJ5| D]}|jtL|<tN|d d d n #1swxYwYtQ| |fi| 4d {V }|)d {V|_*||_+|,d {V|j-t]|j|/d {Vd d d d {Vn#1d {VswxYwYd d d d {Vn#1d {VswxYwY| rddl0m1}tet@dd }tJ5| D]}tL3|d | D]}||}d}tN|}|s3|1|/ ||dd}n#tFthtHf$rd}YnwxYw|s|rtj6|}tN3|d  d d d d S#1swxYwYd Sd S#| rddl0m1}tet@dd }tJ5| D]}tL3|d | D]}||}d}tN|}|s3|1|/ ||dd}n#tFthtHf$rd}YnwxYw|s|rtj6|}tN3|d  d d d w#1swxYwYwwxYw)z%Run the server using stdio transport.rz' requires the 'mcp' Python SDK, but it is not installed. Install with: pip install 'hermes-agent[mcp]' or (full install): pip install 'hermes-agent[all]'rrrz' has no 'command' in configr)check_package_for_malwarerNuyMCP server '%s': OSV malware preflight timed out after %.0fs (network slow/unreachable) — proceeding without the check.r)rrrrJrW)errlog _pid_existskillpgFT)7rLrr{rrQrrtools.osv_checkrrrr_OSV_MALWARE_CHECK_TIMEOUT_Srr!r[r6r&rr'rrR_MCP_MESSAGE_HANDLER_SUPPORTEDrV_MCP_LOGGING_CALLBACK_SUPPORTEDrO_snapshot_child_pidsr3r4r,r7_filter_mcp_childrenr#getpgidAttributeErrorProcessLookupErrorOSError_lock _stdio_pids _stdio_pgidsr5 initializer-r_discover_toolsr!_reset_server_errorr~gateway.statusrrpopPermissionError_orphan_stdio_pidsrB)rprrrrsafe_envr malware_error server_paramssampling_kwargs pids_beforenew_pids_errlog read_stream write_stream new_pgids_pidrr_killpgpid pid_alive pgroup_alivepgids r+ _run_stdiozMCPServerTask._run_stdioSs  4ty444 **Y''zz&"%%::e$$ FtyFFF #8,,27HEE >===== !")"2!";WdKK4###MM# ! ! ! NNO 7    !MMM  !  B^S$.77999QS   G  " "4#4#C#C#E#E F F F " N'E N151K1K1M1MO- . * P262M2M2O2OO. /+,,  !+++%''P 8#M'BBB- ;- ;- ;- ;- ;- ;- ;G0(**[87 13I (!!!.0j.>.>IdOO .0BGL!!!!D!77$,::D04 K--$++I666777777777777777)1@;;;;;;;;3:3E3E3G3G-G-G-G-G-G-GD*#*DL..000000000KOO%%%( 22288:::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;?- ;- ;- ;- ;- ;- ;- ;- ;- ;- ;- ;- ;- ;- ;- ;- ;- ;- ;- ;- ;- ;- ;- ;- ;- ;- ;- ;h 8666666!"h5588 (44#d3333'88%0K$4$4 ', +//44( 5T-='BU 5 'a 0 0 0/3 $6#Q555/4 5$8 8.2237777),,S$7777+8888888888888888888 8 8x 8666666!"h5588 (44#d3333'88%0K$4$4 ', +//44( 5T-='BU 5 'a 0 0 0/3 $6#Q555/4 5$8 8.2237777),,S$7777+88888888888888888 8s/%5C7DD!S8*N7#I;:N7;JN7J N7/K N7K N7!K "N7:BNN7 N N7!N "N7%S7 OSOS-AR7QR7Q+(R7*Q++>R77R;>R;&W,AV5?U V5U* 'V5)U* *>V5) W5V9 9W<V9 =W)zapplication/jsonztext/event-streamTg@)headers ssl_verifyrr\rrrr\c "K ddl}n#t$rYdSwxYw|d||d}|||d<|rt|ni} |jdi|4d{V} | ||d{V} | jdvr| ||d{V} dddd{Vn#1d{VswxYwYn#|j$rYdSwxYwd| jcxkrd ksndS| j d d  d d } | sdS| |j vrdStd |jd|d| dd|j d )uProbe *url* for an MCP-shaped response before the SDK connects. A misconfigured ``mcp_servers..url`` pointed at a plain web app returns HTML (or some other non-MCP body). The MCP SDK then sits on the connection for the full ``connect_timeout`` (default 60 s) before surfacing an opaque ``CancelledError``. A cheap, short-timeout probe here catches that in ≤ ``timeout`` seconds and raises :class:`NonMcpEndpointError` with an actionable message. Detection is allow-list based: a 2xx response is rejected only when it carries a definite content type that is NOT one an MCP endpoint uses (``application/json`` / ``text/event-stream``). A missing or empty content type, non-2xx status, or any network/transport error passes through silently — the probe is strictly best-effort, and the real handshake remains the source of truth for everything except the unambiguous "this is a web page, not MCP" case. Runs on its own httpx client OUTSIDE the SDK's anyio task group, so the raised error propagates as itself rather than being wrapped in an ``ExceptionGroup`` (which is what defeats hooks installed inside the SDK transport). rNT)verifyfollow_redirectsr\cert)r)iir r`z content-typerrrz' at z returned Content-Type 'z)', not an MCP response (expected one of: ru). The URL most likely points at a web page rather than an MCP endpoint — check it resolves to a Streamable HTTP / SSE endpoint (e.g. https://host/mcp, not https://host/).rR)httpxrTimeoutr AsyncClienthead status_coder HTTPErrorrrrr_MCP_CONTENT_TYPESrr{r) rprrrrr\_httpx client_kwargs probe_headersclientrespct_bases r+_preflight_content_typez%MCPServerTask._preflight_content_types>  " " " " "    FF ! $~~g..   "$/M& !)08W b  )v)::M:: H H H H H H Hf$[[m[DDDDDDDD#z11!'C!G!GGGGGGGDG  H H H H H H H H H H H H H H H H H H H H H H H H H H H     FF  t'----#---- F,"">266<.Is0LLS399;;"88LLLLLLrSrconnect_timeoutrTNoauthr get_managerz#MCP OAuth setup failed for '%s': %srJrW transportssezt' requires SSE transport but mcp.client.sse.sse_client is not available. Upgrade the mcp package to get SSE support.r@)rrr\sse_read_timeoutauthcdd}|||d<ndd|d<|||d<|||d<|d <jd i|S) NT)rrr\rlrreadrrrrR)rr)rr\rkwargs_cert_for_factory _httpx_mod_verify_for_factorys r+_mcp_http_client_factoryz9MCPServerTask._run_http.._mcp_http_client_factorys-1"5$$F*,3y)),6,>,>t%,>,P,Py)*,3y)')-v(4):v1:1;;F;;;rShttpx_client_factoryrsuAMCP server '%s': reconnect requested — tearing down SSE sessionc K|jr|jrz|jj}|j|j|jfjjjfkrF|jjdd|jjdddSdSdSdS)zBStrip Authorization headers when redirected to a different origin. authorizationN Authorization) is_redirect next_requestrrhostportrr)rtarget _original_urls r+$_strip_auth_on_cross_origin_redirectzEMCPServerTask._run_http.._strip_auth_on_cross_origin_redirects'QH,AQ%26F v{FK@%,m.@-BTE!-599/4PPP -599/4PPPPP QQQQrSrr)rr\r event_hooksr) http_clientuBMCP server '%s': reconnect requested — tearing down HTTP session)rr\ruIMCP server '%s': reconnect requested — tearing down legacy HTTP session)NNNrR),_MCP_HTTP_AVAILABLErr{rranyr:_DEFAULT_CONNECT_TIMEOUTr'r)tools.mcp_oauth_managerrget_or_build_providerr r!r[r&rr'rrRrrVrrOr;rGrr5rr-rrr!r3rr~rY _MCP_NEW_HTTPURLrrr9r8)rprrrrrr _oauth_authrr*r _sse_kwargsrrrrrrrrr_get_session_id _http_kwargsrrrrs @@@@r+ _run_httpzMCPServerTask._run_http:s " ?ty???  Umvzz),,233 LLGLLLLL F.EG* + **%68PQQZZ d33 *49f==  ?g % % ??????)kmmAAIsFJJw$7$7    DdiQTUUU >B^S$.77999QS   G  " "4#4#C#C#E#E F F F " N'E N151K1K1M1MO- . * P262M2M2O2OO. / ::k " "e + +!!B49BBB"?d 11$) !!K &'2 F#&*D*@*@ +***$/!&0#6:<<<<<<<<&7O 23!00K00       4O[,(1@3:3E3E3G3G-G-G-G-G-G-GD*#*DL..000000000KOO%%%( 222#'#A#A#C#CCCCCCCF,, 78<                            $ F M  LLL!IIcNNM Q Q Q Q Q%) ==)?)?e=LL$ *-Q,RS ##M  3+2 i(&(3 f%&(3 f%)u(99=99       [1#;OOOT,[,ZZ/ZZ^e7>7I7I7K7K1K1K1K1K1K1K.'. "22444444444 ))),DI666'+'E'E'G'G!G!G!G!G!G!G![00"KK!<=AY                              ,# 11$""L &'2 V$,SAALAA       F\?(lVVoVVZa3:3E3E3G3G-G-G-G-G-G-GD*#*DL..000000000KOO%%%( 222#'#A#A#C#CCCCCCCF,, ?@D                               s =D D8"D33D8M0B.L0M0 L: :M=L: >M M M T8S4B.S?S4 S S4S S4"T4 S> >TS> T T"%T"Y1B.X1Y1 X; ;Y>X; ?Y Y"YcKd|_|jdS|s)td|jg|_dS|j4d{V|jd{V}dddd{Vn#1d{VswxYwYt|dr|j ng|_dS)uDiscover tools from the connected session. Capability-gated: prompt-only / resource-only MCP servers don't implement ``tools/list``, and calling it raises ``McpError(-32601)``, which previously aborted the connection — those servers could never stay connected for their prompts/resources. Skip the call when the server doesn't advertise the ``tools`` capability. (Ported from anomalyco/opencode#31271.) FNusMCP server '%s': does not advertise 'tools' capability — skipping tools/list (prompts/resources remain available)r) r.rr:r!rYr{r$r+r^r|r)rprds r+rzMCPServerTask._discover_tools sf"' <  F%%''  KKK     DK F> ; ; ; ; ; ; ; ;!%!8!8!:!:::::::L ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;|W-- L   s B BBc K||_|dt|_|dpd|_|di}|ddr"trt|j ||_ nd|_ |di}|ddr$trt|j || |_ nd|_ d |vr$d |vr td |j |r t#|j |d nS#t$$rF}td |||_|jYd}~dSd}~wwxYw|ddkr|js|jdkr t/|dpi}||d ||ddt3|j |d{VnS#t4$rF}td |||_|jYd}~dSd}~wwxYwd}d}d} |r||d{Vn||d{V|jr d|_dStd|j d}d}d|_ d|_#t@j!$r d|_tD$r$}d|_|jsotG|rNtd|j |||_|jYd}~d|_dS|dz }|tHkrTtd|j tH|||_|jYd}~d|_dStd|j |tH||tAj%|d{VtM|dztN}|jr-||_|jYd}~d|_dSYd}~d|_U|jr.t(d|j |Yd}~d|_dS|dz }|tRkrtd|j tR||*|j+,|-d{V} | dkr Yd}~d|_dStd|j d}d}Yd}~d|_^td |j |tR||tAj%|d{VtM|dztN}|jr Yd}~d|_dSYd}~nd}~wwxYw d|_n #d|_wxYw)!zLong-lived coroutine: connect, discover tools, wait, disconnect. Includes automatic reconnection with exponential backoff if the connection drops unexpectedly (unless shutdown was requested). r\rrsamplingenabledTN elicitation)rrrzMCP server '%s' has both 'url' and 'command' in config. Using HTTP transport ('url'). Remove 'command' to silence this warning.z%srrrrr)rrrrg?z@MCP server '%s': reconnecting (OAuth recovery or manual refresh)zSMCP server '%s' failed initial OAuth authentication, not retrying automatically: %srzJMCP server '%s' failed initial connection after %d attempts, giving up: %szPMCP server '%s' initial connection failed (attempt %d/%d), retrying in %.0fs: %srz0MCP server '%s' disconnected during shutdown: %szaMCP server '%s' failed after %d reconnection attempts, parking until a reconnect is requested: %srrzHMCP server '%s': reconnect requested while parked; rebuilding transport.zJMCP server '%s' connection lost (attempt %d/%d), reconnecting in %.0fs: %s).r%rr0rrrr)rrRr{r&_MCP_ELICITATION_TYPESrr'r!r[r5rrrr!r3ryrrr'rrrr"rrYrr=r _is_auth_error_MAX_INITIAL_CONNECT_RETRIESrTr_MAX_BACKOFF_SECONDSr"_MAX_RECONNECT_RETRIES_deregister_toolsr#rzr) rprsampling_configelicitation_configr*_probe_headersretriesinitial_retriesbackoffparkeds r+rzMCPServerTask.run' s  "JJy2GHH!::f--3::<<BBDD!**Z44   y$ / / "4G ",TYHHDNN!DN $ZZ r::  ! !)T 2 2 %7M % 249>PX\ ] ] ]D   $D  F??yF22 NN      ==??"  (FJJu4E4EFFFF%   tS)))!  !!!  $zz+&&%// 8J8J8L8L/QUQ`dkQkQk %)&**Y*?*?*E2%F%FN66u .#)::lD#A#A$8F$K$K 7 +NN4---"%DKKOO%%%FFFFF  O $N $==??2..0000000000//&111111111 '..00F $ E &I $ \ $ [)    $ _ _ _ # {))++$%c**= Is '*  )))b $ _$q(O&)EEE9 I'CS '*  )))L $ INNA ?4gs  "-000000000!'A+/CDDG+2244&)  )))n $ mHHHl $ g'..00LLJ 3FFF\ $ Y1 333NNE #93**,,,)//111#'#G#G#I#IIIIIIIF++. $ -KK0   G!GHHH $ 0Iw(>S  mG,,,,,,,,,gk+?@@'..00FFF# }_ | $ t ####_O $s(E== G ;GG A0I?? K ;K  KA$M<+M<>>>>>>>>>>'   II !!###*$$$$$$$$-D   & 0T899   .$"=VQUVV V V V V V V V  ' - - / / /     s7!A88AC' CC'C!C' C!!C'&C'cddlm}tt|dgD]&}||t |'g|_dS)aDrop this server's tools from the global registry (idempotent). Pulls the server's tool schemas out of the registry so the agent stops advertising them to the model. Called on shutdown AND when the reconnect budget is exhausted, so a dead server never leaves phantom tool definitions bloating the prompt cache and producing "not connected" errors on every turn. rrXr(N)r]rYr rr_r`r()rprYrs r+rzMCPServerTask._deregister_tools. sm ,+++++gd,DbIIJJ / /I    * * * #I . . . .&(###rS)r N) rrrr __slots__rrrrr5r:r?rTaskrFrOrVr<rnr~rrrrr rGrrrrrrrrrRrSr+rrsU I2-S2-2-2-2-h%$%%%%848888,XXX   D)))VAAAF&H&H&H&HPPPPPPd!s!!!!FU8tU8U8U8U8tC #'I I I I $ I  I I  I I I I VKdKKKKZ   @`$`$`$`$`$D$<))))))rSr_servers_server_connecting_server_connect_errors_server_error_counts_server_breaker_opened_atgN@ct|ddz}|t|<|tkrtjt |<dSdS)aIncrement the consecutive-failure count for ``server_name``. When the count crosses :data:`_CIRCUIT_BREAKER_THRESHOLD`, stamp the breaker-open timestamp so the cooldown clock starts (or re-starts, for probe failures in the half-open state). rrN)r r_CIRCUIT_BREAKER_THRESHOLDrw monotonicr )r-ns r+_bump_server_errorr^ sV   a0014A()% &&&151A1A!+...'&rScPdt|<t|ddS)zFully close the breaker for ``server_name``. Clears both the failure count and the breaker-open timestamp. Call this on any unambiguous success signal (successful tool call, successful reconnect, manual /mcp refresh). rN)r r rr-s r+rrk s+)*%!!+t44444rSserverct|dd}|dSt}|/|r||jn|dS)a*Ask a server task to rebuild its transport, thread-safely. The tool handlers run on caller threads, while the server task and its ``_reconnect_event`` live on the background MCP loop. Setting an asyncio.Event from another thread must go through ``loop.call_soon_threadsafe``; only fall back to a direct ``.set()`` when the loop isn't running (e.g. unit tests that drive the handler synchronously). Returns True if a reconnect signal was delivered, False if the server has no reconnect machinery (nothing to revive). r#NFT)r _mcp_loop is_runningcall_soon_threadsafer3)reventloops r+_signal_reconnectrv se F. 5 5E }u D DOO-- !!%),,,, 4rSrR_AUTH_ERROR_TYPESctrtSg} ddlm}m}|||gn#t $rYnwxYw ddlm}||n#t $rYnwxYw ddlm }||n#t $rYnwxYw ddl }||j n#t $rYnwxYwt|atS)uReturn a tuple of exception types that indicate MCP OAuth failure. Cached after first call. Includes: - ``mcp.client.auth.OAuthFlowError`` / ``OAuthTokenError`` — raised by the SDK's auth flow when discovery, refresh, or full re-auth fails. - ``mcp.client.auth.UnauthorizedError`` (older MCP SDKs) — kept as an optional import for forward/backward compatibility. - ``tools.mcp_oauth.OAuthNonInteractiveError`` — raised by our callback handler when no user is present to complete a browser flow. - ``httpx.HTTPStatusError`` — caller must additionally check ``status_code == 401`` via :func:`_is_auth_error`. r)OAuthFlowErrorOAuthTokenError)UnauthorizedError)OAuthNonInteractiveErrorN) rmcp.client.authrrr;rr rtools.mcp_oauthr!rHTTPStatusErrorr!)typesrrr r!rs r+_get_auth_error_typesr& s`!  E CCCCCCCC no67777       555555 &''''       <<<<<< -....         U*++++      e  sB2 ??A A,+A,0B BBB<< C C ct}|rt||sdS ddl}t||jrt |jdddkSn#t $rYnwxYwdS)zReturn True if ``exc`` indicates an MCP OAuth failure. ``httpx.HTTPStatusError`` is only treated as auth-related when the response status code is 401. Other HTTP errors fall through to the generic error path in the tool handlers. FrNriT)r&r rr$rrr)r*r%rs r+rr s " # #E  3..u  c50 1 1 E3<==D D E      4s2A A%$A%op_descriptionc^ t|sdSddlm}| fd} t|d}n5#t$r(}t d|d}Yd}~nd}~wwxYw|rt5t dddn #1swxYwYtd rt}|| rz| jjd t ffd } t| d n3#t$r&}t d |Yd}~nd}~wwxYwt# |} t%j| } d| vrt#| Sn-#t$jt*f$rt#| cYSwxYwn4#t$r'} t d|| Yd} ~ nd} ~ wwxYwt-t%jddddddS)aQAttempt auth recovery and one retry; return None to fall through. Called by the 5 MCP tool handlers when ``session.()`` raises an auth-related exception. Workflow: 1. Ask :class:`tools.mcp_oauth_manager.MCPOAuthManager.handle_401` if recovery is viable (i.e., disk has fresh tokens, or the SDK can refresh in-place). 2. If yes, set the server's ``_reconnect_event`` so the server task tears down the current MCP session and rebuilds it with fresh credentials. Wait briefly for ``_ready`` to re-fire. 3. Retry the operation once. Return the retry result if it produced a non-error JSON payload. Otherwise return the ``needs_reauth`` error dict so the model stops hallucinating manual refresh. 4. Return None if ``exc`` is not an auth error, signalling the caller to use the generic error path. Args: server_name: Name of the MCP server that raised. exc: The exception from the failed tool call. retry_call: Zero-arg callable that re-runs the tool call, returning the same JSON string format as the handler. op_description: Human-readable name of the operation (for logs). Returns: A JSON string if auth recovery was attempted, or None to fall through to the caller's generic error path. Nrrc@Kdd{VSr) handle_401)managerr-sr+_recoverz._handle_auth_error_and_retry.._recover s/'' T:::::::::rSr[rz+MCP OAuth '%s': recovery attempt failed: %sFr#r c Ktjdz}tj|krSjjrdSt jdd{Vtj|kSdS)NT?F)rwrrr!ryrrT)deadlinesrvs r+ _await_readyz2_handle_auth_error_and_retry.._await_ready s#~//"4H.**X55;2sz7H7H7J7J2#'4%mD111111111.**X55!5rSr/z%MCP OAuth '%s': ready poll failed: %sr\z.MCP %s/%s retry after auth recovery failed: %srz4' requires re-authentication. Run `hermes mcp login u` (or delete the tokens file under ~/.hermes/mcp-tokens/ and restart). Do NOT retry this tool — ask the user to re-authenticate.T)r\ needs_reauthrr)rrr_run_on_mcp_loopr r!r[rrrr|rrrr#r3rrrrrrPrr)r-r* retry_callr(rr- recoveredrec_excrr3rOr retry_excr,r2s` @@r+_handle_auth_error_and_retryr: snD #  t333333kmmG;;;;;;$Xr:::  9     5  , ,,,{++C , , , , , , , , , , , , , , , ?ws,>???DDOO$5$5))#*>*BCCC!D!!!!!!$\\^^R@@@@@ NN?#S K((( Z\\F F++&((' 444!M)()4   #K000  )     NN@^Y         {### : >; > >%0 > > >       s{> A0A++A0=B$$B(+B( D%% E/EE( G 3(FG 'GG GG G<G77G<) zinvalid or expired sessionzexpired sessionzsession expiredzsession not foundzunknown sessionzsession terminatedclosedresourceerrorzclosed resourceztransport is closedzconnection closedz broken pipez end of file_SESSION_EXPIRED_MARKERSct|trdSt|sdSt fdt DS)uReturn True if ``exc`` looks like an MCP transport session expiry. Streamable HTTP MCP servers may garbage-collect server-side session state while the OAuth token remains valid — idle TTL, server restart, horizontal-scaling pod rotation, etc. The SDK surfaces this as a JSON-RPC error whose message contains phrases like ``"Invalid or expired session"``. This class of failure is distinct from :func:`_is_auth_error`: re-running the OAuth refresh flow would be pointless because the access token is fine. What's needed is a transport reconnect — tear down and rebuild the ``streamablehttp_client`` + ``ClientSession`` pair, which is exactly what ``MCPServerTask._reconnect_event`` triggers. Fc3 K|]}|vV dSrrR)rmarkerrs r+rz,_is_session_expired_error..z s'DDv}DDDDDDrS)r InterruptedErrorrrrr<)r*rs @r+_is_session_expired_errorrAc se#'((u c((..  C u DDDD+CDDD D DDrSct|sdSt5t|}dddn #1swxYwY|t |dsdSt }||sdStd|||| |j j tj dz}d}tj |krN|j|jrd}n+tjdtj |kN|std|dS |} t'j|} d | vr d t*|<|Sn(#t&jt.f$rd t*|<|cYSwxYwn4#t0$r'} td ||| Yd} ~ nd} ~ wwxYwdS) uOTrigger a transport reconnect and retry once on session expiry. Unlike :func:`_handle_auth_error_and_retry`, this does **not** call the OAuth manager's ``handle_401`` — the access token is still valid, only the server-side session state is stale. Setting ``_reconnect_event`` causes the server task's lifecycle loop to tear down the current ``streamablehttp_client`` + ``ClientSession`` and rebuild them, reusing the existing OAuth provider instance. See #13383. Args: server_name: Name of the MCP server that raised. exc: The exception from the failed call. retry_call: Zero-arg callable that re-runs the operation, returning the same JSON string format as the handler. op_description: Human-readable name of the operation (logs). Returns: A JSON string if reconnect + retry was attempted and produced a response, or ``None`` to fall through to the caller's generic error path (not a session-expired error, no server record, reconnect didn't ready in time, or retry also failed). Nr#zmMCP server '%s': %s failed with session-expired error (%s); signalling transport reconnect and retrying once.r/FTr0zsMCP server '%s': reconnect did not ready within 15s after session-expired error; falling through to error response.r\rz2MCP %s/%s retry after session reconnect failed: %s)rArrrr|rrr!rYrr#r3rwrrr!ryrTr[rrr rrPr ) r-r*r6r(r2rr1readyrOrr9s r+!_handle_session_expired_and_retryrD} s~: %S ) )t ((ll;''((((((((((((((( {'#'9::{t D |4??,,|t KK <^S c26777~"$H E .  X % % ; "sz'8'8':': "E  4 .  X % %  H    t  Z''Ff$$45$[1 %$i0   01  -MMM %     @          4sMAAA F0"#FF0"F,)F0+F,,F00 G!:GG!_parallel_safe_servers_mcp_tool_server_namesr _mcp_threadrrrctj} d|d|d}t|d5}d|DcdddS#1swxYwYn#t t tf$rYnwxYw ddl}d | | DS#t$rYnwxYwtS) zReturn a set of current child process PIDs. Uses /proc on Linux, falls back to psutil, then empty set. Used by _run_stdio to identify the subprocess spawned by stdio_client. z/proc/z/task/z /childrenrrcTh|]%}|t|&SrR)rrf)rps r+r\z'_snapshot_child_pids.. s+BBBq BCFFBBBrSNrch|] }|j SrR)r)rcs r+r\z'_snapshot_child_pids.. sAAA!AAArS) r#getpidrrrrrrQpsutilProcesschildrenr r3)my_pid children_pathfrNs r+rr s\ Y[[F @@@v@@@ -' 2 2 2 CaBBAFFHHNN$4$4BBB C C C C C C C C C C C C C C C C C w 3       AAv~~f55>>@@AAAA       55LsFA80A, A8,A00A83A04A88BB4C CC)ztui_gateway.slash_workerztui_gateway.entryz-dorg.eclipse.equinox.launcherzeclipse.jdt.lszorg.eclipse.equinox.launcher_._NON_MCP_CHILD_CMDLINE_MARKERSpidsc^|s|S ddl}n#t$r|cYSwxYwt}|D]} ||}n#|j|jtf$rYDwxYwtd|ddDrj| ||S)aRemove non-MCP children from a PID snapshot delta. _snapshot_child_pids() returns *all* direct children of the gateway. When a stdio MCP server spawns concurrently with a slash_worker or LSP server spawn, the delta ``_snapshot_child_pids() - pids_before`` can include PIDs that are NOT the MCP server. Tracking those PIDs in _stdio_pgids is catastrophic if a future child lacks start_new_session: its pgid can be the TUI parent's PID, so the shutdown sweep's killpg() kills the TUI itself. rNc32K|]}tD]}||vV dSr)rT)rargr?s r+rz'_filter_mcp_children..B sQ  8   cM       rSr) rNrr3rOcmdline NoSuchProcess AccessDeniedrrrB)rUrNfilteredrargvs r+rr) s     EEH   >>#&&..00DD$f&97C    H    ABBx        S Os 'AA21A2c|d}t|trdt|vrdS||dS)aSuppress benign 'Event loop is closed' noise during shutdown. When the MCP event loop is stopped and closed, httpx/httpcore async transports may fire __del__ finalizers that call call_soon() on the dead loop. asyncio catches that RuntimeError and routes it here. We silence it because the connection is being torn down anyway; all other exceptions are forwarded to the default handler. r>zEvent loop is closedN)rr  RuntimeErrorrdefault_exception_handler)rrr*s r+_mcp_loop_exception_handlerraL sW ++k " "C#|$$)?3s88)K)K""7+++++rSczt5t'tr ddddStjatt tjtj dda t ddddS#1swxYwYdS)z>Start the background event loop thread if not already running.Nzmcp-event-loopT)rr{daemon) rrrrnew_event_loopset_exception_handlerra threadingThread run_foreverrGrrRrSr+_ensure_mcp_loopri[ s      Y%9%9%;%;         *,, ''(CDDD&(!                     s"B0A,B00B47B4cororc ddlm}mm|n#t$rcYSwxYwsSfd}|S)uWCarry the caller's context-local HERMES_HOME override into ``coro``. Returns ``coro`` unchanged when no override is active. Otherwise wraps it so the override is set inside the coroutine's own (task-local) context on the MCP loop and reset when it completes — concurrent calls carrying different scopes don't interfere. r)get_hermes_home_overridereset_hermes_home_overrideset_hermes_home_overridechK} d{V |S#|wxYwrrR)tokenrj home_overridermrns r+_scopedz)_wrap_with_home_override.._scoped sZ((77 .::::::  & &u - - - - & &u - - - -s$ 1)rrlrmrnr )rjrlrrrqrmrns` @@@r+_wrap_with_home_overridersk s           1022    ........ 799s  **r]r\cddlm}ddlm}t5t }dddn #1swxYwY||s7tj|r| tdt|r |n|}t|}|||td}|tdtj}|dn||z} |r#|t#d d } |{|tjz } | dkrO|tj|z } t%d | d dt'|d dt)| | } || S#t,jj$rYwxYw)aSchedule a coroutine on the MCP event loop and block until done. Accepts either a coroutine object or a zero-arg callable that returns one. Callers can pass a factory to avoid constructing coroutine objects when the MCP loop is unavailable (which would otherwise leak the coroutine frame and emit ``"coroutine was never awaited"`` warnings). Poll in short intervals so the calling agent thread can honor user interrupts while the MCP work is still running on the background loop. r)is_interruptedsafe_schedule_threadsafeNzMCP event loop is not runningzMCP scheduling failedr! log_messagez/MCP event loop unavailable (failed to schedule)TzUser sent a new messageg?zMCP call timed out after z.1fzs (configured timeout: zs)r)tools.interruptruagent.async_utilsrwrrrr iscoroutinecloser_callablersr!rwrrr@rrGrrO concurrentfutures) coro_or_factoryr\rurwrrjfuture start_timer1 wait_timeout remainingelapseds r+r5r5 sa/.....::::::  |4??,,|   / / $  ! ! # # #:;;; ( 9 9 N??   D $D ) )D % % d+F ~LMMM!!JttJ,@H >   > MMOOO"#<== =   4>#3#33IA~~ .**Z7"C?CC,1'NNBCCC|Y77L ===66 6!.    H s(,,F//GGc2tjddidS)z=Standardized JSON error for a user-interrupted MCP tool call.r\z-MCP call interrupted: user sent a new messageFr)rrrRrSr+_interrupted_call_resultr s) :@   rSc&ddlmt|tr fd}t||St|t rd|DSt|tr d|DS|S)u9Recursively resolve ``${VAR}`` placeholders. Both ``${VAR}`` and Cursor-style ``${env:VAR}`` are accepted — the ``env:`` prefix is stripped so a doc copied from a Cursor / Claude MCP config resolves the same secret. Resolves from the active profile's secret scope when multiplexing is on (so an MCP server config's ``${API_KEY}`` picks up the routed profile's value, not the process-global ``os.environ`` which may hold another profile's), falling back to ``os.environ`` otherwise. Unset vars keep the literal placeholder, as before. r) get_secretct|d}||dp|dS)Nrr)rr1)mr{ _get_secrets r+_replacez'_interpolate_env_vars.._replace sE ,,D;tQWWQZZ00>AGGAJJ >rSc4i|]\}}|t|SrR_interpolate_env_varsrkvs r+ z)_interpolate_env_vars.. s'FFF1(++FFFrSc,g|]}t|SrRr)rrs r+rz)_interpolate_env_vars.. s!888Q%a((888rS) agent.secret_scoperr r_ENV_VAR_PATTERNrrrr )rrrs @r+rr s=<<<<<%5 ? ? ? ? ? ##He444%GFF FFFF%988%8888 LrSserversc6 ddlm}n#t$rd}YnwxYw||Si}|D]c\}}t |t s|||< |||}|r0t d|d|^|||<d|S)zADrop exfiltration-shaped MCP configs before any stdio spawn path.r)validate_mcp_server_entryNz'Skipping suspicious MCP server '%s': %sr) hermes_cli.mcp_securityrr rr rr!r[r)r_validate_mcp_server_entry safe_serversr{cfgissuess r+_filter_suspicious_mcp_serversr s]ccccccc ]]]X\"""]")L]]__ ! ! c#t$$ !$L  ++D#66   NN9 &!!     T s  c ddlm}ddlm}|driS|}|d}|rt |t siS ddlm}|n#t$rYnwxYwi}t| D].\}}t|}t |t r|||</|S#t$r'} td| icYd} ~ Sd} ~ wwxYw) aRead ``mcp_servers`` from the Hermes config file. Returns a dict of ``{server_name: server_config}`` or empty dict. Server config can contain either ``command``/``args``/``env`` for stdio transport or ``url``/``headers`` for HTTP transport, plus optional ``timeout``, ``connect_timeout``, and ``auth`` overrides. ``${ENV_VAR}`` placeholders in string values are resolved from ``os.environ`` (which includes ``~/.hermes/.env`` loaded at startup). r) load_config)env_var_enabledHERMES_SAFE_MODE mcp_servers)load_hermes_dotenvzFailed to load MCP config: %sN)hermes_cli.configrutilsrrr rhermes_cli.env_loaderrr rrrr!r") r _env_enabledrrrrr{r interpolatedr*s r+_load_mcp_configr sg111111 :99999 <* + + I**]++ j$77 I  @ @ @ @ @ @       D (* 7@@FFHH 2 2ID#055L,-- 2%1 T"  4c::: sGC 7C A%$C % A2/C 1A22AC C:C5/C:5C:r{c^Kt|}||d{V|S)aCreate an MCPServerTask, start it, and return when ready. The server Task keeps the connection alive in the background. Call ``server.shutdown()`` (on the same event loop) to tear it down. Raises: ValueError: if required config keys are missing. ImportError: if HTTP transport is needed but not available. Exception: on connection or initialization failure. N)rr)r{rrs r+_connect_serverr8 s>4 F ,,v   MrSrc8dtdtffd }|S)zReturn a sync handler that calls an MCP tool via the background loop. The handler conforms to the registry's dispatch interface: ``handler(args_dict, **kwargs) -> str`` rr c  t dtkrt d}t j|z }|t krRtdtt |z }tj dd dt d|did St5t  dddn #1swxYwY s+t tj dd d id S jsVt t rtj dd d id Stj dd d id S fd  fd} |} tj|}d|vrt nt# n+#tjt&f$rt# YnwxYw|S#t($rt+cYSt,$r}t/ ||d } | | cYd}~St1 ||d } | | cYd}~St t2d |tj dt7dt9|jdt=|id cYd}~Sd}~wwxYw)Nrgrr\rz' is unreachable after z0 consecutive failures. Auto-retry available in ~ues. Do NOT retry this tool yet — use alternative approaches or ask the user to check the MCP server.Fr' is not connectedut' transport is down; reconnect requested. Do NOT retry this tool immediately — give it a few seconds to come back.cpKj4d{Vtj_ j d{V}d_n #d_wxYw dddd{Vn#1d{VswxYwY|jrOd}|jpgD]}t|dr ||j z }tj dt|pdidSg}|jpgD]Z}t|dr"|j r| |j 4t|}|r| |[|rd|nd}t!|d d}|3|rtj ||d dStj d |idStj d |idS) Nrrrr\zMCP tool returned an errorFrrstructuredContent)rOrrO)r+ contextvars copy_contextr r call_toolisErrorrr|rrrrrrrr) rO error_textrr image_tag text_result structuredrrrs r+_callz3_make_tool_handler.._handler.._call s' 8 8 8 8 8 8 8 8 0;/G/I/I,8#)>#;#;IQU#;#V#VVVVVVVF37F004F077777 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8~ ' $n211Euf--1"ej0 z_"B&B#!& ''''" "E ..B , ,5&))ejLL,,,2599 ,LL+++.3;$))E***K !)A>c&tSNrr5rrsr+ _call_oncez8_make_tool_handler.._handler.._call_once #E<@@@ @rSz tools/call zMCP tool %s/%s call failed: %sMCP call failed: r)r rrr rwr_CIRCUIT_BREAKER_COOLDOWN_SECrJrfrrrrrrrrrrrPr@rr r:rDr!r\rrrr)rr opened_atagerrrOrr*r7rrr-rrs` @@r+rUz$_make_tool_handler.._handlerS sg # #K 3 37Q Q Q155k3GGI.""Y.C2223'Ds'J#K#KLL zO{OO/ <OO>GOOO#!&'''' / /\\+..F / / / / / / / / / / / / / / / # { + + +:G GGG!### #~ # { + + + (( 'zO{OOO# !& '''':G GGG!### #8 K8 K8 K8 K8 K8 K8 Kt A A A A A A, #Z\\F 1F++f$$&{3333' 444()4 1 1 1#K00000 1M . . .+-- - - - # # #5S*)i))I$       :S*)i))I$       { + + + LL0Y   :MS (:MMhsmmMM" ### # # # # # #5 #ss>C%%C),C) G87G G8 %G30G82G33G88K KK3K9KKA5K KKrr)r-rrrUs``` r+_make_tool_handlerrL sMc#tc##c#c#c#c#c#c#c#c#J OrSc4dtdtffd }|S)z>Return a sync handler that lists resources from an MCP server.rr c t5tdddn #1swxYwYrjst jdddidSfdfd} |S#t $rtcYSt$r}t||d}||cYd}~St||d}||cYd}~St d |t jdtd t|jd t!|idcYd}~Sd}~wwxYw) Nr\rrFrcHKj4d{Vjd{V}dddd{Vn#1d{VswxYwYg}t|dr|jngD]}i}t|drt |j|d<t|dr |j|d<t|dr|jr |j|d<t|dr|j r |j |d<| |tj d|idS)N resourcesurir{rrFr) r+rlist_resourcesr|rrrr{rrrrr)rOrrentryrs r+rz=_make_list_resources_handler.._handler.._calls' ? ? ? ? ? ? ? ?%~<<>>>>>>>> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?I*1&+*F*FNf&&B ( (1e$$.#&qu::E%L1f%%+$%FE&M1m,,99+,=E-(1j))3aj3() E*%  '''':{I6UKKK K A A A c&tSrrrsr+rzB_make_list_resources_handler.._handler.._call_oncerrSzresources/listz MCP %s/list_resources failed: %srrrrrrrrr@rr r:rDr!r\rrrr rrrr*r7rrr-rs @@r+rUz._make_list_resources_handler.._handler sB  / /\\+..F / / / / / / / / / / / / / / / #V^ #:G GGG!### # L L L L L" A A A A A A #:<<  . . .+-- - - - # # #4S*.>I$       9S*.>I$       LL2K   :MS (:MMhsmmMM" ### # # # # # # #I266. A88E ED<0E6D< EA%D<6E<Err-rrUs`` r+_make_list_resources_handlerr s=2#t2##2#2#2#2#2#2#2#h OrSc4dtdtffd }|S)zFReturn a sync handler that reads a resource by URI from an MCP server.rr c ddlm}t5t dddn #1swxYwYrjst jdd didS|ds |d Sfd  fd } |S#t$rtcYSt$r}t ||d }||cYd}~St ||d }||cYd}~Std |t jdtdt!|jdt%|idcYd}~Sd}~wwxYw)Nr tool_errorr\rrFrrz Missing required parameter 'uri'cKj4d{Vjd{V}dddd{Vn#1d{VswxYwYg}t|dr|jng}|D]h}t|dr||j-t|dr+|dt|jditj d|rd |ndid S) Ncontentsrblobz[binary data, z bytes]rOrrFr) r+r read_resourcer|rrrrrrrr)rOrrrrrs r+rz<_make_read_resource_handler.._handler.._callFs' A A A A A A A A%~;;C@@@@@@@@ A A A A A A A A A A A A A A A A A A A A A A A A A A A "E*1&**E*EMv2H! L L5&))LLL,,,,UF++LLL!J#ej//!J!J!JKKK:xU)J5)9)9)9KZ_``` `s!A AAc&tSrrrsr+rzA_make_read_resource_handler.._handler.._call_onceSrrSzresources/readzMCP %s/read_resource failed: %srrr]rrrrrrrr@rr r:rDr!r\rrrr) rrrrr*r7rrrr-rs @@@r+rUz-_make_read_resource_handler.._handler8s------  / /\\+..F / / / / / / / / / / / / / / / #V^ #:G GGG!### #hhuoo B:@AA A a a a a a a A A A A A A #:<<  . . .+-- - - - # # #4S*.>I$       9S*.>I$       LL1;   :MS (:MMhsmmMM" ### # # # # # # #sJ9== B""E+< E+E&E+ E&5E+;A%E& E+&E+rrs`` r+_make_read_resource_handlerr5s=4#t4##4#4#4#4#4#4#4#l OrSc4dtdtffd }|S)z._handler.._call..s***  #AFAHMAZAZt_`_lt q}==rt._handler.._call|s' = = = = = = = =%~::<<<<<<<< = = = = = = = = = = = = = = = = = = = = = = = = = = =G(/ (B(BJfnn & &1f%%+$%FE&M1m,,99+,=E-(1k**q{** "# ***E+&u%%%%:y'2GGG Grc&tSrrrsr+rz@_make_list_prompts_handler.._handler.._call_oncerrSz prompts/listzMCP %s/list_prompts failed: %srrrrs @@r+rUz,_make_list_prompts_handler.._handlerts@  / /\\+..F / / / / / / / / / / / / / / / #V^ #:G GGG!### # H H H H H, A A A A A A #:<<  . . .+-- - - - # # #4S*nI$       9S*nI$       LL0+s   :MS (:MMhsmmMM" ### # # # # # # #rrrs`` r+_make_list_prompts_handlerrqs=7#t7##7#7#7#7#7#7#7#r OrSc4dtdtffd }|S)zDReturn a sync handler that gets a prompt by name from an MCP server.rr c   ddlm}t5t  dddn #1swxYwY r jst jdd didS|ds |d S|d i fd  fd } |S#t$rtcYSt$r}t ||d }||cYd}~St ||d }||cYd}~Std |t jdtdt!|jdt%|idcYd}~Sd}~wwxYw)Nrrr\rrFrr{z!Missing required parameter 'name'rcKj4d{Vjd{V}dddd{Vn#1d{VswxYwYg}t|dr|jngD]}i}t|dr |j|d<t|drO|j}t|dr |j|d<n-t|tr||d<nt||d<| |d|i}t|dr|j r |j |d<tj |dS) Nrr>rrrrFr)r+r get_promptr|r>rrrr rrrrr) rOr>rrrrrr{rs r+rz9_make_get_prompt_handler.._handler.._calls!' T T T T T T T T%~888SSSSSSSS T T T T T T T T T T T T T T T T T T T T T T T T T T TH+26:+F+FNB ' '3''-$'HE&M3 **8!kGw//8+2<i((#GS118+2i((+.w<<i(&&&&)Dv}-- 9&2D 9&,&8]#:d777 7s#A AAc&tSrrrsr+rz>_make_get_prompt_handler.._handler.._call_oncerrSz prompts/getzMCP %s/get_prompt failed: %srrr) rrrrr*r7rrr{rr-rs @@@@r+rUz*_make_get_prompt_handler.._handlers------  / /\\+..F / / / / / / / / / / / / / / / #V^ #:G GGG!### #xx C:ABB BHH["--  8 8 8 8 8 8 8. A A A A A A #:<<  . . .+-- - - - # # #4S*mI$       9S*mI$       LL. S   :MS (:MMhsmmMM" ### # # # # # # #sJ:>>0 B::F FE>2F8E> FA%E>8F>Frrs`` r+_make_get_prompt_handlerrs=?#t?##?#?#?#?#?#?#?#B OrSc"dtffd }|S)zBReturn a check function that verifies the MCP connection is alive.r ct5t}dddn #1swxYwY|duo|jduSr)rrrr)rr-s r+_checkz_make_check_fn.._checks  / /\\+..F / / / / / / / / / / / / / / /T!@fnD&@@s 044)r)r-rs` r+_make_check_fnrs6ADAAAAAA MrSc|sdidSfdd}fd|}||}|}t|tsdidS|ddkr d|vri|dii}|S)adNormalize MCP input schemas for LLM tool-calling compatibility. MCP servers can emit plain JSON Schema with ``definitions`` / ``#/definitions/...`` references. Kimi / Moonshot rejects that form and requires local refs to point into ``#/$defs/...`` instead. Normalize the common draft-07 shape here so MCP tool schemas remain portable across OpenAI-compatible providers. Additional MCP-server robustness repairs applied recursively: * Missing or ``null`` ``type`` on an object-shaped node is coerced to ``"object"`` (some servers omit it). See PR #4897. * When an ``object`` node lacks ``properties``, an empty ``properties`` dict is added so ``required`` entries don't dangle. * ``required`` arrays are pruned to only names that exist in ``properties``; otherwise Google AI Studio / Gemini 400s with ``property is not defined``. See PR #4651. * MCP/Pydantic optional fields commonly arrive as ``anyOf: [{...}, {"type": "null"}], default: null``. Anthropic rejects nullable branches in tool input schemas, so nullable unions are collapsed to the non-null branch and optionality remains represented solely by the parent object's ``required`` list. All repairs are provider-agnostic and ideally produce a schema valid on OpenAI, Anthropic, Gemini, and Moonshot in one pass. objectrrct|tri}|D]Z\}}|dvr9t|tr$fd|D||<B|dkrdn|}|||<[|d}t|tr2|drd|t ddz|d<|St|trfd |DS|S) aWalk the schema, promoting legacy ``definitions`` to ``$defs``. The promotion is contextual: ``definitions`` is renamed only when it appears as a JSON Schema *meta-keyword* (sibling of ``properties`` / ``$ref`` at a schema node), never when it appears as the *name of a property* (i.e., as a key inside a ``properties`` dict). Without this gate, MCP servers that legitimately expose a tool parameter named ``definitions`` (e.g. a CI/pipelines tool that uses ``definitions`` for an array of pipeline-definition IDs) would have that user-facing property name silently rewritten to ``$defs``. Anthropic and OpenAI both reject ``$`` in property names (``^[a-zA-Z0-9_.-]{1,64}$``), so the whole tool array gets a 400 and every conversation breaks. The gate works by treating ``properties`` and ``patternProperties`` specially during descent: we iterate the property-name -> schema map directly, leaving the property names verbatim, then recurse into each property's schema where ordinary JSON Schema semantics resume (so any legitimately-nested ``definitions`` meta-keyword inside a property's schema is still promoted). )rpatternPropertiesc.i|]\}}||SrRrR)r prop_name prop_schema_rewrite_local_refss r+rzL_normalize_mcp_input_schema.._rewrite_local_refs..Cs;'''2I{"#6#6{#C#C'''rS definitionsz$defsz$refz#/definitions/z#/$defs/Nc&g|] }|SrRrR)rrDrs r+rzL_normalize_mcp_input_schema.._rewrite_local_refs..Os%???$''--???rS)r rrrrrrr )rrrrout_keyrrs r+rz8_normalize_mcp_input_schema.._rewrite_local_refs$sL. dD ! ! J"jjll E E U===*UTXBYBY= ''''6;kkmm'''JsOO *- )=)=gg3G*=*=e*D*DJw''..((C#s## N7G(H(H N%/#c:J6K6K6L6L2M%M 6"  dD ! ! @????$??? ? rSc(ddlm}||dS)aCollapse JSON Schema nullable unions to provider-safe non-null schemas. Delegates to ``tools.schema_sanitizer.strip_nullable_unions`` so MCP ingestion, the Anthropic guard, and the global sanitizer all share one implementation. Keeps the ``nullable: true`` hint so runtime argument coercion can still map a model-emitted ``"null"`` string to Python ``None`` for this optional field. r)strip_nullable_unionsT)keep_nullable_hint)tools.schema_sanitizerr)rrs r+_strip_nullable_unionz:_normalize_mcp_input_schema.._strip_nullable_unionRs- A@@@@@$$TdCCCCrSc"t|trfd|DSt|ts|Sfd|D}|ds d|vsd|vrd|d<|ddkrd|vs(t|dts>d|vrin|d|d<t|dtsi|d<|d}t|trc|dpifd|D}t |t |kr|r||d<n|dd|S) zBRecursively repair object-shaped nodes: fill type, prune required.c&g|] }|SrRrR)rrD_repair_object_shapes r+rzM_normalize_mcp_input_schema.._repair_object_shape..bs%@@@4((..@@@rSc.i|]\}}||SrRrR)rrrr s r+rzM_normalize_mcp_input_schema.._repair_object_shape..fs+HHH41aA++A..HHHrSrrrrcFg|]}t|t|v|SrR)r r)rrrs r+rzM_normalize_mcp_input_schema.._repair_object_shape..|s-RRRq 1c0B0BRqEzzzzzrSN)r r rrrrr)rrepairedrvalidrr s @r+r z9_normalize_mcp_input_schema.._repair_object_shape_s dD ! ! A@@@@4@@@ @$%% KHHHH4::<<HHH||F## ( H $ $ h(>(>'HV  <<  8 + +8++: \**D44+0<8/K/KQYZfQg&!(,,|"<"__``. )rMCP_TOOL_NAME_PREFIX_MCP_NAME_DELIM)r-r safe_server safe_tools r+r[r[s9 .k::K+I66I" MK M M) M MMrSc t||j}||jp d|jd|tt |dddS)aSConvert an MCP tool listing to the Hermes registry schema format. Args: server_name: The logical server name for prefixing. mcp_tool: An MCP ``Tool`` object with ``.name``, ``.description``, and ``.inputSchema``. Returns: A dict suitable for ``registry.register(schema=...)``. z MCP tool z from rNr)r[r{rrr)r-mcp_tool prefixed_names r+_convert_mcp_schemars^+; FFM+]/]8=/]/]P[/]/]1'(MSW2X2XYY  rSc t|dd|ddiddddt|dd |ddd d d d id gddddt|dd|ddiddddt|dd|ddd dd ddiddddgddddgS)zBuild schemas for the MCP utility tools (resources & prompts). Returns a list of (schema, handler_factory_name) tuples encoded as dicts with keys: schema, handler_key. rz*List available resources from MCP server 'r@rrr)r handler_keyrz(Read a resource by URI from MCP server 'rstringzURI of the resource to read)rr)rrrrz(List available prompts from MCP server 'rz&Get a prompt by name from MCP server 'zName of the prompt to retrievez(Optional arguments to pass to the promptT)rrradditionalPropertiesrr{)r[rs r+_build_utility_schemasr"sz/{.s,,,dD ,,,rSz>MCP config %s must be a string or list of strings; ignoring %r)r3r rr r!r!r[)rrs r+_normalize_name_filterr% sx }uu %w%$s+,,-,,e,,,, NNSUZ\abbb 55LrSrLc||St|tr|St|tr2|}|dvrdS|dvrdSt d|||S)z2Parse a bool-like config value with safe fallback.N>1onyestrueT>0noofffalseFzAMCP config expected a boolean-ish value, got %r; using default=%s)r rrrrr!r[)rrLlowereds r+_parse_boolishr0s }% %++--%%'' 0 0 04 1 1 15 NNVX]_fggg NrSrrrrrrrrrrcxt|}t5|t|<ddddS#1swxYwYdS)z:Remember the exact MCP server that registered *tool_name*.N)rrrF)rr-safe_server_names r+_track_mcp_tool_serverr4Bs2;?? ==,<y)==================s /33c|t5t|dddddS#1swxYwYdS)z5Forget MCP server provenance for a deregistered tool.N)rrFr)rs r+r`r`Is 44""9d333444444444444444444s 155c|dpi}t|dd}t|dd}d}t|dd}|t|dd}g}t|D]} | d } | d vr|std || -| d vr|std || P|=t | } t|| dtd|| | n@t| } t|j | std|| | | | |S)z?Select utility schemas based on config and server capabilities.rrTrLrNr-r7r>rrz;MCP server '%s': skipping utility '%s' (resources disabled)>rrz9MCP server '%s': skipping utility '%s' (prompts disabled)zRMCP server '%s': skipping utility '%s' (server does not advertise '%s' capability)z9MCP server '%s': skipping utility '%s' (session lacks %s)) rr0rr"r!r"_UTILITY_CAPABILITY_ATTRS_UTILITY_CAPABILITY_METHODSr|rr) r-rr tools_filterresources_enabledprompts_enabledadvertised_capsr8selectedrrcap_attrrequired_methods r+_select_utility_schemasrAOs::g&&,"L&|'7'7 'D'DdSSS$\%5%5i%@%@$OOOOO&"5t<?;;  O#   OrScg}tD]j\}}t|dr||j0|jD]2}t |j|}||d3k|S)z6Return tool names for all currently connected servers.r(r{) rrr|r;r(r$rr{r)names_snamerrrs r+_existing_tool_namesrEsE"..**)) 63 4 4  LL6 7 7 7   ) )H(h??F LL ( ( ( ( ) LrSc ddlm}g}d|}|dpi}t|dd|dt|dd|d d td t ffd }|jD]'}||js"t d ||j5t||j|j pdt||} | d} | | } | r9| ds$td||j| | || || t#||j|jt'|d| dt)| ||| )t,t.t0t2d} t'|} t5|||D]}|d} |d}| |||j}| d}| |} | r3| dstd||| {|||| || d| dt)|||||r||||S)aRegister tools from an already-connected server into the registry. Handles include/exclude filtering and utility tools. Toolset resolution for ``mcp-{server}`` and raw server-name aliases is derived from the live registry, rather than mutating ``toolsets.TOOLSETS`` at runtime. Used by both initial discovery and dynamic refresh (list_changed). Returns: List of registered prefixed tool names. rrXzmcp-rincludez mcp_servers.z.tools.includeexcludez.tools.excluderr c r|vSr|vSdS)NTrR)r exclude_set include_sets r+_should_registerz0_register_server_tools.._should_registers.  , + +  0K/ /trSz8MCP server '%s': skipping tool '%s' (filtered by config)rr{usMCP server '%s': tool '%s' (→ '%s') collides with built-in tool in toolset '%s' — skipping to preserve built-inFr)r{toolsetrhandlercheck_fnis_asyncrr1rrupMCP server '%s': utility tool '%s' collides with built-in tool in toolset '%s' — skipping to preserve built-in)r]rYrr%rrr$r{r!r"rrrget_toolset_for_toolrr[registerrrrr4rrrrrrAregister_toolset_alias)r{rrrYregistered_names toolset_namer:rLrrtool_name_prefixedexisting_toolset_handler_factoriesrOrrrN util_namerJrKs @@r+raras~('''''"$ $==L::g&&,"L()9)9))D)DFiUYFiFiFijjK()9)9))D)DFiUYFiFiFijjKCDM44 ..  LLSUY[c[h i i i  dHM83G3M2NNN$T844#F^$889KLL  $4$?$?$G$G  NNIhm%79I    # &tX]F>++xM* 1$[1$8KLL6N $88CC  $4$?$?$G$G  NNIi!1     }-     y$/// ****<''l;;; rSc &K|dt}tjt |||d{V}t 5t |t |d|t|<dddn #1swxYwYt|||}t||_ d|vrdnd}td||t!|d||S) zsConnect to a single MCP server, discover tools, and register them. Returns list of registered tool names. rrNrHTTPstdioz/MCP server '%s' (%s): registered %d tool(s): %sr)rrrrrrr rDr rrrar r(r!rYrr)r{rrrrTtransport_types r+_discover_and_register_serverr^si jj!24LMMO#f%%F   ""4(((""4...               .dFFCC$()9$:$:F!$VVGN KK9 nc"233 "## sABB"BcF tstdgSt|}|stdgSt5d|D t   D]}t |d|D]y\}}t| dddr(t t|Rtt|z dddn #1swxYwY st!St#dt$d t&d t(t$fd  fd }d dlm}m}|}|r |d t1|d|r |dn#|r |dwwxYwt5d D}t3d|D}dddn #1swxYwYt5 t5|z } |s| r;d|dt5|d} | r | d| dz } t| t!S)a[Connect to explicit MCP servers and register their tools. Idempotent for already-connected server names. Servers with ``enabled: false`` are skipped without disconnecting existing sessions. Args: servers: Mapping of ``{server_name: server_config}``. Returns: List of all currently registered MCP tool names. z;MCP SDK not available -- skipping explicit MCP registrationz No explicit MCP servers providedcvi|]6\}}|tvt|ddd3||7SrTr7rr0rrs r+rz(register_mcp_servers..:sT   1  ^AEE)T4J4JTX%Y%Y%Y  q   rSNsupports_parallel_tool_callsFr7r{rr c2Kt||d{VS)z@Connect to a single server and return its registered tool names.N)r^)r{rs r+ _discover_onez+register_mcp_servers.._discover_oneOs(24=========rScKt}tjfdDddid{V}t ||D]\}}t |tr|id}t|}t5t ||t|<dddn #1swxYwYtd||rd|dnd|t5t |t|ddddn #1swxYwYdS) Nc36K|]\}}||VdSrrR)rr{rres r+rz>register_mcp_servers.._discover_all..Ws3 L L94mmD#&& L L L L L LrSrTrz*Failed to connect to MCP server '%s'%s: %sz (command=r r)r keysrrrzipr r2rrErr rDr r!r[r) server_namesresultsr{rOrrBre new_serverss r+ _discover_allz+register_mcp_servers.._discover_allSs$K,,..//  L L L L 8I8I8K8K L L L "         g66 ; ;LD&&-00 ;%//$3377 BB/77;;&..t4443:*40;;;;;;;;;;;;;;;@/6>+++++B ;;&..t444*..tT:::;;;;;;;;;;;;;;; ; ;s$%C55C9 <C9 -6E//E3 6E3 r)ru set_interruptxrTc$g|] }|tv |SrRrrrs r+rz(register_mcp_servers..~s===1qH}}Q}}}rSc3hK|]-}ttt|dgV.dSr(Nrrrrrs r+rz'register_mcp_servers..sO    %=rBB C C      rSzMCP: registered  tool(s) from server(s)r  failed))rLr!r"rrrr rr rr0rrErBrrDrErirrrrzrurnr5sumrrY) rsrv_namesrv_cfgrm_is_interrupted_set_interrupt_was_interrupted connectednew_tool_countfailedsummaryrerls @@r+register_mcp_serversr"s  RSSS ,W55G  7888  VV      !!+...# 7 7H " & &x 6 6 6 6!( V V Hggkk*H%PPZ_``` V&**+Fx+P+PQQQQ&../J8/T/TUUUU  VVVVVVVVVVVVVVVV &#%%%>#>D>T#Y>>>>;;;;;;>cbbbbbbb&((u!4444  ! N4   ! N4  !   == ===                         I .F]^]]3y>>]]]  - ,F,,, ,G G  ! !!s1C'EEEG G0:&H,,H03H0ctstdgSt}|stdgSt5d|D}dddn #1swxYwYt |}|s|St5d|D}td|D}dddn #1swxYwYt|t|z }|s|r;d|dt|d }|r |d |d z }t ||S) aEntry point: load config, connect to MCP servers, register tools. Called from ``model_tools`` after ``discover_builtin_tools()``. Safe to call even when the ``mcp`` package is not installed (returns empty list). Idempotent for already-connected servers. If some servers failed on a previous call, only the missing ones are retried. Returns: List of all registered MCP tool names. z4MCP SDK not available -- skipping MCP tool discoveryzNo MCP servers configuredctg|]5\}}|tvt|ddd3|6Srarb)rr{rs r+rz&discover_mcp_tools..sR   c8##swwy$7O7OY](^(^(^# ###rSNc$g|] }|tv |SrRrqrr{s r+rz&discover_mcp_tools..s"!X!X!X4txGWGW$GWGWGWrSc3hK|]-}ttt|dgV.dSrtrurs r+rz%discover_mcp_tools..sO   (@"EE F F      rSz MCP: rvrwr rx) rLr!r"rrrrryrrY)rnew_server_names tool_namesconnected_server_namesr failed_countrs r+discover_mcp_toolsrs   KLLL   G  0111     $]]__                  &g..J    !X!X3C!X!X!X  .                    '((3/E+F+FFLaNaa#>T:U:Uaaa  3 2L222 2G G s$BB B'&CC Cc|tsdSt5t|}t |o|t vcdddS#1swxYwYdS)aCheck if an MCP tool belongs to a server that supports parallel tool calls. MCP tool names follow the pattern ``mcp__{server}__{tool}``, but that string shape is ambiguous when server names contain underscores. Use the exact server provenance captured at registration time rather than prefix matching, then check whether that server's config includes ``supports_parallel_tool_calls: true``. Returns False for non-MCP tools or tools from servers without the flag. FN)rrrrFrrrE)rr-s r+is_mcp_tool_parallel_safers    4 5 5u KK,00;; KIK3I$IJJKKKKKKKKKKKKKKKKKKs2A##A'*A'c g}t}|s|St5tt}t t }tt }dddn #1swxYwY|D]c\}}d|vr|ddnd}t|ddd}||} | r| j x||t| d rt| j nt| jdd d d } | jrt| jj| d <|| |s|||dd ddd ||vr|||dd d dd ||vr%|||dd d d||dG|||dd d dd e|S)a`Return status of all configured MCP servers for banner display. Returns a list of dicts with keys: name, transport, tools, connected, disabled, and status. Includes connected servers, disabled servers, in-flight connection attempts, recorded failures, and servers that are configured but have not been started in this process yet. Nrrr r\rTr7r(Fr)r{rrrdisabledstatusrrr connectingr)r{rrrrrr\ configured)rrrrr3r r rrr0rr|rr(r$r&ror) rOractive_serversrconnect_errorsr{rrrrrs r+get_mcp_statusrsF"##J  66h+,, 455666666666666666  %%''77 c49SLLCGGK000g  D!9!94HHH##D)) 3 fn0&?FvOg?h?hAV:;;;nqrxroAoA!!% E C$()9)A$B$Bj! MM% '  MM&" $     Z   MM&"!&     ^ # # MM&"!"'-     MM&"!&      Ms=A%%A),A)ctsiSt}|siSd|DsiStigfd} t |dn2#t $r%}t d|Yd}~nd}~wwxYwtn#twxYwS)uTemporarily connect to configured MCP servers and list their tools. Designed for ``hermes tools`` interactive configuration — connects to each enabled server, grabs tool names and descriptions, then disconnects. Does NOT register tools in the Hermes registry. Returns: Dict mapping server name to list of (tool_name, description) tuples. Servers that fail to connect are omitted from the result. cdi|]-\}}t|ddd*||.Sra)r0rrs r+rz*probe_mcp_server_tools..2sOA !%% 400$ ? ? ? 1rSc Kt }g} D]W\}}|dt}|t jt|||Xt j |ddid{V}t||D]\}}t|trtd||7 |g}|jD]1}t!|ddpd} ||j| f2| |<t j d Dddid{VdS) NrrrTz$Probe: failed to connect to '%s': %srrc3>K|]}|VdSrrr)rss r+rz=probe_mcp_server_tools.._probe_all..Ts* 3 3qajjll 3 3 3 3 3 3rS)r rhrrrrrrrrrir r r!r"r$rr{) rCcorosr{rctoutcomesoutcomerrudescrprobed_serversrOs r+ _probe_allz*probe_mcp_server_tools.._probe_all>sW\\^^$$  S SID#*,DEEB LL)/$*D*DbQQQ R R R R G$GGGGGGGG 11 ! !MD''9--  CT7SSS  ! !' * * *E^ - -q-44: afd^,,,, F4LLn 3 3N 3 3 3 "           rSrorzMCP probe failed: %sN) rLrrrir5r r!r"_stop_mcp_loop_if_idle)servers_configrr*rrrOs @@@r+probe_mcp_server_toolsr s%  %''N  '--//G  %'F*,N       4!S11111 222 +S111111112         Ms0A-,B.- B7BB.BB..B>clt5ttcdddS#1swxYwYdS)uTrue if any MCP server has actually registered tools into the registry. Cheap — checks the global MCP-tool→server name map under ``_lock``, no registry walk. Used by the per-turn refresh hook so a session with no MCP tools (the common case, and also a connected-but-zero-tool/prompt-only server) skips the ``get_tool_definitions`` rebuild entirely. Checks registered TOOLS, not connected servers, so a server that registers no tools doesn't keep the hook firing every turn. N)rrrFrRrSr+has_registered_mcp_toolsrjsz ,,*++,,,,,,,,,,,,,,,,,,s )--)enabled_overridedisabled_override quiet_modercddlm}ddlm}||9||nt |dd}||nt |dd}||_||_n"t |dd}t |dd}|j}t||||pg} d| D} t|| | } t5t |d d } t| tr| nd } || krtcdddSd t |d dpgD}| |kr/t| ||_tcdddS| |_| |_t |d d}t|tr)||| t| ||_| |z cdddS#1swxYwYdS)u Re-derive an already-built agent's tool snapshot from the live registry. The agent snapshots ``agent.tools`` once at build time and never re-reads the registry (see ``run_agent`` / ``agent_init``). When MCP servers connect *after* that snapshot — a slow HTTP/OAuth server that misses the bounded startup wait, or a ``/reload-mcp`` — their tools are invisible until the snapshot is rebuilt. This is the single shared rebuild used by every such caller (the TUI ``reload.mcp`` RPC, the gateway reload, the late-binding refresh thread, and the per-turn between-turns refresh) so they can't drift apart again. The rebuild respects the agent's own ``enabled_toolsets`` / ``disabled_toolsets`` (the same filtering it was built with) and diffs by tool **name** (not count — a count compare misses an equal-size add/remove swap). Crucially it is **additive-preserving**: ``get_tool_definitions`` returns only the registry-derived tools, but ``agent_init`` appends two further families directly onto ``agent.tools`` *after* that — external memory-provider tools (mem0/honcho/…) and context-engine tools (``lcm_*``). A naive ``agent.tools = get_tool_definitions(...)`` would silently DELETE those. So after rebuilding the registry set we re-run the same post-build injectors ``agent_init`` used, reconstructing the full surface. The new ``(tools, valid_tool_names)`` pair is published together under ``_agent_tools_lock`` so a concurrent reader never sees a cross-attribute half-swap. Returns the set of newly-added tool names (empty when nothing changed), so callers can decide whether to notify the user / re-emit session info. The caller owns the prompt-cache contract: this helper does NOT check turn state, because each caller has a different policy (``/reload-mcp`` rebuilds after explicit user consent; the late-binding and between-turns paths only rebuild at a turn boundary, before that turn's ``tools=`` prefix is assembled). r)get_tool_definitionsrXNenabled_toolsetsdisabled_toolsets)rrrc*h|]}|ddSrr{rRrs r+r\z*refresh_agent_mcp_tools..s!9991:v&999rS_tool_snapshot_generationrc*h|]}|ddSrrRrs r+r\z*refresh_agent_mcp_tools..s1    jM& !   rSr_context_engine_tool_names) model_toolsrr]rYrrr _generationr _reinject_post_build_tools_agent_tools_lockr rfr3rJrrvalid_tool_namesrzr)agentrrrrrYrrsnapshot_generationnew_defs new_namesstaged_engine_namespublished_gen_raw published_genr) engine_namess r+refresh_agent_mcp_toolsrxsR100000'''''' #'8'D&6&B""PUWikoHpHp(9(E$$7SXZmosKtKt!("*%!3T::5"5t<<#. $&!      H:9999I5UHiPP ## $E+FKK-78I3-O-OW))UW  . .55########  eWd339r      /2-AT.U.UE +55%########& !*u&BDII lC ( ( 5       3 4 4 4*-m=P*Q*Q'7"7##################s 4>G?AGA6GGG tools_listname_setcjdtdtffd } t|dd}|rt|ddnd}t|rQddlm}d vs|t|d dr-|D]"}t |tr ||#n,#t$rt d d YnwxYwt} t|d d} | dupd| v} t|dd} | rt| ddnd} | rjt| r[| D]P}t |ts| dd} ||r| r| | Qn,#t$rt dd YnwxYw|S)uAppend memory-provider and context-engine tools onto staged locals. Mirrors the post-``get_tool_definitions`` injection in ``agent_init`` so a snapshot rebuild reconstructs the FULL tool surface, not just the registry-derived subset. Operates ONLY on the caller's staged ``tools_list`` / ``name_set`` (never the live agent attributes) so the rebuild stays atomic. Idempotent (skips names already present) and fail-soft. Returns the set of context-engine routing names actually appended by THIS rebuild — matching ``agent_init``'s dedup behavior (a name already provided by a registry/plugin tool is NOT claimed for context-engine routing). The caller publishes this into ``agent._context_engine_tool_names`` atomically with the snapshot. rr c|dd}|r|vrdSd|d|dS)Nr{rFrrT)rrrB)rr{rrs r+_addz(_reinject_post_build_tools.._adds`zz&"%% tx''5:6BBCCC TtrS_memory_managerNget_all_tool_schemasr)memory_provider_tools_enabledmemoryrz)Memory-provider tool re-injection skippedTrcontext_enginecontext_compressorget_tool_schemasr{rz(Context-engine tool re-injection skipped) rrrr~agent.memory_managerrr r r!r"r3rrB)rrrrmemory_managerget_mem_schemasrrrrcontext_engine_allowed compressor get_schemasr{s `` r+rrsYTd Q (94@@Sak'.2H$OOOgk O $ $ % J J J J J J8##'D'DWUTfhlEmEm'n'n#-o//%%F!&$//%V QQQ @4 PPPPPQ #uuP%!3T::!(D!O4D4OU$8$?? GQ[gj*K|]}|VdSrr)rrs r+rz:shutdown_mcp_servers.._shutdown..Ds, ? ?Ffoo ? ? ? ? ? ?rSrTz!Error closing MCP server '%s': %s) rrrir r r!r"r{rrrz)rkrrOservers_snapshots r+ _shutdownz'shutdown_mcp_servers.._shutdownBs ? ?.> ? ? ? "        ""2G<<  NFF&),,  7f   NN                     s8BB#&B#rrvz MCP shutdown: failed to schedulerxr/rzError during MCP shutdown: %s) rr rvalues_stop_mcp_looprrr{rwr!rOr2r")rrrwrr*rs @r+shutdown_mcp_serversr3s 33 1 122333333333333333        DOO-->>>>>>)) IKK:      C b ))))  C C C .s* _ _ _C3R^K^K^l3&7K^K^K^rSrsigr-r c|}ttdd}|x|v#|krtd||nQ |||dS#t t tf$r(}td||||Yd}~nd}~wwxYw tj ||dS#t t tf$rYdSwxYw)z=SIGTERM/SIGKILL via pgroup on POSIX, fall back to pid signal.rNuMCP server '%s' pgid %d matches gateway pgid; skipping killpg to avoid self-kill and using per-pid kill — any grandchildren in this group may not be reapedzHkillpg(%d, %d) failed for MCP server '%s': %s; falling back to kill(pid)) rrr#r!r[rrrr"kill)rrr-rrr*_my_pgidpgidss r+ _send_signalz1_kill_orphaned_mcp_children.._send_signals-yy~~Xt,,   2#(8(8D   F4%%%F*OWELLbc;  GC     "OW=    DD s* A%%B$<BB$(B??CCz,Sent SIGTERM to orphaned MCP process %d (%s)rSIGKILLrz6Force-killed MCP process %d (%s) after SIGTERM timeout)signalrrrzrrrrrr#getpgrprrrfrrSIGTERMr!r"rwrTrrrr[) r_signalrUopidrrr-_sigkillrrrs @@r+_kill_orphaned_mcp_childrenras.  ( (!& " "D!DJJ  """  KK[)) * * *      !` _4 _ _ _ ( (C   S$ ' ' ' ' ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( :<< G $!#!C!c!d!!!!!!!H!JJLLWW[ S'/;777 CS+VVVV JqMMMw 7?;;H+***** JJLL  [{3   S(K000 D       s$BB44B8;B8CC.-C.c"tdS)aStop the MCP loop only when no registered server still owns it. Probe paths create temporary MCPServerTask instances that are not placed in ``_servers``. They should clean up an otherwise-idle loop, but must not tear down the process-global loop when live agent tools are registered on it. Otherwise a dashboard/CLI probe can make later MCP tool calls fail with ``MCP event loop is not running``. T only_if_idle)rrRrSr+rrs t , , ,,rSrrct5|r6tstr(td ddddSt }t }dadadddn #1swxYwY|h||j|| d | n#t$rYnwxYwtddS)z3Stop the background event loop and join its thread.zKLeaving MCP event loop running; active servers are registered or connectingNFrbrT)r) rrr r!r"rrGrrVrr}r r)rrthreads r+rrsN   X );  LLf g g g    !!$),,,   KKK " " "  JJLLLL    D  $48888 4s),AAA#&A#B44 CC)rjrr r)r])T)F)rrrconcurrent.futuresrrMrrhrHr#r0rr%rfrwtypingrrrrrrr urllib.parser getLoggerrr!rr __annotations__r2rr,rr4rLrrrRrrr:rr5r6mcp.client.stdior7mcp.client.streamable_httpr8rr9r mcp.typesr"mcp.client.sser;r<r=r>r?r@rArBrCrDrErFrGrHrrTrXrrirjrkERRORrKr0rrrrrurt frozensetrrcompile IGNORECASErrrrrrr2rrrr rIrrrr!rrrrQrConnectionErrorrrr'rErfrPrRrrrrr3r r r r rGrrrrrrr&rr:r<rArDrErFrAbstractEventLooprGrgrrrrrrTrrarirsr5rrrrrrrrrrrrrrrr[rr"r%r0r9r8r4r`rArErar^rrrrrrrrr rrrrrrRrSr+rs)PPPd   77777777777777!!!!!!  8 $ $ $(%)HSM(((%y~'' "S " " " "F  #  $     &!&'>K88888888------N$DDDDDD" $$$#$EEEEEE  k5555555 kkk ijjjjjkZ------- ZZZ  XYYYYYZ N                  # NNN LMMMMMNT????????!% TTT RSSSSST `            #' ``` ^_____`KKK LLIJJJJJK     "@!?!A!A`8` LL^___      #B"A"C"C ] Ll ] ]   "#,)---##B!bj  M  "2:.// s s    "htn.7#7#7777 '- 'C ' ' ' ' 'GGGGGGG''' &'MdPRZAAuAAAAH#2DdOS$Y6$$sDy/$$$$V  T m    (lClClullll^7c77777t9S99999x<C<u<<<<~D#DUDDDDNIt IIIIIX;s;s;;;;$NNNNNNNSt&EET EEEEP # c c#h      #      "'$" $"  =c======4s4t4444 66m6T6VZ[_V`6666r d3i    kkmkTkdSVikkkk\c4DI>h"$sDy/h"d3ih"h"h"h"V.DI....bKKKKKK$MT MMMM`?S$u+%5 6????N#IN$$ ,$ , , , ," w#w#w#  w#  w#w#w#w#t>$>#>#>>>>B+++\i i i i i i i X - - - - -,1DTs #G4B=<G=CGCG CGCGCG"C)(G)DGDG DGD0-G/D00G4E G E&#G%E&&G* E54G5FGFGF%$G%G?GGGG#"G#KKK