[agentserver] core: make TaskRun awaitable (return .result())

Adds TaskRun.__await__ so callers can write:

    run = await my_task.start(task_id=..., input=...)
    ...
    result = await run

as shorthand for the existing:

    result = await run.result()

This is the natural Pythonic shape for handle-style awaitables and
removes a pyright complaint when users naively do 'await run' on a
TaskRun handle.

Both APIs continue to work: .__await__ delegates to .result().

Test: tests/durable/test_lifecycle.py::test_task_run_is_awaitable
verifies both 'await run' and 'await run.result()' return equivalent
TaskResults.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: RaviPidaparthi

sdk/agentserver/azure-ai-agentserver-core/azure/ai/agentserver/core/durable/_run.py

@@ -243,3 +243,23 @@ async def __anext__(self) -> Any:
         if self._stream_handler is None:
             raise StopAsyncIteration
         return await self._stream_handler.get()
+
+    def __await__(self) -> Any:
+        """Awaiting a :class:`TaskRun` returns its :meth:`result`.
+
+        Lets callers write ``result = await run`` as shorthand for
+        ``result = await run.result()``. Useful when you already have
+        a ``TaskRun`` handle (e.g. from :meth:`Task.start` or
+        :meth:`Task.get_active_run`) and just want the terminal
+        outcome.
+
+        Usage::
+
+            run = await my_task.start(task_id="t1", input=...)
+            ...
+            result = await run
+
+        :return: The :class:`TaskResult` for this run.
+        :rtype: TaskResult[Output]
+        """
+        return self.result().__await__()

sdk/agentserver/azure-ai-agentserver-core/tests/durable/test_lifecycle.py

@@ -290,6 +290,28 @@ async def my_task(ctx: TaskContext[str]) -> str:
         finally:
             await self._teardown_manager(manager, mgr_mod)
 
+    @pytest.mark.asyncio
+    async def test_task_run_is_awaitable(self, tmp_path) -> None:
+        """``await task_run`` returns the same TaskResult as ``await task_run.result()``."""
+
+        @task(title="awaitable")
+        async def my_task(ctx: TaskContext[str]) -> str:
+            return f"echo: {ctx.input}"
+
+        manager, mgr_mod = await self._setup_manager(tmp_path)
+        try:
+            # Direct-await the TaskRun handle.
+            handle = await my_task.start(task_id="awaitable-1", input="hello")
+            result = await handle  # ← exercising __await__
+            assert result.output == "echo: hello"
+
+            # And confirm the explicit .result() path still works identically.
+            handle2 = await my_task.start(task_id="awaitable-2", input="world")
+            result_via_method = await handle2.result()
+            assert result_via_method.output == "echo: world"
+        finally:
+            await self._teardown_manager(manager, mgr_mod)
+
     @pytest.mark.asyncio
     async def test_stale_timeout_kwarg_removed_spec_016(self, tmp_path) -> None:
         """Spec 016 FR-001 / US1: stale_timeout removed from developer surface.