`gjZdZddlmZddlZddlZddlZddlZddlmZddl m Z m Z m Z m Z ejeZdZdZddZd Zdd Zed Gd dZd dZej0dd dZd!ddd d d"dZd!ddd d d#dZd!ddd d d$dZd%dZd&dZd'dZgdZ y)(uMicrosoft Entra ID adapter for Microsoft Foundry. Provides keyless authentication for Microsoft Foundry deployments using the `azure-identity` SDK's `DefaultAzureCredential` chain (env service principal → workload identity → managed identity → VS Code → Azure CLI → azd → PowerShell → broker). Architecture mirrors `agent/bedrock_adapter.py`: * Lazy import. `azure-identity` is only loaded when ``model.auth_mode = entra_id`` is selected. Users who stick with `AZURE_FOUNDRY_API_KEY` never pay the import cost. * SDK-callable contract. The public entry point ``build_token_provider`` returns a zero-arg callable produced by ``get_bearer_token_provider`` — this is exactly the value Microsoft's documented sample plugs into ``OpenAI(api_key=token_provider, base_url=...)``. The OpenAI SDK calls it before every request, so token refresh is transparent. * Three explicit consumer-side helpers (display / cache / http-bearer) rather than one generic "materialize" function — splitting them by purpose prevents accidental token-minting in logging paths or token leakage into cache keys / dashboard JSON. * No persisted JWT. ``azure-identity`` caches in-process and (where available) in the OS keychain or ``~/.IdentityService``. Hermes does not duplicate that storage in ``auth.json``. Reference: https://learn.microsoft.com/azure/ai-foundry/foundry-models/how-to/configure-entra-id Requires: ``azure-identity`` (optional dependency — only needed when ``model.auth_mode = entra_id``). ) annotationsN) dataclass)AnyCallableDictOptionalzhttps://ai.azure.com/.defaultzprovider.azure_identityc, ddl}y#t$rYywxYw)uxReturn True if `azure-identity` can be imported right now. Cheap check — does not walk the credential chain. rNTF)azure.identity Exception)azures O/root/.hermes/venv/lib/python3.12/site-packages/agent/azure_identity_adapter.pyhas_azure_identity_installedr<s  s  c ddlm}|S#t$rg ddlm}m}n#t$r}td|d}~wwxYw |t dn%#|$r}tdt|z|d}~wwxYwddlm}|cYSwxYw)zImport ``azure.identity``, lazy-installing it if allowed. Raises ``ImportError`` with a clear actionable message when the package is missing and lazy installs are disabled. rN)ensureFeatureUnavailablezThe 'azure-identity' package is required for Azure AI Foundry Entra ID authentication. Install it with: pip install azure-identityF)promptzWThe 'azure-identity' package is required for Azure AI Foundry Entra ID authentication. )r identity ImportErrortools.lazy_depsrr_AZURE_IDENTITY_FEATUREstr)_airrexcs r _require_azure_identityrHs $   B B -     *5 9! 469#h?   % )sL A:A: 7 27A:A  A: A,A''A,, A:9A:cLttdd}t|r|yy)u%Clear the cached ``DefaultAzureCredential``. Used by tests and profile switches. Defensive against tests that ``monkeypatch.setattr`` over ``build_credential`` with a plain (non-lru-cached) function — those won't expose ``cache_clear()`` until pytest reverts the patch. cache_clearN)getattrbuild_credentialcallable)rs r reset_credential_cacher hs%*M4@K  T)frozenc\eZdZUdZeZded<dZded<d dZd dZ e d d  dd Z y )EntraIdentityConfiguSerializable Entra ID config. Captures the Hermes-managed Entra knobs we need outside Azure SDK environment configuration. Everything else (tenant ID, service principal secret, federated token file, sovereign cloud authority, etc.) flows through azure-identity's standard ``AZURE_*`` env vars — see the Bedrock pattern in ``hermes_cli/runtime_provider.py:1310-1377`` for the analogous "let the SDK read env" approach. ``scope`` is Microsoft's documented Foundry inference audience. Almost everyone uses the default; sovereign-cloud / non-standard tenants can override via ``model.entra.scope``. Identity selection (user-assigned managed identity, workload identity, service principal, tenant, authority) stays in the standard Azure SDK env vars such as ``AZURE_CLIENT_ID``. ``exclude_interactive_browser`` is kept as an internal constructor knob so probes stay non-interactive by default. It is not written by the setup wizard. The dataclass is frozen so it's hashable for ``functools.lru_cache`` keying, and serializable across multiprocessing boundaries (workers rebuild the credential inside their own process). rscopeTboolexclude_interactive_browserct|jxsdjxst}tj |d|y)Nr%)rr%stripSCOPE_AI_AZURE_DEFAULTobject __setattr__)selfr%s r __post_init__z!EntraIdentityConfig.__post_init__s6DJJ$"%++-G1G4%0r!c4|j|jdS)Nr%r'r1)r.s r to_dictzEntraIdentityConfig.to_dictsZZ+/+K+K  r!N) default_scopec|xsi}t|jdxsdjxs |xst}t |jdd}|||S)Nr%r)r'Tr1)rgetr*r+r&)clsdatar3r%exclude_browsers r from_dictzEntraIdentityConfig.from_dictsbzrDHHW%+,224_ _I_txx(EtLM(7  r!returnNone)r;Dict[str, Any])r7zOptional[Dict[str, Any]]r3 Optional[str]r;z'EntraIdentityConfig') __name__ __module__ __qualname____doc__r+r%__annotations__r'r/r2 classmethodr9r!r r$r$zsO2(E3'(,,1 48 $1 =R  r!r$c`t}i}|jsd|d<|jdi|S)uConstruct a ``DefaultAzureCredential`` for ``config``. Only Hermes-selected knobs are passed as kwargs. Everything else (tenant, service principal secret, federated token file, sovereign cloud authority, etc.) is read by ``azure-identity`` from the standard ``AZURE_*`` environment variables — see Microsoft's documented credential resolution chain. Users configure those in ``~/.hermes/.env`` or the deployment environment. F&exclude_interactive_browser_credentialrE)rr'DefaultAzureCredential)configaikwargss r _build_default_credentialrLs= ! "BF  - -;@78 $2 $ $ .v ..r!)maxsizect|S)u#Return the cached ``DefaultAzureCredential`` for ``config``. Hermes processes use exactly one Entra config at a time (the ``model.entra.*`` block in config.yaml drives every aux task, subagent, and credential probe in the session). ``maxsize=1`` is intentional: it reflects the actual usage pattern and keeps the cache trivially small. ``EntraIdentityConfig`` is a frozen dataclass, so it's hashable and safe as an LRU-cache key. ``functools.lru_cache`` is thread-safe in CPython. If two distinct configs are ever passed (tests do this; production rarely), the LRU eviction handles it correctly — each call still returns a credential matching its config; only one is cached at a time. Use :func:`reset_credential_cache` to clear (e.g. in tests). )rL)rIs r rrs& %V ,,r!)rIbase_urlr'ct}|t|xst|}t|}|j ||j S)uReturn a zero-arg callable that mints a fresh Entra bearer JWT. The returned callable is exactly what Microsoft's documented Foundry sample expects:: from openai import OpenAI client = OpenAI( base_url="https://my-resource.openai.azure.com/openai/v1/", api_key=build_token_provider(), ) Scope resolution order: 1. ``config.scope`` when a config object is supplied 2. explicit ``scope`` kwarg 3. ``SCOPE_AI_AZURE_DEFAULT`` (Microsoft's documented Foundry scope) ``base_url`` is unused today and kept for back-compat. Tenant / service-principal / sovereign-cloud configuration flows through ``azure-identity``'s standard ``AZURE_*`` environment variables — see :func:`_build_default_credential` for the rationale. NOT serializable across process boundaries. For multiprocessing workers, serialize the ``EntraIdentityConfig`` and rebuild the provider inside the worker. r1)rr$r+rget_bearer_token_providerr%)r%rIrPr'rJ credentials r build_token_providerrTsJ> ! "B ~$11(C "&)J ' ' FLL AAr!g$@)rItimeout_seconds allow_installc  ts|sy t)|xsdj xst }td d|i|ddi d fd }tj|d }|j|jtd | |jrtj d |yt jdS#t$r }tj d|Yd}~yd}~wwxYw)u!Best-effort probe: can `DefaultAzureCredential` mint a token now? Runs ``credential.get_token(scope)`` under a thread-based timeout so a slow token service can't hang the caller. Returns False on any error — never raises. Use for ``hermes doctor`` / ``hermes auth status`` / wizard preflight. ``allow_install``: when True (default) and ``azure-identity`` is not importable, the adapter triggers the standard lazy-install path (subject to ``security.allow_lazy_installs``) before probing. Set False to make this strictly an "is installed?" check — used on hot paths like CLI startup where we never want pip to run. NOT used by ``is_provider_configured()`` — that path is structural only (no token mint), so CLI startup doesn't pay this latency. Fz+azure-identity lazy install unavailable: %sNr)r%okc t}|jj}tt |ddd<y#t $r%}t jd|dd<Yd}~yd}~wwxYw)NtokenrXz!Entra credential probe failed: %sF)r get_tokenr%r&rr loggerdebugrStokrrIresults r _probez.has_azure_identity_credentials.._probe)se !)&1J&&v||4CWd ;C99C>)r%rUrVc  ddi}ts|s d|d<d|d<|S t)|xsd j xst }t d"d |i|j|d <tjjd d j r$tjd j |d <g}tjjd d j r|jdtjjdd j rmtjjdd j r?tjjd d j r|jdtjjdd j s.tjjdd j r|jd||d<i d# fd } tj| d} | j| jt!d|| j#rd|dd|d<d|d<|Sd vr d|d<|S jd} | d |d<|Sd|d<t%| d!d|d!<|S#t$r#}t|xsd|d<d|d<|cYd}~Sd}~wwxYw)$uReturn diagnostic info about the active credential chain. Best-effort: runs ``get_token()`` and inspects what came back. Designed for ``hermes doctor`` and the wizard preflight — never raises, returns ``{"ok": False, "error": ...}`` on failure. ``allow_install``: when True (default) and ``azure-identity`` is not importable, the adapter triggers the standard lazy-install path (subject to ``security.allow_lazy_installs``) before probing. The install failure is surfaced as the diagnostic error when it fails. Set False for hot CLI paths that should never trigger pip. ``azure-identity`` doesn't expose the winning inner credential as a public field, so we report a coarse picture (env vars present, token expiry, claims-derived tenant) rather than the credential class name. Users wanting the precise class can run with ``AZURE_LOG_LEVEL=DEBUG``. rXFzazure-identity not installederrorzApip install azure-identity (or rely on lazy install at first use)hintzqpip install azure-identity manually, or enable lazy installs (security.allow_lazy_installs: true in config.yaml).Nr)r%AZURE_TENANT_ID tenant_id_envAZURE_FEDERATED_TOKEN_FILEz7WorkloadIdentityCredential (AZURE_FEDERATED_TOKEN_FILE)AZURE_CLIENT_IDAZURE_CLIENT_SECRETz%EnvironmentCredential (client secret)IDENTITY_ENDPOINT MSI_ENDPOINTz-ManagedIdentityCredential (IDENTITY_ENDPOINT) env_sourcesc t}|jj}|d<y#t$r}t |d<Yd}~yd}~wwxYw)NrZrs)rr[r%r rr^s r raz*describe_active_credential.._probesL ')&1J&&v||4C!F7O '!#hF7O 's+/ AA  ATrbrerfzToken probe timed out after z.0fszDefaultAzureCredential can be slow when the token service is unreachable or when az login state is stale. Try `az login` or set AZURE_CLIENT_ID / AZURE_TENANT_ID / AZURE_CLIENT_SECRET.rZzcredential chain exhausted expires_onrEr:)rrrrr*r+r$r%osenvironr5appendrhrirjrkrlrmr) rIr%rUrVrninforror|rarprZr`s ` @r describe_active_credentialr;s0!%=D ' ):DM LK  # %~ ;B--/I3I$H?HiHLLDM zz~~',224 " +< = C C E_K zz~~2B7==?TU ("-335 4b9??A 0"5;;=BC zz~~)2.446"**..Y[:\:b:b:dJK%D F'  VD 9F LLN KKD/2K3 6s6K1MW  G V  &wW  JJw E }4W  DJ  d;D KC HF(FDM  L K s J00 K9KKKc>t|xrt|t S)zReturn True when ``value`` is a callable Entra token provider. Used at the seams where a consumer must decide between string-API-key semantics and bearer-callable semantics. )r isinstancer)values r is_token_providerrs E? 9:eS#999r!ct|r&|}t|tr|s td|St|tr|r|Std)uFReturn a fresh Bearer JWT for a manual HTTP request. Only call this at sites that must construct an ``Authorization`` header outside the OpenAI SDK (e.g. ``hermes_cli/azure_detect.py``). Calls the callable exactly once and returns the resulting token. **Anthropic SDK integration:** the Anthropic Python SDK does not accept a ``Callable[[], str]`` for ``auth_token``. Instead, :func:`build_bearer_http_client` returns an ``httpx.Client`` whose request event hook calls this function and rewrites the ``Authorization`` header per request — and that client is passed to the Anthropic SDK via ``http_client=...``. See :func:`agent.anthropic_adapter.build_anthropic_client` for the consumer. Raises ``ValueError`` if ``value`` is not a callable token provider or non-empty string. z#token provider returned empty valuez"no usable api_key / token provider)rrr ValueError)rrZs r materialize_bearer_for_httprsM&%%UBC C %% 9 ::r!c ts td ddl}dfd }|jd dd|gii|S#t$r}td|d}~wwxYw) uyReturn an ``httpx.Client`` that mints a fresh Entra bearer JWT per outbound request. The Anthropic SDK (≤ 0.86.0 at the time of writing) stores ``api_key`` / ``auth_token`` as static strings and computes the ``Authorization`` header at construction time. To get per-request token refresh (the Microsoft-recommended Foundry pattern for callable bearer providers), we install an httpx ``request`` event hook on a custom client and pass that client to the SDK via ``http_client=...``. The hook: 1. Calls :func:`materialize_bearer_for_http` to mint a fresh JWT (azure-identity caches internally — this is cheap when the cached token is still valid). 2. Strips any pre-set ``Authorization`` / ``api-key`` / ``x-api-key`` headers the SDK may have added (avoids conflicting auth values). 3. Sets ``Authorization: Bearer ``. ``token_provider`` must be a zero-arg callable returning a string — typically the result of :func:`build_token_provider`. ``httpx_kwargs`` are forwarded verbatim to ``httpx.Client(...)`` so callers can attach a ``timeout``, ``transport``, ``proxy``, etc. Raises ``ImportError`` if ``httpx`` is not installed (it is a transitive dependency of both ``openai`` and ``anthropic`` SDKs, so in practice always available when this helper is reached). zDbuild_bearer_http_client requires a zero-arg callable token providerrNzhttpx is required for Entra ID bearer auth on Microsoft Foundry Anthropic-style endpoints. It is normally a transitive dependency of the openai/anthropic SDKs.requestc& t}dD]}|jj |d d||jd<y#t$rC}tjd|dD]}|jj |d Yd}~yd}~wwxYw)NuBearer hook: Entra ID token provider returned empty (%s) — stripping Authorization headers. Azure will respond 401. Run `hermes doctor` or `az login` to recover.) Authorization authorizationzApi-Keyzapi-keyz X-Api-Keyz x-api-keyzBearer r)rrr\warningheaderspop)rrZr header_nametoken_providers r _inject_bearerz0build_bearer_http_client.._inject_bearers /?E0n 3K OO   T 2 3-4UG+<(3  NN@   r 7 ##K6 7 - s A B 9B  B event_hooks)rz'httpx.Request'r;r<rE)rrhttpxrClient)r httpx_kwargsrrrs` r build_bearer_http_clientrs< ^ ,   =< 5<<  01   K  7   s: A AA) r$r+rrrTrrqrrrr )r;r&r:)rIr$r;r)N) r%r>rIOptional[EntraIdentityConfig]rPr>r'r&r;Callable[[], str]) r%r>rIrrUfloatrVr&rnrr;r&) rIrr%r>rUrrVr&rnrr;r=)rrr;r&)rrr;r)rrrrr;r)!rB __future__r functoolsloggingrrh dataclassesrtypingrrrr getLoggerr?r\r+rrrr r$rL lru_cacherrTrqrrrr__all__rEr!r rs># !00   8 $9 4 @ $ $0 0 0 f/&Q- -*&BAE37=A &B!>&B$1&B7; &B 0 &B\3"KO<@9= 3"+H3"5:3"37 3" 14 3" 9= 3"ld6:8<59 d&3d16d/3 d -0 d 5C dZ:;:Nb r!