microsoft-agents-hosting-core 0.10.0.dev5__tar.gz → 0.10.0.dev7__tar.gz

{microsoft_agents_hosting_core-0.10.0.dev5/microsoft_agents_hosting_core.egg-info → microsoft_agents_hosting_core-0.10.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microsoft-agents-hosting-core
-Version: 0.10.0.dev5
+Version: 0.10.0.dev7
 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==0.10.0.dev5
+Requires-Dist: microsoft-agents-activity==0.10.0.dev7
 Requires-Dist: pyjwt>=2.10.1
 Requires-Dist: isodate>=0.6.1
 Requires-Dist: azure-core>=1.30.0

microsoft_agents_hosting_core-0.10.0.dev7/VERSION.txt

@@ -0,0 +1 @@
+0.10.0.dev7

{microsoft_agents_hosting_core-0.10.0.dev5 → microsoft_agents_hosting_core-0.10.0.dev7}/microsoft_agents/hosting/core/_oauth/_oauth_flow.py

@@ -187,7 +187,7 @@ class _OAuthFlow:
 
         token_exchange_state = TokenExchangeState(
             connection_name=self._abs_oauth_connection_name,
-            conversation=activity.get_conversation_reference(),
+            conversation=activity.get_conversation_reference(force_base_channel=True),
             relates_to=activity.relates_to,
             ms_app_id=self._ms_app_id,
         )
@@ -195,7 +195,7 @@ class _OAuthFlow:
         res = await self._user_token_client.user_token._get_token_or_sign_in_resource(
             activity.from_property.id,
             self._abs_oauth_connection_name,
-            activity.channel_id,
+            token_exchange_state.conversation.channel_id,
             token_exchange_state.get_encoded_state(),
         )
 

{microsoft_agents_hosting_core-0.10.0.dev5 → microsoft_agents_hosting_core-0.10.0.dev7}/microsoft_agents/hosting/core/app/__init__.py

@@ -11,7 +11,7 @@ from .app_options import ApplicationOptions
 from .input_file import InputFile, InputFileDownloader
 from .query import Query
 from ._routes import _RouteList, _Route, RouteRank
-from .typing_indicator import TypingIndicator
+from .typing_indicator import TypingChannelStrategy, TypingIndicator, TypingOptions
 from ._type_defs import RouteHandler, RouteSelector, StateT
 
 # Auth
@@ -46,7 +46,9 @@ __all__ = [
     "Query",
     "Route",
     "RouteHandler",
+    "TypingChannelStrategy",
     "TypingIndicator",
+    "TypingOptions",
     "StatePropertyAccessor",
     "ConversationState",
     "state",

{microsoft_agents_hosting_core-0.10.0.dev5 → microsoft_agents_hosting_core-0.10.0.dev7}/microsoft_agents/hosting/core/app/agent_application.py

@@ -5,6 +5,7 @@ Licensed under the MIT License.
 
 from __future__ import annotations
 import logging
+from contextlib import nullcontext
 from copy import copy
 from functools import partial
 
@@ -697,62 +698,69 @@ class AgentApplication(Agent, Generic[StateT]):
         await self._start_long_running_call(context, self._on_turn)
 
     async def _on_turn(self, context: TurnContext):
-        typing = None
         try:
             with spans.AppOnTurn(context) as on_turn_span:
-                if context.activity.type != ActivityTypes.typing:
-                    if self._options.start_typing_timer:
-                        typing = TypingIndicator(context)
-                        typing.start()
-
-                self._remove_mentions(context)
-
-                logger.debug("Initializing turn state")
-                turn_state = await self._initialize_state(context)
-                if (
-                    context.activity.type == ActivityTypes.message
-                    or context.activity.type == ActivityTypes.invoke
-                ):
+                use_typing = (
+                    self._options.start_typing_timer
+                    and context.activity.type != ActivityTypes.typing
+                )
+                typing_context = (
+                    TypingIndicator(
+                        context,
+                        typing_options=self._options.typing,
+                    )
+                    if use_typing
+                    else nullcontext()
+                )
 
-                    (
-                        auth_intercepts,
-                        continuation_activity,
-                    ) = await self._auth._on_turn_auth_intercept(context, turn_state)
-                    if auth_intercepts:
-                        if continuation_activity:
-                            new_context = copy(context)
-                            new_context.activity = continuation_activity
-                            logger.info(
-                                "Resending continuation activity %s",
-                                continuation_activity.text,
-                            )
-                            await self.on_turn(new_context)
-                            await turn_state.save(context)
+                async with typing_context:
+                    self._remove_mentions(context)
+
+                    logger.debug("Initializing turn state")
+                    turn_state = await self._initialize_state(context)
+                    if context.activity.type in [
+                        ActivityTypes.message,
+                        ActivityTypes.invoke,
+                    ]:
+
+                        (
+                            auth_intercepts,
+                            continuation_activity,
+                        ) = await self._auth._on_turn_auth_intercept(
+                            context, turn_state
+                        )
+                        if auth_intercepts:
+                            if continuation_activity:
+                                new_context = copy(context)
+                                new_context.activity = continuation_activity
+                                logger.info(
+                                    "Resending continuation activity %s",
+                                    continuation_activity.text,
+                                )
+                                await self.on_turn(new_context)
+                                await turn_state.save(context)
+                            return
+
+                    logger.debug("Running before turn middleware")
+                    if not await self._run_before_turn_middleware(context, turn_state):
                         return
 
-                logger.debug("Running before turn middleware")
-                if not await self._run_before_turn_middleware(context, turn_state):
-                    return
+                    logger.debug("Running file downloads")
+                    await self._handle_file_downloads(context, turn_state)
 
-                logger.debug("Running file downloads")
-                await self._handle_file_downloads(context, turn_state)
+                    logger.debug("Running activity handlers")
+                    await self._on_activity(context, turn_state, on_turn_span)
 
-                logger.debug("Running activity handlers")
-                await self._on_activity(context, turn_state, on_turn_span)
-
-                logger.debug("Running after turn middleware")
-                if await self._run_after_turn_middleware(context, turn_state):
-                    await turn_state.save(context)
-                return
+                    logger.debug("Running after turn middleware")
+                    if await self._run_after_turn_middleware(context, turn_state):
+                        await turn_state.save(context)
+                    return
         except ApplicationError as err:
             logger.error(
                 f"An application error occurred in the AgentApplication: {err}",
                 exc_info=True,
             )
             await self._on_error(context, err)
-        finally:
-            if typing:
-                typing.stop()
 
     def _remove_mentions(self, context: TurnContext):
         if (

{microsoft_agents_hosting_core-0.10.0.dev5 → microsoft_agents_hosting_core-0.10.0.dev7}/microsoft_agents/hosting/core/app/app_options.py

@@ -13,6 +13,7 @@ from microsoft_agents.hosting.core.app.oauth import AuthHandler
 from microsoft_agents.hosting.core.storage import Storage
 
 # from .auth import AuthOptions
+from .typing_indicator import TypingOptions
 from .input_file import InputFileDownloader
 from ..channel_service_adapter import ChannelServiceAdapter
 
@@ -62,6 +63,13 @@ class ApplicationOptions:
     the request. Defaults to true.
     """
 
+    typing: Optional[TypingOptions] = None
+    """
+    Optional. Typing indicator timing options. Controls initial delay, interval,
+    and per-channel strategies. If not provided, defaults are used when
+    ``start_typing_timer`` is true.
+    """
+
     long_running_messages: bool = False
     """
     Optional. If true, the bot supports long running messages that can take longer then the 10 - 15

microsoft_agents_hosting_core-0.10.0.dev7/microsoft_agents/hosting/core/app/typing_indicator.py

@@ -0,0 +1,243 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass, field
+from typing import Dict, Optional
+
+from microsoft_agents.hosting.core import TurnContext
+from microsoft_agents.activity import Activity, ActivityTypes, Channels, EntityTypes
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_INITIAL_DELAY_MS = 500
+DEFAULT_INTERVAL_MS = 10000
+
+
+@dataclass
+class TypingChannelStrategy:
+    """Per-channel timing parameters for the typing indicator.
+
+    :param initial_delay_ms: Delay in milliseconds before the first typing activity.
+    :param interval_ms: Interval in milliseconds between subsequent typing activities.
+    """
+
+    initial_delay_ms: int = DEFAULT_INITIAL_DELAY_MS
+    interval_ms: int = DEFAULT_INTERVAL_MS
+
+
+@dataclass
+class TypingOptions:
+    """Configuration options for the automatic typing indicator.
+
+    :param initial_delay_ms: Default delay in milliseconds before the first typing activity.
+    :param interval_ms: Default interval in milliseconds between subsequent typing activities.
+    :param channel_strategies: Optional per-channel timing overrides keyed by channel ID.
+    """
+
+    initial_delay_ms: int = DEFAULT_INITIAL_DELAY_MS
+    interval_ms: int = DEFAULT_INTERVAL_MS
+    channel_strategies: Dict[str, TypingChannelStrategy] = field(default_factory=dict)
+
+    def __post_init__(self):
+        # Apply default channel overrides (matching .NET's M365Copilot default)
+        if Channels.copilot_studio.value not in self.channel_strategies:
+            # make a copy to avoid mutating input
+            self.channel_strategies = dict(self.channel_strategies)
+            self.channel_strategies[Channels.copilot_studio.value] = (
+                TypingChannelStrategy(initial_delay_ms=250, interval_ms=1000)
+            )
+
+    def get_strategy_for_channel(self, channel: str) -> TypingChannelStrategy:
+        """Returns the timing strategy for the given channel, falling back to defaults."""
+        if channel in self.channel_strategies:
+            return self.channel_strategies[channel]
+        return TypingChannelStrategy(
+            initial_delay_ms=self.initial_delay_ms,
+            interval_ms=self.interval_ms,
+        )
+
+
+class TypingIndicator:
+    """
+    Encapsulates the logic for sending "typing" activity to the user.
+
+    Scoped to a single turn of conversation with the user.
+
+    Automatically stops when a message or streaming activity is about to be
+    sent on the same turn, preventing bare typing activities from overlapping
+    with real responses.
+
+    Can be used as an async context manager::
+
+        async with TypingIndicator(context, typing_options=opts) as typing:
+            # typing indicators are sent automatically
+            ...
+    """
+
+    def __init__(
+        self,
+        context: TurnContext,
+        interval_seconds: Optional[float] = None,
+        typing_options: Optional[TypingOptions] = None,
+    ) -> None:
+        """Initializes a new instance of the TypingIndicator class.
+
+        :param context: The turn context.
+        :param interval_seconds: Interval in seconds between typing indicators.
+            When set, overrides the interval from ``typing_options``.
+        :param typing_options: Typing timing options including per-channel
+            strategies. If not provided, defaults are used. An explicit
+            ``interval_seconds`` value takes precedence over the interval
+            in ``typing_options`` for backward compatibility.
+        """
+        options = typing_options or TypingOptions()
+
+        channel = (
+            context.activity.channel_id.channel if context.activity.channel_id else ""
+        ) or ""
+        strategy = options.get_strategy_for_channel(channel)
+
+        interval = (
+            interval_seconds
+            if interval_seconds is not None
+            else strategy.interval_ms / 1000.0
+        )
+        initial_delay = strategy.initial_delay_ms / 1000.0
+
+        if interval <= 0:
+            raise ValueError("interval must be greater than 0")
+
+        if initial_delay < 0:
+            raise ValueError("initial_delay must be greater than or equal to 0")
+
+        self._context: TurnContext = context
+        self._interval: float = interval
+        self._initial_delay: float = initial_delay
+        self._task: Optional[asyncio.Task[None]] = None
+        self._last_send: Optional[asyncio.Task[None]] = None
+        self._stopped: bool = False
+        self._hook_registered: bool = False
+
+    async def __aenter__(self) -> "TypingIndicator":
+        self.start()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        await self._stop_async()
+
+    async def _send_typing(self) -> None:
+        """Sends a single typing activity via the adapter, bypassing middleware."""
+        ref = self._context.activity.get_conversation_reference()
+        typing_activity = TurnContext.apply_conversation_reference(
+            Activity(type=ActivityTypes.typing), ref
+        )
+        await self._context.adapter.send_activities(self._context, [typing_activity])
+
+    async def _run(self) -> None:
+        """Sends typing indicators at regular intervals after an initial delay."""
+        try:
+            if self._initial_delay > 0:
+                await asyncio.sleep(self._initial_delay)
+
+            while not self._stopped:
+                send_task = asyncio.ensure_future(self._send_typing())
+                self._last_send = send_task
+                # Shield the send so task cancellation doesn't interrupt
+                # an in-flight adapter call.
+                try:
+                    await asyncio.shield(send_task)
+                except asyncio.CancelledError:
+                    # Task was cancelled while sending — wait for the send
+                    # to finish naturally, then exit the loop.
+                    break
+                await asyncio.sleep(self._interval)
+        except asyncio.CancelledError:
+            pass
+        except Exception:
+            logger.debug(
+                "Typing indicator send failed for conversation %s",
+                self._context.activity.conversation.id,
+                exc_info=True,
+            )
+
+    @staticmethod
+    def _has_streaminfo(activity: Activity) -> bool:
+        """Check if an activity contains a streaminfo entity."""
+        if not activity.entities:
+            return False
+        for entity in activity.entities:
+            entity_type = getattr(entity, "type", None)
+            if entity_type is None and isinstance(entity, dict):
+                entity_type = entity.get("type")
+            if entity_type == EntityTypes.STREAM_INFO.value:
+                return True
+        return False
+
+    def start(self) -> None:
+        """Starts sending typing indicators and registers a send-activity hook
+        that auto-stops the indicator when a real response is about to be sent."""
+
+        if self._task is not None:
+            logger.warning(
+                "Typing indicator is already running for conversation %s",
+                self._context.activity.conversation.id,
+            )
+            return
+
+        logger.debug(
+            "Starting typing indicator (initial_delay=%.1fs, interval=%.1fs) "
+            "for conversation %s",
+            self._initial_delay,
+            self._interval,
+            self._context.activity.conversation.id,
+        )
+
+        self._stopped = False
+        self._task = asyncio.create_task(self._run())
+
+        if not self._hook_registered:
+
+            async def _on_send_activities_handler(ctx, activities, next_handler):
+                should_stop = any(
+                    a.type == ActivityTypes.message or self._has_streaminfo(a)
+                    for a in activities
+                )
+                if should_stop:
+                    self._stop_loop()
+                return await next_handler()
+
+            self._context.on_send_activities(_on_send_activities_handler)
+            self._hook_registered = True
+
+    def _stop_loop(self) -> None:
+        """Cancels the background loop task. Does not await in-flight sends."""
+        if self._stopped:
+            return
+        self._stopped = True
+
+        if self._task is not None:
+            self._task.cancel()
+            self._task = None
+
+    def stop(self) -> None:
+        """Stops sending typing indicators synchronously."""
+        self._stop_loop()
+
+    async def _stop_async(self) -> None:
+        """Stops typing and waits for any in-flight send to finish."""
+        self._stop_loop()
+
+        # Wait for any in-flight typing send to finish so we don't
+        # interrupt an adapter call mid-flight.
+        if self._last_send and not self._last_send.done():
+            try:
+                await asyncio.shield(self._last_send)
+            except (asyncio.CancelledError, Exception):
+                pass
+        self._last_send = None

{microsoft_agents_hosting_core-0.10.0.dev5 → microsoft_agents_hosting_core-0.10.0.dev7/microsoft_agents_hosting_core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microsoft-agents-hosting-core
-Version: 0.10.0.dev5
+Version: 0.10.0.dev7
 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==0.10.0.dev5
+Requires-Dist: microsoft-agents-activity==0.10.0.dev7
 Requires-Dist: pyjwt>=2.10.1
 Requires-Dist: isodate>=0.6.1
 Requires-Dist: azure-core>=1.30.0

{microsoft_agents_hosting_core-0.10.0.dev5 → microsoft_agents_hosting_core-0.10.0.dev7}/microsoft_agents_hosting_core.egg-info/requires.txt

@@ -1,4 +1,4 @@
-microsoft-agents-activity==0.10.0.dev5
+microsoft-agents-activity==0.10.0.dev7
 pyjwt>=2.10.1
 isodate>=0.6.1
 azure-core>=1.30.0

microsoft_agents_hosting_core-0.10.0.dev5/VERSION.txt

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

microsoft_agents_hosting_core-0.10.0.dev5/microsoft_agents/hosting/core/app/typing_indicator.py

@@ -1,81 +0,0 @@
-"""
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the MIT License.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from typing import Optional
-
-from microsoft_agents.hosting.core import TurnContext
-from microsoft_agents.activity import Activity, ActivityTypes
-
-logger = logging.getLogger(__name__)
-
-
-class TypingIndicator:
-    """
-    Encapsulates the logic for sending "typing" activity to the user.
-
-    Scoped to a single turn of conversation with the user.
-    """
-
-    def __init__(self, context: TurnContext, interval_seconds: float = 10.0) -> None:
-        """Initializes a new instance of the TypingIndicator class.
-
-        :param context: The turn context.
-        :param interval_seconds: The interval in seconds between typing indicators.
-        """
-        if interval_seconds <= 0:
-            raise ValueError("interval_seconds must be greater than 0")
-        self._context: TurnContext = context
-        self._interval: float = interval_seconds
-        self._task: Optional[asyncio.Task[None]] = None
-
-    async def _run(self) -> None:
-        """Sends typing indicators at regular intervals."""
-
-        running_task = self._task
-        try:
-            while running_task is self._task:
-                await self._context.send_activity(Activity(type=ActivityTypes.typing))
-                await asyncio.sleep(self._interval)
-        except asyncio.CancelledError:
-            # Task was cancelled, exit gracefully
-            pass
-
-    def start(self) -> None:
-        """Starts sending typing indicators."""
-
-        if self._task is not None:
-            logger.warning(
-                "Typing indicator is already running for conversation %s",
-                self._context.activity.conversation.id,
-            )
-            return
-
-        logger.debug(
-            "Starting typing indicator with interval: %s seconds in conversation %s",
-            self._interval,
-            self._context.activity.conversation.id,
-        )
-        self._task = asyncio.create_task(self._run())
-
-    def stop(self) -> None:
-        """Stops sending typing indicators."""
-
-        if self._task is None:
-            logger.warning(
-                "Typing indicator is not running for conversation %s",
-                self._context.activity.conversation.id,
-            )
-            return
-
-        logger.debug(
-            "Stopping typing indicator for conversation %s",
-            self._context.activity.conversation.id,
-        )
-        self._task.cancel()
-        self._task = None