߲j3cdUdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z mZddlmZddlmZej&eZiZded <iZd ed <iZd ed <dad ed<daded<dadae GddZiZded<e j@Z!e ddZ"ded<ee#jIjJjJdz dz Z&d3dZ'd4dZ(d5dZ)d6dZ*d7d Z+d8d!Z,d9d"Z-d:d#Z.d;d$Z/d;d%Z0dd(Z3d)d*d?d+Z4d3d,Z5d@d-Z6d3d.Z7d3d/Z8d0d1iZ9d2Z:y)Au6Provider module registry. Provider profiles can live in three places: 1. Bundled plugins: ``plugins/model-providers//`` (shipped with hermes-agent) 2. User plugins: ``$HERMES_HOME/plugins/model-providers//`` 3. Pip-installed plugins: distributions exposing a ``hermes_agent.plugins`` entry point (``module:func`` callable or a self-registering ``module``) Each plugin directory contains: - ``__init__.py`` — calls ``register_provider(profile)`` at import - ``plugin.yaml`` — manifest (name, kind: model-provider, version, description) Discovery is lazy: the first call to ``get_provider_profile()`` or ``list_providers()`` imports the bundled and pip-installed plugins once per process; the ``$HERMES_HOME`` plugins of the profile home bound at lookup time load into that home's own layer, so one process serving several profiles (multiplex gateway, Desktop ``serve``) resolves each profile's installs. User plugins override bundled plugins on name collision, so third parties can monkey-patch or replace any built-in profile without editing the repo. For backward compatibility, ``providers/*.py`` files (other than ``base.py`` and ``__init__.py``) are still discovered via ``pkgutil.iter_modules``. This lets out-of-tree users drop a single-file profile into an editable install without the plugin dir structure. New profiles should prefer the plugin layout. Usage:: from providers import get_provider_profile profile = get_provider_profile("nvidia") # ProviderProfile or None profile = get_provider_profile("kimi") # checks name + aliases ) annotationsN) ContextVar) dataclassfield)Path)ProviderProfiledict[str, ProviderProfile] _REGISTRYdict[str, str]_ALIASES_SOURCES str | None_current_sourcezlist[ProviderProfile] | None_PROVIDER_LIST_CACHEFcXeZdZUdZeeZded<eeZded<dZ ded <y ) _HomeLayeruThe ``$HERMES_HOME/plugins`` providers of ONE profile home. One process serves many profiles (multiplex gateway, Desktop ``serve``) and each profile installs its own plugins, so user plugins are keyed by the home bound at lookup time instead of the home that happened to be bound at first discovery — that made a plugin installed in a secondary profile ``Unknown provider`` in Desktop while the same profile worked in a terminal (#88143). ``stamps`` are the plugin dirs' mtimes: a directory added by ``hermes plugins install`` while the process runs changes them, and the next lookup imports it without a restart. )default_factoryr registryr aliasestuplestampsN) __name__ __module__ __qualname____doc__rdictr__annotations__rrr7/home/ubuntu/.hermes/hermes-agent/providers/__init__.pyrr@s2,1+FH(F#D9G^9FErrzdict[str, _HomeLayer] _HOME_LAYERS_provider_registration_target)defaultzContextVar[_HomeLayer | None]_REGISTRATION_TARGETpluginsmodel-providerscttjjddd}|y |y#t$r }t j d|Yd}~yd}~wwxYw)aMirror profiles into ``hermes_cli.auth.PROVIDER_REGISTRY`` if that module is loaded. ``hermes_cli.auth`` takes its own snapshot of ``list_providers()`` when it is imported. If a plugin's imports pull that module in while :func:`_discover_providers` is still running, the snapshot is partial and later plugins never reach the auth registry ("Unknown provider", #102123). Calling back into auth once discovery is complete closes that window. Looked up via ``sys.modules`` on purpose: this layer must never import ``hermes_cli`` (that would run auth's top-level code mid-scan and risk a circular import). Never raises: registration must not fail because of the auth mirror. zhermes_cli.authsync_plugin_provider_registryNzauth registry sync skipped: %s)getattrsysmodulesget Exceptionloggerdebug)syncexcs r _sync_auth_registryr2^sV 3;;??#457VX\ ]D |<  < 5s;;rr,r rr isinstancestrlower startswith)r5r9r?r8s r get_provider_profilerHs  ME !!$'C8<<d+CInn  +Gy}}Y/GG:dC0TZZ\5L5LY5W..$$X.I)--2I Nrct|xsdjj}t|}||jduryddlm}||syt|xsdjjd\}}}|r|syt|jj}|duxr|jduS)aWhether an active route or its aggregator-targeted model rejects image tool parts. Routing aggregators such as ``openrouter`` send vendor-prefixed model IDs (for example, ``xiaomi/mimo-v2.5``), but their own profile cannot describe every routed provider's tool-message compatibility. Preserve the transport profile as the default and consult a registered target profile only for routing aggregators. Missing or unrecognized identities deliberately fail open. NFTr)is_routing_aggregator/)rEstriprFrHsupports_vision_tool_messageshermes_cli.providersrK partition) providermodel provider_namer8rK target_name separator_target_profiles r )routed_model_rejects_vision_tool_messagesrXsB'--/557M"=1GwDDM;  / #EKR 0 6 6 8 B B3 GKA K)+*;*;*=*C*C*EFN  % _.*V*VZ_*__rcts tt}t`t }g}t j D];}t||vs|jt||j|=|atDcgc]}|j|jvs|}}|j|jj Dcic]}t||c}j |Scc}wcc}w)zReturn all registered provider profiles (one per canonical name); the bound home's ``$HERMES_HOME`` plugins shadow process-wide profiles of the same name.) r6rCr>rsetr valuesidaddappendr5rextend)r9seencacher8presults r list_providersrds  ME#') '') &G'{$&G% W% & %- NAu~~1Ma NF N MMU^^%:%:%<=2a5!8=DDFG MO=s C>'C>DcF ddlm}m}|}||}t5t j |}|tx}t |<ddd|-t|x}jk7rt||||_ S#t$rd\}}YzwxYw#1swYNxYw)zRThe layer for the home bound right now, importing plugin dirs it has not seen yet.r)get_hermes_homehermes_home_key)NrJN) hermes_constantsrfrgr-_HOME_LAYERS_LOCKr!r,r_plugin_dir_stampsr_scan_home_layer)rfrghomekeyr9rs r r>r>sE d# 5  % =(2 4EL%5  '9$'??VELLP$ L  c55sB+BBBB c<dd}||dz ||dz dz fS)z[mtimes of ``plugins/`` and ``plugins/model-providers/``: they change when a child is added.c` tj|jS#t$rYywxYw)N)osstat st_mtime_nsOSError)paths r stampz!_plugin_dir_stamps..stamps- 774=,, ,  s ! --r%r&)rtrr)rlrus r rjrjs. $" #U4)+;>O+O%P QQrcp ddlm}|dz dz }|jr|SdS#t$rYywxYw)z>Return ``$HERMES_HOME/plugins/model-providers/`` if it exists.rrfr%r&Nrhrfis_dirr-rfds r _user_plugins_dirr|sB4   ),= =HHJq(D( s$)) 55cj ddlm}|dz }|jr|SdS#t$rYywxYw)uReturn ``$HERMES_HOME/plugins/`` if it exists. This is where ``hermes plugins install`` clones a plugin — flat, one directory per plugin, NOT under ``model-providers/``. See :func:`_discover_installed_provider_plugins`. rrwr%Nrxrzs r _installed_plugins_dirr~s<4   )HHJq(D( s!&& 22cddD] }||z }|js |jdd} ddl}|j |}t |t r.t|jdd jd k(cS |jD]v}|j}|jd sd |vr)|jd \}} } |jdk(sR| jjd d k(ccSyy#t$rYywxYw#t$rYwxYw)ujWhether ``plugin_dir``'s manifest declares ``kind: model-provider``. Only that kind is imported from the flat install directory — every other plugin there belongs to ``PluginManager``, which owns its lifecycle and consent flow. Parsed with PyYAML when available, falling back to a line scan so provider discovery never hard-depends on it. )z plugin.yamlz plugin.ymlutf-8replace)encodingerrorsFrNkindrJzmodel-provider#:z"') is_file read_textr-yaml safe_loadrDrrEr,rM splitlinesrGrP) plugin_dirfilenamemanifesttextrdatalinestrippedrmrVvalues r _declares_model_provider_kindrs?2(!  %%wy%ID  >>$'D$%488FB/0668$..s3MCEyy{f${{}**515EEE  F/0 %     s#DAD# D D # D/.D/ctj|t}}da t}|Yt |j D]=}|j s|jjdr0t|d|?t}|st |j D]W}|j r*|jjds|jdk(r>t|sJt|d|Ytj||atrts tyyy#tj||awxYw)aImport the bound home's not-yet-imported provider plugins into *layer*. ``$HERMES_HOME/plugins/model-providers//`` first, then plugins cloned flat by ``hermes plugins install`` into ``$HERMES_HOME/plugins//`` that declare ``kind: model-provider`` (PluginManager owns every other kind there). Per-home module names let two profiles carry the same plugin without aliasing each other's registrations. TNrV.r=home_keyr&)r$rZr7r|sortediterdirryr5rG_import_plugin_dirr~rresetr6r2)r9rmtokenprior_discoveringuser_dirchild installed_dirs r rkrk5s  477> EL)$&   0 0 23 D<<>%***?*? *K&ufsC D/0  $ 5 5 78 D||~)>)>z)Jejj\mNm07&ufsC  D ""5)( <({ ""5)( s8D3D34A>D33D33E ctj|jdjdd}d|d|jj ddS)Nr _hermes_user_provider_rV-)hashlibsha1encode hexdigestr5r)rrdigests r _user_module_namerTsN \\(//'2 3 = = ? DF #F81Z__-D-DS#-N,O PPrrJrc|dz }|jsy|dk(r d|jjdd}n t||}|tj vry|a tjj||t|g}| |j daytjj|}|tj |<|jj|day#t$rN}tj!d||j|tj j#|dYd}~dayd}~wwxYw#dawxYw) zImport a single plugin directory so it self-registers. ``source`` is "bundled" or "user"; it is recorded per registered profile (``_SOURCES``). z __init__.pyNbundledzplugins.model_providers.rrV)submodule_search_locationsz(Failed to load %s provider plugin %s: %s)existsr5rrr*r+r importlibutilspec_from_file_locationrEloadermodule_from_spec exec_moduler-r.warningpop)rsourcer init_file module_namespecmoduler1s r rrYs8 ]*I     01H1Hc1R0ST ' H= ckk!O~~55 J?P6  <4;;. 006#) K  ' + 6 QT   T** + s2:C,A C,, E5AD>7E>EEE c ddlm} ddlm}m}|}|}|syd} |j}t|drt|j|}nt|j|g}|D]} | j|vs| j|vr!tjd| j@ | j} t#| s]t%| r!tjd | j | y#t$rYywxYw#t$rdt }}YwxYw#t$r }tjd|Yd}~yd}~wwxYw#t$r,}tj!d | j|Yd}~d}~wwxYw#t$r,}tj!d | j|Yd}~Sd}~wwxYw) u*Import pip-installed provider plugins via the ``hermes_agent.plugins`` entry-point group so they self-register. A distribution ships:: [project.entry-points."hermes_agent.plugins"] acme-inference = "acme_hermes_plugin:register" The target may be either a **callable** (``module:func`` — invoked with no args; typically calls ``register_provider(profile)``) or a **module** (``module`` — imported for its module-level ``register_provider`` side effect, mirroring the directory-plugin ``__init__.py`` contract). Gating and safety: * **Opt-in.** Entry-point plugins are subject to the same ``plugins.enabled`` allow-list (and ``plugins.disabled`` deny-list) the general PluginManager enforces — a pip package is never imported just because it is installed. An entry point whose name is not enabled is skipped without loading. * **Provider targets only.** The ``hermes_agent.plugins`` group is shared with general plugins whose target is ``register(ctx)``. Callables that require arguments are skipped here (the PluginManager owns them); provider registration hooks take no arguments by contract. Failures are swallowed per-entry (a broken third-party package must not break provider discovery) and logged at warning level. This scan runs first, so filesystem plugins (bundled + ``$HERMES_HOME``) keep their documented override precedence via last-writer-wins in ``register_provider()`` — a pip package cannot hijack a first-party provider name. rN)_get_disabled_plugins_get_enabled_pluginszhermes_agent.pluginsselect)groupz%entry-point provider scan skipped: %sz6entry-point provider %r skipped: not enabled in configz1Failed to load entry-point provider plugin %r: %szjentry-point %r skipped by provider scan: target requires arguments (general plugin owned by PluginManager)z7Entry-point provider plugin %r raised on invocation: %s)importlib.metadatametadatar-hermes_cli.pluginsrrrZ entry_pointshasattrlistrr,r.r/r5loadrcallable_requires_arguments) _mdrrenableddisabledreps group_epsr1eploadeds r _discover_entry_point_providersrsB( (R&((*  "E   3 !SZZeZ45ISWWUB/0I ! 77' !RWW%8 LLH"''   WWYF F "6* HGG  7!7  ( #%(  /plugins/model-providers//`` 2. Legacy per-file modules at ``providers/.py`` (back-compat) Each step imports its plugins, which call ``register_provider()`` at module-level. Later steps win on name collision. ``$HERMES_HOME`` plugins are per profile home and load through :func:`_home_layer` at lookup time. NTF)r6r7_run_discovery_stepsr2rrr rCrCs=KL    s $2c&ttjrZttj D]:}|jr|j j dr/t|d< ddl}ddl }|j|jD]6\}}}|j ds|dk(r tjd|8y#t$r!}tj!d||Yd}~_d}~wwxYw#t"$rYywxYw) zLThe discovery passes, in precedence order (see :func:`_discover_providers`).rrrNrVbasez providers.z.Failed to import legacy provider module %s: %s)r_BUNDLED_PLUGINS_DIRryrrr5rGrpkgutil providers iter_modules__path__r import_module ImportErrorr.rr-)rr_pkg _importermodname_ispkgr1s r rrs $%""$088:; 1E<<>UZZ%:%::%F ui 0 1  *1*>*>t}}*M  &Iw!!#&'V*; ''*WI(>?    Dgs     s=:AD<CD D C<7D<DD DDOMIT_TEMPERATURE)zproviders.baserctj|}|tdtd|ddl}ddlm}|t|g|t|j|d|dS)Nzmodule z has no attribute r) warn_once) _PLUGIN_COMPAT_LAZYr,AttributeErrorrrhermes_cli.plugin_compatrr)r)r5targetrrs r __getattr__rRsh $ $T *F ~wxl2DTHMNN2 h&v& *9**6!95vay AAr)returnNone)r8rrr)r5rErr)r5rErzProviderProfile | None)rQrErRrErbool)rzlist[ProviderProfile])rr)rlrrr)rz Path | None)rrrr)r9rrmrErr)rrrrErrE)rrrrErrErr)rr);r __future__rrrimportlib.utilloggingrpr* threading contextvarsr dataclassesrrpathlibrproviders.baser getLoggerrr.r rr r rrr6r7rr!Lockrir$__file__resolveparentrr2r;r@rHrXrdr>rjr|r~rrkrrrrrCrrrrrr r s D# "(*   8 $)+ %*..""5929       ') #("INN$ 7AA`jn6o3o N##**Y69JJ <(0 #"`6**R  F>Q JL&R_D02+ r> Br