Merge feature branch into this

Author: larohra

python/packages/azurefunctions/tests/test_app.py

@@ -650,6 +650,7 @@ def test_entity_function_handles_exception(self) -> None:
 
         mock_context = Mock()
         mock_context.operation_name = "run"
+        mock_context.operation_name = "run"
         mock_context.get_input.side_effect = Exception("Input error")
         mock_context.get_state.return_value = None
 

python/packages/durabletask/agent_framework_durabletask/_durable_agent_state.py

@@ -30,9 +30,10 @@
 from __future__ import annotations
 
 import json
+from collections.abc import MutableMapping
 from datetime import datetime, timezone
 from enum import Enum
-from typing import Any, cast
+from typing import Any, ClassVar, cast
 
 from agent_framework import (
     AgentResponse,
@@ -261,7 +262,7 @@ def to_ai_content(self) -> Any:
         """Convert this durable state content back to an agent framework content object.
 
         Returns:
-            An agent framework content object (TextContent, FunctionCallContent, etc.)
+            An agent framework content object (Content of type `text`, `function_call`, etc.)
 
         Raises:
             NotImplementedError: Must be implemented by subclasses
@@ -272,38 +273,42 @@ def to_ai_content(self) -> Any:
     def from_ai_content(content: Any) -> DurableAgentStateContent:
         """Create a durable state content object from an agent framework content object.
 
-        This factory method maps agent framework content types (TextContent, FunctionCallContent,
-        etc.) to their corresponding durable state representations. Unknown content types are
-        wrapped in DurableAgentStateUnknownContent.
+        This factory method maps agent framework content types to their corresponding durable state representations.
+        Unknown content types are wrapped in DurableAgentStateUnknownContent.
 
         Args:
-            content: An agent framework content object (TextContent, FunctionCallContent, etc.)
+            content: An agent framework content object (Content of type `text`, `function_call`, etc.)
 
         Returns:
             The corresponding DurableAgentStateContent subclass instance
         """
         # Map AI content type to appropriate DurableAgentStateContent subclass
-        if isinstance(content, Content) and content.type == "data":
-            return DurableAgentStateDataContent.from_data_content(content)
-        if isinstance(content, Content) and content.type == "error":
-            return DurableAgentStateErrorContent.from_error_content(content)
-        if isinstance(content, Content) and content.type == "function_call":
-            return DurableAgentStateFunctionCallContent.from_function_call_content(content)
-        if isinstance(content, Content) and content.type == "function_result":
-            return DurableAgentStateFunctionResultContent.from_function_result_content(content)
-        if isinstance(content, Content) and content.type == "hosted_file":
-            return DurableAgentStateHostedFileContent.from_hosted_file_content(content)
-        if isinstance(content, Content) and content.type == "hosted_vector_store":
-            return DurableAgentStateHostedVectorStoreContent.from_hosted_vector_store_content(content)
-        if isinstance(content, Content) and content.type == "text":
-            return DurableAgentStateTextContent.from_text_content(content)
-        if isinstance(content, Content) and content.type == "text_reasoning":
-            return DurableAgentStateTextReasoningContent.from_text_reasoning_content(content)
-        if isinstance(content, Content) and content.type == "uri":
-            return DurableAgentStateUriContent.from_uri_content(content)
-        if isinstance(content, Content) and content.type == "usage":
-            return DurableAgentStateUsageContent.from_usage_content(content)
-        return DurableAgentStateUnknownContent.from_unknown_content(content)
+        if not isinstance(content, Content):
+            return DurableAgentStateUnknownContent.from_unknown_content(content)
+
+        match content.type:
+            case "data":
+                return DurableAgentStateDataContent.from_data_content(content)
+            case "error":
+                return DurableAgentStateErrorContent.from_error_content(content)
+            case "function_call":
+                return DurableAgentStateFunctionCallContent.from_function_call_content(content)
+            case "function_result":
+                return DurableAgentStateFunctionResultContent.from_function_result_content(content)
+            case "hosted_file":
+                return DurableAgentStateHostedFileContent.from_hosted_file_content(content)
+            case "hosted_vector_store":
+                return DurableAgentStateHostedVectorStoreContent.from_hosted_vector_store_content(content)
+            case "text":
+                return DurableAgentStateTextContent.from_text_content(content)
+            case "reasoning":
+                return DurableAgentStateTextReasoningContent.from_text_reasoning_content(content)
+            case "uri":
+                return DurableAgentStateUriContent.from_uri_content(content)
+            case "usage":
+                return DurableAgentStateUsageContent.from_usage_content(content)
+            case _:
+                return DurableAgentStateUnknownContent.from_unknown_content(content)
 
 
 # Core state classes
@@ -871,7 +876,9 @@ def to_dict(self) -> dict[str, Any]:
 
     @staticmethod
     def from_data_content(content: Content) -> DurableAgentStateDataContent:
-        return DurableAgentStateDataContent(uri=content.uri, media_type=content.media_type)  # type: ignore[arg-type]
+        if content.uri is None:
+            raise ValueError("uri is required for data content")
+        return DurableAgentStateDataContent(uri=content.uri, media_type=content.media_type)
 
     def to_ai_content(self) -> Content:
         return Content.from_uri(uri=self.uri, media_type=self.media_type)
@@ -952,6 +959,10 @@ def to_dict(self) -> dict[str, Any]:
 
     @staticmethod
     def from_function_call_content(content: Content) -> DurableAgentStateFunctionCallContent:
+        if content.call_id is None:
+            raise ValueError("call_id is required for function call content")
+        if content.name is None:
+            raise ValueError("name is required for function call content")
         # Ensure arguments is a dict; parse string if needed
         arguments: dict[str, Any] = {}
         if content.arguments:
@@ -1000,7 +1011,9 @@ def to_dict(self) -> dict[str, Any]:
 
     @staticmethod
     def from_function_result_content(content: Content) -> DurableAgentStateFunctionResultContent:
-        return DurableAgentStateFunctionResultContent(call_id=content.call_id, result=content.result)  # type: ignore[arg-type]
+        if content.call_id is None:
+            raise ValueError("call_id is required for function result content")
+        return DurableAgentStateFunctionResultContent(call_id=content.call_id, result=content.result)
 
     def to_ai_content(self) -> Content:
         return Content.from_function_result(call_id=self.call_id, result=self.result)
@@ -1028,7 +1041,9 @@ def to_dict(self) -> dict[str, Any]:
 
     @staticmethod
     def from_hosted_file_content(content: Content) -> DurableAgentStateHostedFileContent:
-        return DurableAgentStateHostedFileContent(file_id=content.file_id)  # type: ignore[arg-type]
+        if content.file_id is None:
+            raise ValueError("file_id is required for hosted file content")
+        return DurableAgentStateHostedFileContent(file_id=content.file_id)
 
     def to_ai_content(self) -> Content:
         return Content.from_hosted_file(file_id=self.file_id)
@@ -1062,7 +1077,9 @@ def to_dict(self) -> dict[str, Any]:
     def from_hosted_vector_store_content(
         content: Content,
     ) -> DurableAgentStateHostedVectorStoreContent:
-        return DurableAgentStateHostedVectorStoreContent(vector_store_id=content.vector_store_id)  # type: ignore[arg-type]
+        if content.vector_store_id is None:
+            raise ValueError("vector_store_id is required for hosted vector store content")
+        return DurableAgentStateHostedVectorStoreContent(vector_store_id=content.vector_store_id)
 
     def to_ai_content(self) -> Content:
         return Content.from_hosted_vector_store(vector_store_id=self.vector_store_id)
@@ -1149,7 +1166,11 @@ def to_dict(self) -> dict[str, Any]:
 
     @staticmethod
     def from_uri_content(content: Content) -> DurableAgentStateUriContent:
-        return DurableAgentStateUriContent(uri=content.uri, media_type=content.media_type)  # type: ignore[arg-type]
+        if content.uri is None:
+            raise ValueError("uri is required for uri content")
+        if content.media_type is None:
+            raise ValueError("media_type is required for uri content")
+        return DurableAgentStateUriContent(uri=content.uri, media_type=content.media_type)
 
     def to_ai_content(self) -> Content:
         return Content.from_uri(uri=self.uri, media_type=self.media_type)
@@ -1169,6 +1190,14 @@ class DurableAgentStateUsage:
         extensionData: Optional additional metadata
     """
 
+    # UsageDetails field name constants (snake_case keys from agent_framework.UsageDetails)
+    _INPUT_TOKEN_COUNT = "input_token_count"  # noqa: S105  # nosec B105
+    _OUTPUT_TOKEN_COUNT = "output_token_count"  # noqa: S105  # nosec B105
+    _TOTAL_TOKEN_COUNT = "total_token_count"  # noqa: S105  # nosec B105
+
+    # Standard fields in UsageDetails that are mapped to dedicated attributes
+    _STANDARD_USAGE_FIELDS: ClassVar[set[str]] = {_INPUT_TOKEN_COUNT, _OUTPUT_TOKEN_COUNT, _TOTAL_TOKEN_COUNT}
+
     input_token_count: int | None = None
     output_token_count: int | None = None
     total_token_count: int | None = None
@@ -1206,22 +1235,31 @@ def from_dict(cls, data: dict[str, Any]) -> DurableAgentStateUsage:
         )
 
     @staticmethod
-    def from_usage(usage: UsageDetails | dict[str, int] | None) -> DurableAgentStateUsage | None:
+    def from_usage(usage: UsageDetails | MutableMapping[str, int] | None) -> DurableAgentStateUsage | None:
         if usage is None:
             return None
+
+        # Collect all non-standard fields into extension_data
+        extension_data: dict[str, Any] = {
+            k: v for k, v in usage.items() if k not in DurableAgentStateUsage._STANDARD_USAGE_FIELDS
+        }
+
         return DurableAgentStateUsage(
-            input_token_count=usage.get("input_token_count"),
-            output_token_count=usage.get("output_token_count"),
-            total_token_count=usage.get("total_token_count"),
+            input_token_count=usage.get(DurableAgentStateUsage._INPUT_TOKEN_COUNT),
+            output_token_count=usage.get(DurableAgentStateUsage._OUTPUT_TOKEN_COUNT),
+            total_token_count=usage.get(DurableAgentStateUsage._TOTAL_TOKEN_COUNT),
+            extensionData=extension_data if extension_data else None,
         )
 
     def to_usage_details(self) -> UsageDetails:
         # Convert back to AI SDK UsageDetails
-        return {
-            "input_token_count": self.input_token_count,
-            "output_token_count": self.output_token_count,
-            "total_token_count": self.total_token_count,
-        }
+
+        return UsageDetails(
+            input_token_count=self.input_token_count,
+            output_token_count=self.output_token_count,
+            total_token_count=self.total_token_count,
+            **self.extensionData if self.extensionData else {},
+        )
 
 
 class DurableAgentStateUsageContent(DurableAgentStateContent):

python/packages/durabletask/agent_framework_durabletask/_entities.py

@@ -13,7 +13,7 @@
     AgentResponse,
     AgentResponseUpdate,
     ChatMessage,
-    ErrorContent,
+    Content,
     Role,
     get_logger,
 )
@@ -176,7 +176,7 @@ async def run(
             logger.exception("[AgentEntity.run] Agent execution failed.")
 
             error_message = ChatMessage(
-                role=Role.ASSISTANT, contents=[ErrorContent(message=str(exc), error_code=type(exc).__name__)]
+                role=Role.ASSISTANT, contents=[Content.from_error(message=str(exc), error_code=type(exc).__name__)]
             )
             error_response = AgentResponse(messages=[error_message])
 

python/packages/durabletask/agent_framework_durabletask/_executors.py

@@ -16,7 +16,7 @@
 from datetime import datetime, timezone
 from typing import Any, Generic, TypeVar
 
-from agent_framework import AgentResponse, AgentThread, ChatMessage, ErrorContent, Role, TextContent, get_logger
+from agent_framework import AgentResponse, AgentThread, ChatMessage, Content, Role, get_logger
 from durabletask.client import TaskHubGrpcClient
 from durabletask.entities import EntityInstanceId
 from durabletask.task import CompletableTask, CompositeTask, OrchestrationContext, Task
@@ -182,7 +182,7 @@ def _create_acceptance_response(self, correlation_id: str) -> AgentResponse:
         acceptance_message = ChatMessage(
             role=Role.SYSTEM,
             contents=[
-                TextContent(
+                Content.from_text(
                     f"Request accepted for processing (correlation_id: {correlation_id}). "
                     f"Agent is executing in the background. "
                     f"Retrieve response via your configured streaming or callback mechanism."
@@ -362,7 +362,7 @@ def _handle_agent_response(
                 error_message = ChatMessage(
                     role=Role.SYSTEM,
                     contents=[
-                        ErrorContent(
+                        Content.from_error(
                             message=f"Error processing agent response: {e}",
                             error_code="response_processing_error",
                         )
@@ -377,7 +377,7 @@ def _handle_agent_response(
             error_message = ChatMessage(
                 role=Role.SYSTEM,
                 contents=[
-                    ErrorContent(
+                    Content.from_error(
                         message=f"Timeout waiting for agent response after {self.max_poll_retries} attempts",
                         error_code="response_timeout",
                     )

python/packages/durabletask/tests/integration_tests/test_02_dt_multi_agent.py

@@ -13,7 +13,6 @@
 from typing import Any
 
 import pytest
-from agent_framework import FunctionCallContent
 from dt_testutils import create_agent_client
 
 # Agent names from the 02_multi_agent sample
@@ -65,7 +64,7 @@ def test_weather_agent_with_tool(self):
 
         # Verify that the get_weather tool was actually invoked
         tool_calls = [
-            content for msg in response.messages for content in msg.contents if isinstance(content, FunctionCallContent)
+            content for msg in response.messages for content in msg.contents if content.type == "function_call"
         ]
         assert len(tool_calls) > 0, "Expected at least one tool call"
         assert any(call.name == "get_weather" for call in tool_calls), "Expected get_weather tool to be called"
@@ -84,7 +83,7 @@ def test_math_agent_with_tool(self):
 
         # Verify that the calculate_tip tool was actually invoked
         tool_calls = [
-            content for msg in response.messages for content in msg.contents if isinstance(content, FunctionCallContent)
+            content for msg in response.messages for content in msg.contents if content.type == "function_call"
         ]
         assert len(tool_calls) > 0, "Expected at least one tool call"
         assert any(call.name == "calculate_tip" for call in tool_calls), "Expected calculate_tip tool to be called"

python/packages/durabletask/tests/test_durable_entities.py

@@ -11,7 +11,7 @@
 from unittest.mock import AsyncMock, Mock
 
 import pytest
-from agent_framework import AgentResponse, AgentResponseUpdate, ChatMessage, ErrorContent, Role
+from agent_framework import AgentResponse, AgentResponseUpdate, ChatMessage, Content, Role
 from pydantic import BaseModel
 
 from agent_framework_durabletask import (
@@ -456,7 +456,7 @@ async def test_run_agent_handles_agent_exception(self) -> None:
         assert isinstance(result, AgentResponse)
         assert len(result.messages) == 1
         content = result.messages[0].contents[0]
-        assert isinstance(content, ErrorContent)
+        assert isinstance(content, Content)
         assert "Agent failed" in (content.message or "")
         assert content.error_code == "Exception"
 
@@ -472,7 +472,7 @@ async def test_run_agent_handles_value_error(self) -> None:
         assert isinstance(result, AgentResponse)
         assert len(result.messages) == 1
         content = result.messages[0].contents[0]
-        assert isinstance(content, ErrorContent)
+        assert isinstance(content, Content)
         assert content.error_code == "ValueError"
         assert "Invalid input" in str(content.message)
 
@@ -488,7 +488,7 @@ async def test_run_agent_handles_timeout_error(self) -> None:
         assert isinstance(result, AgentResponse)
         assert len(result.messages) == 1
         content = result.messages[0].contents[0]
-        assert isinstance(content, ErrorContent)
+        assert isinstance(content, Content)
         assert content.error_code == "TimeoutError"
 
     async def test_run_agent_preserves_message_on_error(self) -> None:
@@ -506,7 +506,7 @@ async def test_run_agent_preserves_message_on_error(self) -> None:
         assert isinstance(result, AgentResponse)
         assert len(result.messages) == 1
         content = result.messages[0].contents[0]
-        assert isinstance(content, ErrorContent)
+        assert isinstance(content, Content)
 
 
 class TestConversationHistory:

python/samples/README.md

@@ -253,6 +253,21 @@ The recommended way to use Ollama is via the native `OllamaChatClient` from the
 | [`getting_started/azure_functions/05_multi_agent_orchestration_concurrency/`](./getting_started/azure_functions/05_multi_agent_orchestration_concurrency/) | Run two agents concurrently within a durable orchestration and combine their domain-specific outputs. |
 | [`getting_started/azure_functions/06_multi_agent_orchestration_conditionals/`](./getting_started/azure_functions/06_multi_agent_orchestration_conditionals/) | Route orchestration logic based on structured agent responses for spam detection and reply drafting. |
 | [`getting_started/azure_functions/07_single_agent_orchestration_hitl/`](./getting_started/azure_functions/07_single_agent_orchestration_hitl/) | Implement a human-in-the-loop approval loop that iterates on agent output inside a durable orchestration. |
+| [`getting_started/azure_functions/08_mcp_server/`](./getting_started/azure_functions/08_mcp_server/) | Configure agents as both HTTP endpoints and MCP tools for flexible integration patterns. |
+
+## Durable Task
+
+These samples demonstrate durable agent hosting using the Durable Task Scheduler with a worker-client architecture pattern, enabling distributed agent execution with persistent conversation state.
+
+| Sample | Description |
+|--------|-------------|
+| [`getting_started/durabletask/01_single_agent/`](./getting_started/durabletask/01_single_agent/) | Host a single conversational agent with worker-client architecture and agent state management. |
+| [`getting_started/durabletask/02_multi_agent/`](./getting_started/durabletask/02_multi_agent/) | Host multiple domain-specific agents and route requests based on question topic. |
+| [`getting_started/durabletask/03_single_agent_streaming/`](./getting_started/durabletask/03_single_agent_streaming/) | Implement reliable streaming using Redis Streams with cursor-based resumption for durable agents. |
+| [`getting_started/durabletask/04_single_agent_orchestration_chaining/`](./getting_started/durabletask/04_single_agent_orchestration_chaining/) | Chain multiple agent invocations using durable orchestration while preserving conversation context. |
+| [`getting_started/durabletask/05_multi_agent_orchestration_concurrency/`](./getting_started/durabletask/05_multi_agent_orchestration_concurrency/) | Run multiple agents concurrently within an orchestration and aggregate their responses. |
+| [`getting_started/durabletask/06_multi_agent_orchestration_conditionals/`](./getting_started/durabletask/06_multi_agent_orchestration_conditionals/) | Implement conditional branching with spam detection using structured outputs and activity functions. |
+| [`getting_started/durabletask/07_single_agent_orchestration_hitl/`](./getting_started/durabletask/07_single_agent_orchestration_hitl/) | Human-in-the-loop pattern with external event handling, timeouts, and iterative refinement. |
 
 ## Observability