microsoft-agents-hosting-core 1.10.0.dev2__tar.gz → 1.10.0.dev5__tar.gz

{microsoft_agents_hosting_core-1.10.0.dev2 → microsoft_agents_hosting_core-1.10.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microsoft-agents-hosting-core
-Version: 1.10.0.dev2
+Version: 1.10.0.dev5
 Summary: Core library for Microsoft Agents
 Author: Microsoft Corporation
 License-Expression: MIT
@@ -15,7 +15,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: microsoft-agents-activity==1.10.0.dev2
+Requires-Dist: microsoft-agents-activity==1.10.0.dev5
 Requires-Dist: pyjwt>=2.10.1
 Requires-Dist: isodate>=0.6.1
 Requires-Dist: python-dotenv>=1.1.1

microsoft_agents_hosting_core-1.10.0.dev5/VERSION.txt

@@ -0,0 +1 @@
+1.10.0.dev5

{microsoft_agents_hosting_core-1.10.0.dev2 → microsoft_agents_hosting_core-1.10.0.dev5}/microsoft_agents/hosting/core/app/agent_application.py

@@ -421,7 +421,10 @@ class AgentApplication(Agent, Generic[StateT]):
 
         def __call(func: RouteHandler[StateT]) -> RouteHandler[StateT]:
             logger.debug(
-                f"Registering activity handler for route handler {func.__name__} with type: {activity_type} with auth handlers: {auth_handlers}"
+                "Registering activity handler for route handler %s with type: %s with auth handlers: %s",
+                func.__name__,
+                activity_type,
+                auth_handlers,
             )
             self.add_route(selector, func, auth_handlers=auth_handlers, **kwargs)
             return func
@@ -481,7 +484,10 @@ class AgentApplication(Agent, Generic[StateT]):
 
         def __call(func: RouteHandler[StateT]) -> RouteHandler[StateT]:
             logger.debug(
-                f"Registering event handler for route handler {func.__name__} with select: {select} with auth handlers: {auth_handlers}"
+                "Registering event handler for route handler %s with select: %s with auth handlers: %s",
+                func.__name__,
+                select,
+                auth_handlers,
             )
             self.add_route(selector, func, auth_handlers=auth_handlers, **kwargs)
             return func
@@ -523,7 +529,10 @@ class AgentApplication(Agent, Generic[StateT]):
 
         def __call(func: RouteHandler[StateT]) -> RouteHandler[StateT]:
             logger.debug(
-                f"Registering invoke handler for route handler {func.__name__} with select: {select} with auth handlers: {auth_handlers}"
+                "Registering invoke handler for route handler %s with select: %s with auth handlers: %s",
+                func.__name__,
+                select,
+                auth_handlers,
             )
             self.add_route(
                 selector, func, auth_handlers=auth_handlers, is_invoke=True, **kwargs
@@ -570,7 +579,10 @@ class AgentApplication(Agent, Generic[StateT]):
 
         def __call(func: RouteHandler[StateT]) -> RouteHandler[StateT]:
             logger.debug(
-                f"Registering message handler for route handler {func.__name__} with select: {select} with auth handlers: {auth_handlers}"
+                "Registering message handler for route handler %s with select: %s with auth handlers: %s",
+                func.__name__,
+                select,
+                auth_handlers,
             )
             self.add_route(selector, func, auth_handlers=auth_handlers, **kwargs)
             return func
@@ -634,7 +646,10 @@ class AgentApplication(Agent, Generic[StateT]):
 
         def __call(func: RouteHandler[StateT]) -> RouteHandler[StateT]:
             logger.debug(
-                f"Registering conversation update handler for route handler {func.__name__} with type: {update_type} with auth handlers: {auth_handlers}"
+                "Registering conversation update handler for route handler %s with type: %s with auth handlers: %s",
+                func.__name__,
+                update_type,
+                auth_handlers,
             )
             self.add_route(__selector, func, auth_handlers=auth_handlers, **kwargs)
             return func
@@ -763,7 +778,10 @@ class AgentApplication(Agent, Generic[StateT]):
 
         def __call(func: RouteHandler[StateT]) -> RouteHandler[StateT]:
             logger.debug(
-                f"Registering message reaction handler for route handler {func.__name__} with type: {reaction_type} with auth handlers: {auth_handlers}"
+                "Registering message reaction handler for route handler %s with type: %s with auth handlers: %s",
+                func.__name__,
+                reaction_type,
+                auth_handlers,
             )
             self.add_route(__selector, func, auth_handlers=auth_handlers, **kwargs)
             return func
@@ -880,7 +898,10 @@ class AgentApplication(Agent, Generic[StateT]):
 
         def __call(func: RouteHandler[StateT]) -> RouteHandler[StateT]:
             logger.debug(
-                f"Registering message update handler for route handler {func.__name__} with type: {update_type} with auth handlers: {auth_handlers}"
+                "Registering message update handler for route handler %s with type: %s with auth handlers: %s",
+                func.__name__,
+                update_type,
+                auth_handlers,
             )
             self.add_route(__selector, func, auth_handlers=auth_handlers, **kwargs)
             return func
@@ -961,7 +982,9 @@ class AgentApplication(Agent, Generic[StateT]):
                 )
 
             logger.debug(
-                f"Registering handoff handler for route handler {func.__name__} with auth handlers: {auth_handlers}"
+                "Registering handoff handler for route handler %s with auth handlers: %s",
+                func.__name__,
+                auth_handlers,
             )
 
             self.add_route(selector, __handler, auth_handlers=auth_handlers, **kwargs)
@@ -991,12 +1014,14 @@ class AgentApplication(Agent, Generic[StateT]):
 
         if self._auth:
             logger.debug(
-                f"Registering sign-in success handler for route handler {func.__name__}"
+                "Registering sign-in success handler for route handler %s",
+                func.__name__,
             )
             self._auth.on_sign_in_success(func)
         else:
             logger.error(
-                f"Failed to register sign-in success handler for route handler {func.__name__}",
+                "Failed to register sign-in success handler for route handler %s",
+                func.__name__,
                 stack_info=True,
             )
             raise ApplicationError("""
@@ -1025,12 +1050,14 @@ class AgentApplication(Agent, Generic[StateT]):
 
         if self._auth:
             logger.debug(
-                f"Registering sign-in failure handler for route handler {func.__name__}"
+                "Registering sign-in failure handler for route handler %s",
+                func.__name__,
             )
             self._auth.on_sign_in_failure(func)
         else:
             logger.error(
-                f"Failed to register sign-in failure handler for route handler {func.__name__}",
+                "Failed to register sign-in failure handler for route handler %s",
+                func.__name__,
                 stack_info=True,
             )
             raise ApplicationError("""
@@ -1056,7 +1083,7 @@ class AgentApplication(Agent, Generic[StateT]):
         :type func: Callable[[TurnContext, Exception], Awaitable[None]]
         """
 
-        logger.debug(f"Registering the error handler {func.__name__} ")
+        logger.debug("Registering the error handler %s ", func.__name__)
         self._turn_error_handlers.append(func)
 
         return func
@@ -1065,13 +1092,14 @@ class AgentApplication(Agent, Generic[StateT]):
         """
         Custom Turn State Factory
         """
-        logger.debug(f"Setting custom turn state factory: {func.__name__}")
+        logger.debug("Setting custom turn state factory: %s", func.__name__)
         self._turn_state_factory = func
         return func
 
     async def on_turn(self, context: TurnContext):
         logger.debug(
-            f"AgentApplication.on_turn(): Processing turn for context: {context.activity.id}"
+            "AgentApplication.on_turn(): Processing turn for context: %s",
+            context.activity.id,
         )
         await self._start_long_running_call(context, self._on_turn)
 
@@ -1179,7 +1207,8 @@ class AgentApplication(Agent, Generic[StateT]):
                 input_files = state.temp.input_files if state.temp.input_files else []
                 for file_downloader in self._options.file_downloaders:
                     logger.info(
-                        f"Using file downloader: {file_downloader.__class__.__name__}"
+                        "Using file downloader: %s",
+                        file_downloader.__class__.__name__,
                     )
                     files = await file_downloader.download_files(context)
                     input_files.extend(files)
@@ -1237,7 +1266,9 @@ class AgentApplication(Agent, Generic[StateT]):
 
         if not route_matched:
             logger.warning(
-                f"No route found for activity type: {context.activity.type} with text: {context.activity.text}"
+                "No route found for activity type: %s with text: %s",
+                context.activity.type,
+                context.activity.text,
             )
         if on_turn_span is not None:
             on_turn_span.share(
@@ -1254,7 +1285,9 @@ class AgentApplication(Agent, Generic[StateT]):
             and context.identity is not None
         ):
             logger.debug(
-                f"Starting long running call for context: {context.activity.id} with function: {func.__name__}"
+                "Starting long running call for context: %s with function: %s",
+                context.activity.id,
+                func.__name__,
             )
             return await context.adapter.continue_conversation_with_claims(
                 claims_identity=context.identity,
@@ -1290,7 +1323,7 @@ class AgentApplication(Agent, Generic[StateT]):
                 task.result()
             except Exception as e:
                 logger.error(
-                    f"Error occurred while replaying the turn.",
+                    "Error occurred while replaying the turn.",
                     exc_info=True,
                 )
 
@@ -1327,12 +1360,15 @@ class AgentApplication(Agent, Generic[StateT]):
         """
 
         logger.error(
-            f"An error occurred in the AgentApplication: {err}",
+            "An error occurred in the AgentApplication: %s",
+            err,
             exc_info=True,
         )
 
         for err_func in self._turn_error_handlers:
-            logger.info(f"Calling error handler {err_func.__name__} for error: {err}")
+            logger.info(
+                "Calling error handler %s for error: %s", err_func.__name__, err
+            )
             await err_func(context, err)
 
         if not self._turn_error_handlers:

{microsoft_agents_hosting_core-1.10.0.dev2 → microsoft_agents_hosting_core-1.10.0.dev5}/microsoft_agents/hosting/core/app/oauth/_handlers/connector_user_authorization.py

@@ -119,7 +119,9 @@ class ConnectorUserAuthorization(_AuthorizationHandler):
                     )
             except (ValueError, AttributeError) as ex:
                 logger.error(
-                    f"Error checking token expiration for handler {self._id}: {ex}"
+                    "Error checking token expiration for handler %s: %s",
+                    self._id,
+                    ex,
                 )
                 raise
 
@@ -234,7 +236,7 @@ class ConnectorUserAuthorization(_AuthorizationHandler):
                 token_response.expiration = expiration.isoformat()
 
         except Exception as ex:
-            logger.warning(f"Failed to parse JWT token for handler {self._id}: {ex}")
+            logger.warning("Failed to parse JWT token for handler %s: %s", self._id, ex)
             raise ex
 
         return token_response

{microsoft_agents_hosting_core-1.10.0.dev2 → microsoft_agents_hosting_core-1.10.0.dev5}/microsoft_agents/hosting/core/app/streaming/streaming_response.py

@@ -468,7 +468,7 @@ class StreamingResponse:
         Sends any queued activities to the client until the queue is empty.
         """
         try:
-            logger.debug(f"Draining queue with {len(self._queue)} activities.")
+            logger.debug("Draining queue with %s activities.", len(self._queue))
             while self._queue:
                 factory = self._queue.pop(0)
                 activity = factory()

{microsoft_agents_hosting_core-1.10.0.dev2 → microsoft_agents_hosting_core-1.10.0.dev5}/microsoft_agents/hosting/core/authorization/connection_settings_base.py

@@ -4,7 +4,16 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
+from dataclasses import dataclass, field, fields
 from typing import Any, TYPE_CHECKING
+from typing_extensions import Self
+
+from microsoft_agents.activity.config import (
+    Configuration,
+    _Configurable,
+    _resolve,
+    xpath,
+)
 
 if TYPE_CHECKING:
     from .agent_auth_configuration import AgentAuthConfiguration
@@ -109,3 +118,87 @@ class _ConnectionSettingsBase:
     ) -> "_ConnectionSettingsBase":
         """Build base settings from an :class:`AgentAuthConfiguration`."""
         return cls(**cls.base_kwargs_from_configuration(configuration))
+
+
+_KNOWN_KWARGS_CACHE: dict[type[ConnectionSettingsBase], list[str]] = {}
+
+
+@dataclass(frozen=True)
+class ConnectionSettingsBase(_Configurable):
+    """Provider-independent settings bound from Configuration.
+
+    Frozen fields cannot be reassigned, but scopes and extras remain mutable.
+    Treat those containers as read-only after handing settings to a provider.
+    """
+
+    client_id: str | None = None
+    authority: str | None = None
+    tenant_id: str | None = None
+    alternate_blueprint_connection_name: str | None = None
+    scopes: list[str] = field(default_factory=list)
+    _extras: Configuration = field(default_factory=Configuration)
+
+    @property
+    def extras(self) -> Configuration:
+        """Return unrecognized provider settings, not an immutable copy."""
+        return self._extras
+
+    @classmethod
+    def _from_agent_auth_config(cls, agent_auth_config: AgentAuthConfiguration) -> Self:
+        attrs = dict(vars(agent_auth_config))
+        attrs.update(attrs.pop("provider_settings", {}))
+        attrs["ISSUERS"] = agent_auth_config.ISSUERS
+        if isinstance(attrs.get("SCOPES"), Mapping):
+            # TODO: Temporary compatibility for legacy indexed scopes; the next
+            # PR's configuration-loader migration will normalize these mappings.
+            attrs["SCOPES"] = _resolve({"SCOPES": attrs["SCOPES"]})["SCOPES"]
+        return cls.from_mapping(attrs)
+
+    @classmethod
+    def _get_init_kwargs(cls, config: Configuration) -> dict:
+        return {
+            "client_id": config.get_strn(cls._xpath("client_id")),
+            "authority": config.get_strn(
+                cls._xpath("authority"), cls._xpath("authorityendpoint")
+            ),
+            "tenant_id": config.get_strn(cls._xpath("tenant_id")),
+            "scopes": config.get_scopes(cls._xpath("scopes")),
+            "alternate_blueprint_connection_name": config.get_strn(
+                "alt_blueprint_name",
+                "ALT_BLUEPRINT_NAME",
+                "alt_blueprint_id",
+                "ALT_BLUEPRINT_ID",
+                *cls._xpath("alternate_blueprint_connection_name"),
+            ),
+        }
+
+    @classmethod
+    def _known_kwargs(cls) -> list[str]:
+        if cls not in _KNOWN_KWARGS_CACHE:
+            _KNOWN_KWARGS_CACHE[cls] = [
+                alias
+                for f in fields(cls)
+                if f.init and f.name != "_extras"
+                for alias in xpath(f.name)
+            ]
+        return _KNOWN_KWARGS_CACHE[cls]
+
+    @classmethod
+    def _get_extras(cls, config: Configuration) -> Configuration:
+        known_kwargs = cls._known_kwargs()
+        base = {k: v for k, v in config.items() if k not in known_kwargs}
+        return Configuration.from_mapping(
+            base, _base_path=config._base_path, **base.pop("extras", {})
+        )
+
+    @classmethod
+    def _from_configuration(cls, config: Configuration) -> Self:
+        try:
+            settings = config.get_section(xpath("settings"))
+        except KeyError:
+            settings = config
+        return cls(**cls._get_init_kwargs(settings), _extras=cls._get_extras(settings))
+
+    @staticmethod
+    def _xpath(name: str) -> list[str]:
+        return xpath(name, lower_snake=True)

{microsoft_agents_hosting_core-1.10.0.dev2 → microsoft_agents_hosting_core-1.10.0.dev5}/microsoft_agents/hosting/core/authorization/jwt/__init__.py

@@ -3,8 +3,12 @@
 
 from ._authorize_request import _authorize_request
 from .jwt_token_validator import JwtTokenValidator
+from .jwt_connection_settings import JwtConnectionSettings
+from .token_validation_configuration import TokenValidationConfiguration
 
 __all__ = [
     "JwtTokenValidator",
     "_authorize_request",
+    "JwtConnectionSettings",
+    "TokenValidationConfiguration",
 ]

{microsoft_agents_hosting_core-1.10.0.dev2 → microsoft_agents_hosting_core-1.10.0.dev5}/microsoft_agents/hosting/core/authorization/jwt/_authorize_request.py

@@ -4,7 +4,10 @@
 import logging
 
 from jwt import PyJWTError
+from typing import Any, Mapping
+from weakref import WeakKeyDictionary
 
+from microsoft_agents.activity.config import Configuration
 from microsoft_agents.hosting.core.http import HttpResponse
 
 from ..agent_auth_configuration import AgentAuthConfiguration
@@ -13,9 +16,33 @@ from .jwt_token_validator import JwtTokenValidator
 
 logger = logging.getLogger(__name__)
 
+_TOKEN_VALIDATION_CACHE: WeakKeyDictionary[Any, JwtTokenValidator] = WeakKeyDictionary()
+
+
+def _resolve_token_validator(
+    auth_config: Configuration | AgentAuthConfiguration | None,
+    cache_key: Any = None,
+) -> JwtTokenValidator | None:
+
+    if cache_key is not None and cache_key in _TOKEN_VALIDATION_CACHE:
+        return _TOKEN_VALIDATION_CACHE[cache_key]
+
+    if auth_config is not None:
+        config: AgentAuthConfiguration | Configuration = auth_config
+        if not isinstance(auth_config, AgentAuthConfiguration):
+            config = Configuration(auth_config)
+        validator = JwtTokenValidator(config)
+        if cache_key is not None:
+            _TOKEN_VALIDATION_CACHE[cache_key] = validator
+        return validator
+    return None
+
 
 async def _authorize_request(
-    authorization_header: str | None, auth_config: AgentAuthConfiguration | None
+    authorization_header: str | None,
+    auth_config: Configuration | AgentAuthConfiguration | None,
+    *,
+    cache_key: Any = None
 ) -> ClaimsIdentity | HttpResponse:
     """
     Authorizes a request based on the provided JWT token in the Authorization header.
@@ -25,16 +52,16 @@ async def _authorize_request(
     :return: A ClaimsIdentity object if the token is valid, or an HttpResponse with an
         error message and status code if the token is invalid or missing.
     """
+    validator = _resolve_token_validator(auth_config, cache_key)
 
-    if auth_config is None:
+    if not validator:
         return HttpResponse(
             body={"error": "Agent Authentication configuration not found"},
             status_code=500,
         )
-    validator = JwtTokenValidator(auth_config)
 
     if not authorization_header:
-        if auth_config.ANONYMOUS_ALLOWED:
+        if validator.config.anonymous_allowed:
             claims_identity = validator.get_anonymous_claims()
             return claims_identity
         return HttpResponse(

microsoft_agents_hosting_core-1.10.0.dev5/microsoft_agents/hosting/core/authorization/jwt/jwt_connection_settings.py

@@ -0,0 +1,40 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from microsoft_agents.activity.config import Configuration, xpath
+
+from .._entra_issuers import default_connection_issuers
+from ..connection_settings_base import ConnectionSettingsBase
+
+
+@dataclass(frozen=True)
+class JwtConnectionSettings(ConnectionSettingsBase):
+    """Provider-independent connection settings for inbound JWT validation."""
+
+    validate_issuer: bool = False
+    issuers: list[str] = field(default_factory=list)
+    anonymous_allowed: bool = False
+
+    @classmethod
+    def _get_init_kwargs(cls, config: Configuration) -> dict:
+        base = super()._get_init_kwargs(config)
+        issuers = config.get_str_list(xpath("issuers"))
+        issuers = issuers or default_connection_issuers(
+            base.get("tenant_id"), base.get("authority")
+        )
+        base.update(
+            {
+                "validate_issuer": config.get_bool(
+                    xpath("validate_issuer"), default=False
+                ),
+                "issuers": issuers,
+                "anonymous_allowed": config.get_bool(
+                    xpath("anonymous_allowed"), default=False
+                ),
+            }
+        )
+        return base