microsoft-agents-hosting-core 1.4.0.dev13__tar.gz → 1.4.0.dev18__tar.gz

{microsoft_agents_hosting_core-1.4.0.dev13/microsoft_agents_hosting_core.egg-info → microsoft_agents_hosting_core-1.4.0.dev18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microsoft-agents-hosting-core
-Version: 1.4.0.dev13
+Version: 1.4.0.dev18
 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.4.0.dev13
+Requires-Dist: microsoft-agents-activity==1.4.0.dev18
 Requires-Dist: pyjwt>=2.10.1
 Requires-Dist: isodate>=0.6.1
 Requires-Dist: python-dotenv>=1.1.1

microsoft_agents_hosting_core-1.4.0.dev18/VERSION.txt

@@ -0,0 +1 @@
+1.4.0.dev18

{microsoft_agents_hosting_core-1.4.0.dev13 → microsoft_agents_hosting_core-1.4.0.dev18}/microsoft_agents/hosting/core/_oauth/_flow_storage_client.py

@@ -1,8 +1,6 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License.
 
-from typing import Optional
-
 from ..storage import Storage
 from ._flow_state import _FlowState
 
@@ -34,7 +32,7 @@ class _FlowStorageClient:
         channel_id: str,
         user_id: str,
         storage: Storage,
-        cache_class: Optional[type[Storage]] = None,
+        cache_class: type[Storage] | None = None,
     ):
         """
         Args:
@@ -65,7 +63,7 @@ class _FlowStorageClient:
         """Creates a storage key for a specific sign-in handler."""
         return f"{self._base_key}{auth_handler_id}"
 
-    async def read(self, auth_handler_id: str) -> Optional[_FlowState]:
+    async def read(self, auth_handler_id: str) -> _FlowState | None:
         """Reads the flow state for a specific authentication handler."""
         key: str = self.key(auth_handler_id)
         data = await self._cache.read([key], target_cls=_FlowState)
@@ -74,13 +72,13 @@ class _FlowStorageClient:
             if key not in data:
                 return None
             await self._cache.write({key: data[key]})
-        return _FlowState.model_validate(data.get(key))
+        return data.get(key)
 
     async def write(self, value: _FlowState) -> None:
         """Saves the flow state for a specific authentication handler."""
         key: str = self.key(value.auth_handler_id)
         cached_state = await self._cache.read([key], target_cls=_FlowState)
-        if not cached_state or cached_state != value:
+        if not cached_state or cached_state.get(key, None) != value:
             await self._cache.write({key: value})
             await self._storage.write({key: value})
 

{microsoft_agents_hosting_core-1.4.0.dev13 → microsoft_agents_hosting_core-1.4.0.dev18}/microsoft_agents/hosting/core/_oauth/_oauth_flow.py

@@ -126,7 +126,7 @@ class _OAuthFlow:
             magic_code=magic_code,
         )
         if token_response:
-            logger.info("User token obtained successfully: %s", token_response)
+            logger.info("User token obtained successfully")
             self._flow_state.expiration = (
                 datetime.now(timezone.utc).timestamp() + self._default_flow_duration
             )
@@ -315,10 +315,7 @@ class _OAuthFlow:
             self._flow_state.expiration = (
                 datetime.now(timezone.utc).timestamp() + self._default_flow_duration
             )
-            logger.debug(
-                "OAuth flow completed successfully, got TokenResponse: %s",
-                token_response,
-            )
+            logger.debug("OAuth flow completed successfully, got a token response.")
 
         return _FlowResponse(
             flow_state=self._flow_state.model_copy(),

microsoft_agents_hosting_core-1.4.0.dev18/microsoft_agents/hosting/core/app/adaptive_card/__init__.py

@@ -0,0 +1,6 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+from .adaptive_card import AdaptiveCard
+
+__all__ = ["AdaptiveCard"]

microsoft_agents_hosting_core-1.4.0.dev18/microsoft_agents/hosting/core/app/adaptive_card/_type_defs.py

@@ -0,0 +1,46 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+from typing import Awaitable, Protocol
+
+from microsoft_agents.activity import (
+    AdaptiveCardInvokeResponse,
+    AdaptiveCardInvokeValue,
+)
+
+from microsoft_agents.hosting.core.turn_context import TurnContext
+from microsoft_agents.hosting.core.app.state import TurnState
+
+from .models import (
+    AdaptiveCardSearchParams,
+    AdaptiveCardSearchResult,
+    Query,
+)
+
+
+class ActionExecuteHandler(Protocol):
+    def __call__(
+        self, context: TurnContext, state: TurnState, data: object, /
+    ) -> Awaitable[AdaptiveCardInvokeResponse]: ...
+
+
+class ActionExecuteValueHandler(Protocol):
+    def __call__(
+        self, context: TurnContext, state: TurnState, value: AdaptiveCardInvokeValue, /
+    ) -> Awaitable[AdaptiveCardInvokeResponse]: ...
+
+
+class ActionSubmitHandler(Protocol):
+    def __call__(
+        self, context: TurnContext, state: TurnState, data: object, /
+    ) -> Awaitable[None]: ...
+
+
+class SearchHandler(Protocol):
+    def __call__(
+        self,
+        context: TurnContext,
+        state: TurnState,
+        query: Query[AdaptiveCardSearchParams],
+        /,
+    ) -> Awaitable[list[AdaptiveCardSearchResult]]: ...

microsoft_agents_hosting_core-1.4.0.dev18/microsoft_agents/hosting/core/app/adaptive_card/adaptive_card.py

@@ -0,0 +1,275 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+from dataclasses import asdict
+from http import HTTPStatus
+from typing import TYPE_CHECKING, Callable, Pattern
+
+import pydantic
+
+from microsoft_agents.activity import (
+    Activity,
+    ActivityTypes,
+    AdaptiveCardInvokeResponse,
+    AdaptiveCardInvokeValue,
+    AdaptiveCardSearchInvokeValue,
+    Channels,
+    ChannelId,
+    InvokeResponse,
+)
+from microsoft_agents.hosting.core.turn_context import TurnContext
+
+from ..state import TurnState
+from . import factory
+from ._type_defs import (
+    ActionExecuteHandler,
+    ActionSubmitHandler,
+    SearchHandler,
+)
+from .models import AdaptiveCardSearchParams, Query
+
+if TYPE_CHECKING:
+    from ..agent_application import AgentApplication
+
+_ACTION_EXECUTE_TYPE = "Action.Execute"
+_ACTION_INVOKE_NAME = "adaptiveCard/action"
+_SEARCH_INVOKE_NAME = "application/search"
+
+
+class AdaptiveCard:
+    """Register handlers for Adaptive Card activities."""
+
+    def __init__(self, app: AgentApplication):
+        """Initialize an Adaptive Card route registrar for an application."""
+        self._app = app
+
+    def action_execute(
+        self,
+        verb: str | Pattern[str],
+        *,
+        auth_handlers: list[str] | None = None,
+        **kwargs,
+    ) -> Callable[[ActionExecuteHandler], ActionExecuteHandler]:
+        """Register an ``Action.Execute`` handler that receives the action data."""
+
+        def selector(context: TurnContext) -> bool:
+            activity = context.activity
+            if (
+                activity.type != ActivityTypes.invoke
+                or activity.name != _ACTION_INVOKE_NAME
+            ):
+                return False
+
+            try:
+                invoke_value = AdaptiveCardInvokeValue.model_validate(activity.value)
+            except pydantic.ValidationError:
+                return False
+
+            verb_value = (
+                invoke_value.action.verb if invoke_value.action is not None else None
+            )
+            return self._matches(verb, verb_value)
+
+        def register(func: Callable) -> Callable:
+            async def handler(context: TurnContext, state: TurnState) -> None:
+                invoke_value, response = self._validate_action_execute_value(context)
+
+                if invoke_value is not None:
+                    response = await func(context, state, invoke_value.action.data)
+
+                response = response or AdaptiveCardInvokeResponse(
+                    status_code=HTTPStatus.OK
+                )
+
+                await self._send_invoke_response(
+                    context, response, status_code=HTTPStatus.OK
+                )
+
+            kwargs.pop("is_invoke", None)
+            self._app.add_route(
+                selector,
+                handler,
+                is_invoke=True,
+                auth_handlers=auth_handlers,
+                **kwargs,
+            )
+            return func
+
+        return register
+
+    def action_submit(
+        self,
+        verb: str | Pattern[str],
+        *,
+        auth_handlers: list[str] | None = None,
+        submit_filter: str = "verb",
+        **kwargs,
+    ) -> Callable[[ActionSubmitHandler], ActionSubmitHandler]:
+        """Register an Adaptive Card ``Action.Submit`` handler."""
+
+        def selector(context: TurnContext) -> bool:
+            activity = context.activity
+            if (
+                activity.type != ActivityTypes.message
+                or activity.text
+                or activity.value is None
+            ):
+                return False
+
+            verb_value = None
+            if isinstance(activity.value, dict):
+                verb_value = activity.value.get(submit_filter)
+            return self._matches(verb, verb_value)
+
+        def register(func: ActionSubmitHandler) -> ActionSubmitHandler:
+            async def handler(context: TurnContext, state: TurnState) -> None:
+                await func(context, state, context.activity.value)
+
+            self._app.add_route(
+                selector,
+                handler,
+                is_invoke=False,
+                auth_handlers=auth_handlers,
+                **kwargs,
+            )
+            return func
+
+        return register
+
+    def search(
+        self,
+        dataset: str | Pattern[str],
+        *,
+        auth_handlers: list[str] | None = None,
+        **kwargs,
+    ) -> Callable[[SearchHandler], SearchHandler]:
+        """Register an Adaptive Card dynamic-search handler."""
+
+        def selector(context: TurnContext) -> bool:
+            activity = context.activity
+            if (
+                activity.type != ActivityTypes.invoke
+                or activity.name != _SEARCH_INVOKE_NAME
+            ):
+                return False
+
+            try:
+                invoke_value = AdaptiveCardSearchInvokeValue.model_validate(
+                    activity.value
+                )
+            except pydantic.ValidationError:
+                return False
+
+            return self._matches(dataset, invoke_value.dataset)
+
+        def register(func: SearchHandler) -> SearchHandler:
+            async def handler(context: TurnContext, state: TurnState) -> None:
+                value, response = self._validate_search_value(context)
+                if value is not None:
+                    options = value.query_options
+                    query = Query(
+                        count=options.top,
+                        skip=options.skip,
+                        parameters=AdaptiveCardSearchParams(
+                            query_text=value.query_text,
+                            dataset=value.dataset or "",
+                        ),
+                    )
+                    results = await func(context, state, query)
+                    response = factory.search_response(
+                        {"results": [asdict(result) for result in results]}
+                    )
+
+                await self._send_invoke_response(
+                    context, response, response.status_code or HTTPStatus.OK
+                )
+
+            kwargs.pop("is_invoke", None)
+            self._app.add_route(
+                selector,
+                handler,
+                is_invoke=True,
+                auth_handlers=auth_handlers,
+                **kwargs,
+            )
+            return func
+
+        return register
+
+    def _validate_action_execute_value(
+        self, context: TurnContext
+    ) -> tuple[AdaptiveCardInvokeValue | None, AdaptiveCardInvokeResponse]:
+        if context.activity.value is None:
+            return None, factory.bad_request("Missing value property for Invoke Action")
+
+        try:
+            value = AdaptiveCardInvokeValue.model_validate(context.activity.value)
+        except pydantic.ValidationError:
+            return None, factory.bad_request(
+                "Value property is not a properly formed Invoke Action"
+            )
+
+        if value.action is None:
+            return None, factory.bad_request("Missing action property")
+        if value.action.type != _ACTION_EXECUTE_TYPE:
+            return None, factory.not_supported(
+                f"The Invoke Action '{value.action.type}' was not expected."
+            )
+
+        return value, AdaptiveCardInvokeResponse()
+
+    def _validate_search_value(
+        self, context: TurnContext
+    ) -> tuple[AdaptiveCardSearchInvokeValue | None, AdaptiveCardInvokeResponse]:
+        value = context.activity.value
+        if value is None:
+            return None, factory.bad_request("Missing value property for search")
+
+        try:
+            search_invoke_value = AdaptiveCardSearchInvokeValue.model_validate(value)
+        except pydantic.ValidationError:
+            return None, factory.bad_request(
+                "Value property is not a properly formed search invoke value"
+            )
+
+        missing = []
+        if not search_invoke_value.kind:
+            if ChannelId.get_channel(context.activity.channel_id) == Channels.ms_teams:
+                search_invoke_value.kind = "search"
+            else:
+                missing.append("kind")
+
+        if not search_invoke_value.query_text:
+            missing.append("queryText")
+
+        if missing:
+            return None, factory.bad_request(
+                f"Missing '{', '.join(missing)}' property for search"
+            )
+        return search_invoke_value, AdaptiveCardInvokeResponse()
+
+    @staticmethod
+    def _matches(selector: str | Pattern[str], value: object) -> bool:
+        if not isinstance(value, str):
+            return False
+        if isinstance(selector, str):
+            return selector == value
+        return selector.search(value) is not None
+
+    @staticmethod
+    async def _send_invoke_response(
+        context: TurnContext,
+        body: AdaptiveCardInvokeResponse,
+        status_code: int | HTTPStatus = HTTPStatus.OK,
+    ) -> None:
+        await context.send_activity(
+            Activity(
+                type=ActivityTypes.invoke_response,
+                value=InvokeResponse(
+                    status=int(status_code),
+                    body=body.model_dump(mode="json", by_alias=True, exclude_none=True),
+                ),
+            )
+        )

microsoft_agents_hosting_core-1.4.0.dev18/microsoft_agents/hosting/core/app/adaptive_card/factory.py

@@ -0,0 +1,99 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+from http import HTTPStatus
+
+from microsoft_agents.activity import (
+    AdaptiveCardInvokeResponse,
+    ContentTypes,
+    OAuthCard,
+)
+
+
+def adaptive_card(adaptive_card_json: str) -> AdaptiveCardInvokeResponse:
+    return AdaptiveCardInvokeResponse(
+        status_code=HTTPStatus.OK,
+        type=ContentTypes.adaptive_card,
+        value=adaptive_card_json,
+    )
+
+
+def search_response(result: dict | str) -> AdaptiveCardInvokeResponse:
+    return AdaptiveCardInvokeResponse(
+        status_code=HTTPStatus.OK,
+        type=ContentTypes.search_response,
+        value=result,
+    )
+
+
+def message(msg: str) -> AdaptiveCardInvokeResponse:
+    return AdaptiveCardInvokeResponse(
+        status_code=HTTPStatus.OK,
+        type=ContentTypes.message,
+        value=msg,
+    )
+
+
+def login(card: OAuthCard) -> AdaptiveCardInvokeResponse:
+    return AdaptiveCardInvokeResponse(
+        status_code=HTTPStatus.UNAUTHORIZED,
+        type=ContentTypes.login_request,
+        value=card,
+    )
+
+
+def incorrect_auth_code() -> AdaptiveCardInvokeResponse:
+    return AdaptiveCardInvokeResponse(
+        status_code=HTTPStatus.UNAUTHORIZED,
+        type=ContentTypes.incorrect_auth_code,
+    )
+
+
+def precondition_failed(
+    message: str, code: str | None = None
+) -> AdaptiveCardInvokeResponse:
+    return AdaptiveCardInvokeResponse(
+        status_code=HTTPStatus.PRECONDITION_FAILED,
+        type=ContentTypes.precondition_failed,
+        value={
+            "message": message,
+            "code": code or str(HTTPStatus.PRECONDITION_FAILED),
+        },
+    )
+
+
+def error(
+    status_code: int, message: str, code: str | None = None
+) -> AdaptiveCardInvokeResponse:
+    return AdaptiveCardInvokeResponse(
+        status_code=status_code,
+        type=ContentTypes.error,
+        value={
+            "code": code or str(status_code),
+            "message": message,
+        },
+    )
+
+
+def bad_request(message: str) -> AdaptiveCardInvokeResponse:
+    return error(
+        HTTPStatus.BAD_REQUEST,
+        message,
+        "BadRequest",
+    )
+
+
+def not_supported(message: str) -> AdaptiveCardInvokeResponse:
+    return error(
+        HTTPStatus.NOT_IMPLEMENTED,
+        message,
+        "NotSupported",
+    )
+
+
+def internal_error(message: str) -> AdaptiveCardInvokeResponse:
+    return error(
+        HTTPStatus.INTERNAL_SERVER_ERROR,
+        message,
+        "InternalError",
+    )

microsoft_agents_hosting_core-1.4.0.dev18/microsoft_agents/hosting/core/app/adaptive_card/models.py

@@ -0,0 +1,29 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+from dataclasses import dataclass
+from typing import Generic, TypeVar
+
+ParamsT = TypeVar("ParamsT")
+
+
+@dataclass
+class AdaptiveCardSearchParams:
+
+    query_text: str
+    dataset: str
+
+
+@dataclass
+class AdaptiveCardSearchResult:
+
+    title: str
+    value: str
+
+
+@dataclass
+class Query(Generic[ParamsT]):
+
+    count: int
+    skip: int
+    parameters: ParamsT

{microsoft_agents_hosting_core-1.4.0.dev13 → microsoft_agents_hosting_core-1.4.0.dev18}/microsoft_agents/hosting/core/app/agent_application.py

@@ -21,6 +21,7 @@ from typing import (
     TypeVar,
     cast,
     overload,
+    Optional,
 )
 
 from microsoft_agents.activity import (
@@ -53,6 +54,7 @@ from ._type_defs import (
 )
 from ._routes import _RouteList, _Route, RouteRank, _agentic_selector
 from .proactive import Proactive
+from .adaptive_card import AdaptiveCard
 
 logger = logging.getLogger(__name__)
 
@@ -76,6 +78,7 @@ class AgentApplication(Agent, Generic[StateT]):
 
     _options: ApplicationOptions
     _adapter: ChannelServiceAdapter | None = None
+    _adaptive_card: AdaptiveCard
     _auth: Authorization
     _proactive: Proactive | None = None
     _internal_before_turn: list[Callable[[TurnContext, StateT], Awaitable[bool]]]
@@ -105,6 +108,7 @@ class AgentApplication(Agent, Generic[StateT]):
         :param kwargs: Additional configuration parameters.
         :type kwargs: Any
         """
+        self._adaptive_card = AdaptiveCard(self)
         self._route_list = _RouteList[StateT]()
         self._internal_before_turn = []
         self._internal_after_turn = []
@@ -236,6 +240,16 @@ class AgentApplication(Agent, Generic[StateT]):
 
         return self._adapter
 
+    @property
+    def adaptive_card(self) -> AdaptiveCard:
+        """
+        The application's Adaptive Card manager.
+
+        :return: The Adaptive Card manager for the application.
+        :rtype: :class:`microsoft_agents.hosting.core.app.adaptive_card.AdaptiveCard`
+        """
+        return self._adaptive_card
+
     @property
     def auth(self) -> Authorization:
         """

{microsoft_agents_hosting_core-1.4.0.dev13 → microsoft_agents_hosting_core-1.4.0.dev18/microsoft_agents_hosting_core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microsoft-agents-hosting-core
-Version: 1.4.0.dev13
+Version: 1.4.0.dev18
 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.4.0.dev13
+Requires-Dist: microsoft-agents-activity==1.4.0.dev18
 Requires-Dist: pyjwt>=2.10.1
 Requires-Dist: isodate>=0.6.1
 Requires-Dist: python-dotenv>=1.1.1

{microsoft_agents_hosting_core-1.4.0.dev13 → microsoft_agents_hosting_core-1.4.0.dev18}/microsoft_agents_hosting_core.egg-info/SOURCES.txt

@@ -35,6 +35,11 @@ microsoft_agents/hosting/core/app/_routes/__init__.py
 microsoft_agents/hosting/core/app/_routes/_route.py
 microsoft_agents/hosting/core/app/_routes/_route_list.py
 microsoft_agents/hosting/core/app/_routes/route_rank.py
+microsoft_agents/hosting/core/app/adaptive_card/__init__.py
+microsoft_agents/hosting/core/app/adaptive_card/_type_defs.py
+microsoft_agents/hosting/core/app/adaptive_card/adaptive_card.py
+microsoft_agents/hosting/core/app/adaptive_card/factory.py
+microsoft_agents/hosting/core/app/adaptive_card/models.py
 microsoft_agents/hosting/core/app/oauth/__init__.py
 microsoft_agents/hosting/core/app/oauth/_sign_in_response.py
 microsoft_agents/hosting/core/app/oauth/_sign_in_state.py

{microsoft_agents_hosting_core-1.4.0.dev13 → microsoft_agents_hosting_core-1.4.0.dev18}/microsoft_agents_hosting_core.egg-info/requires.txt

@@ -1,4 +1,4 @@
-microsoft-agents-activity==1.4.0.dev13
+microsoft-agents-activity==1.4.0.dev18
 pyjwt>=2.10.1
 isodate>=0.6.1
 python-dotenv>=1.1.1

microsoft_agents_hosting_core-1.4.0.dev13/VERSION.txt

@@ -1 +0,0 @@
-1.4.0.dev13