microsoft-agents-hosting-fastapi 0.7.0__py3-none-any.whl → 0.7.0.dev0__py3-none-any.whl

microsoft_agents/hosting/fastapi/__init__.py

@@ -5,9 +5,7 @@ from .cloud_adapter import CloudAdapter
 from .jwt_authorization_middleware import (
     JwtAuthorizationMiddleware,
 )
-
-# Import streaming utilities from core for backward compatibility
-from microsoft_agents.hosting.core.app.streaming import (
+from .app.streaming import (
     Citation,
     CitationUtil,
     StreamingResponse,

microsoft_agents/hosting/fastapi/channel_service_route_table.py

@@ -1,58 +1,64 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License.
+import json
+from typing import List, Union, Type
 
-from fastapi import APIRouter, Request, Response
+from fastapi import APIRouter, Request, Response, HTTPException, Depends
 from fastapi.responses import JSONResponse
 
+from microsoft_agents.activity import (
+    AgentsModel,
+    Activity,
+    AttachmentData,
+    ConversationParameters,
+    Transcript,
+)
 from microsoft_agents.hosting.core import ChannelApiHandlerProtocol
-from microsoft_agents.hosting.core.http import ChannelServiceRoutes
 
 
-class FastApiRequestAdapter:
-    """Adapter for FastAPI requests to use with ChannelServiceRoutes."""
+async def deserialize_from_body(
+    request: Request, target_model: Type[AgentsModel]
+) -> AgentsModel:
+    content_type = request.headers.get("Content-Type", "")
+    if "application/json" in content_type:
+        body = await request.json()
+    else:
+        raise HTTPException(status_code=415, detail="Unsupported Media Type")
 
-    def __init__(self, request: Request):
-        self._request = request
+    return target_model.model_validate(body)
 
-    @property
-    def method(self) -> str:
-        return self._request.method
 
-    @property
-    def headers(self):
-        return self._request.headers
-
-    async def json(self):
-        return await self._request.json()
-
-    def get_claims_identity(self):
-        return getattr(self._request.state, "claims_identity", None)
+def get_serialized_response(
+    model_or_list: Union[AgentsModel, List[AgentsModel]],
+) -> JSONResponse:
+    if isinstance(model_or_list, AgentsModel):
+        json_obj = model_or_list.model_dump(
+            mode="json", exclude_unset=True, by_alias=True
+        )
+    else:
+        json_obj = [
+            model.model_dump(mode="json", exclude_unset=True, by_alias=True)
+            for model in model_or_list
+        ]
 
-    def get_path_param(self, name: str) -> str:
-        return self._request.path_params.get(name, "")
+    return JSONResponse(content=json_obj)
 
 
 def channel_service_route_table(
     handler: ChannelApiHandlerProtocol, base_url: str = ""
 ) -> APIRouter:
-    """Create FastAPI router for Channel Service API.
-
-    Args:
-        handler: The handler that implements the Channel API protocol.
-        base_url: Optional base URL prefix for all routes.
-
-    Returns:
-        APIRouter with all channel service routes.
-    """
     router = APIRouter()
-    service_routes = ChannelServiceRoutes(handler, base_url)
 
     @router.post(base_url + "/v3/conversations/{conversation_id}/activities")
     async def send_to_conversation(conversation_id: str, request: Request):
-        result = await service_routes.send_to_conversation(
-            FastApiRequestAdapter(request)
+        activity = await deserialize_from_body(request, Activity)
+        result = await handler.on_send_to_conversation(
+            getattr(request.state, "claims_identity", None),
+            conversation_id,
+            activity,
         )
-        return JSONResponse(content=result)
+
+        return get_serialized_response(result)
 
     @router.post(
         base_url + "/v3/conversations/{conversation_id}/activities/{activity_id}"
@@ -60,21 +66,40 @@ def channel_service_route_table(
     async def reply_to_activity(
         conversation_id: str, activity_id: str, request: Request
     ):
-        result = await service_routes.reply_to_activity(FastApiRequestAdapter(request))
-        return JSONResponse(content=result)
+        activity = await deserialize_from_body(request, Activity)
+        result = await handler.on_reply_to_activity(
+            getattr(request.state, "claims_identity", None),
+            conversation_id,
+            activity_id,
+            activity,
+        )
+
+        return get_serialized_response(result)
 
     @router.put(
         base_url + "/v3/conversations/{conversation_id}/activities/{activity_id}"
     )
     async def update_activity(conversation_id: str, activity_id: str, request: Request):
-        result = await service_routes.update_activity(FastApiRequestAdapter(request))
-        return JSONResponse(content=result)
+        activity = await deserialize_from_body(request, Activity)
+        result = await handler.on_update_activity(
+            getattr(request.state, "claims_identity", None),
+            conversation_id,
+            activity_id,
+            activity,
+        )
+
+        return get_serialized_response(result)
 
     @router.delete(
         base_url + "/v3/conversations/{conversation_id}/activities/{activity_id}"
     )
     async def delete_activity(conversation_id: str, activity_id: str, request: Request):
-        await service_routes.delete_activity(FastApiRequestAdapter(request))
+        await handler.on_delete_activity(
+            getattr(request.state, "claims_identity", None),
+            conversation_id,
+            activity_id,
+        )
+
         return Response(status_code=200)
 
     @router.get(
@@ -84,65 +109,97 @@ def channel_service_route_table(
     async def get_activity_members(
         conversation_id: str, activity_id: str, request: Request
     ):
-        result = await service_routes.get_activity_members(
-            FastApiRequestAdapter(request)
+        result = await handler.on_get_activity_members(
+            getattr(request.state, "claims_identity", None),
+            conversation_id,
+            activity_id,
         )
-        return JSONResponse(content=result)
+
+        return get_serialized_response(result)
 
     @router.post(base_url + "/")
     async def create_conversation(request: Request):
-        result = await service_routes.create_conversation(
-            FastApiRequestAdapter(request)
+        conversation_parameters = await deserialize_from_body(
+            request, ConversationParameters
+        )
+        result = await handler.on_create_conversation(
+            getattr(request.state, "claims_identity", None), conversation_parameters
         )
-        return JSONResponse(content=result)
+
+        return get_serialized_response(result)
 
     @router.get(base_url + "/")
     async def get_conversation(request: Request):
-        result = await service_routes.get_conversations(FastApiRequestAdapter(request))
-        return JSONResponse(content=result)
+        # TODO: continuation token? conversation_id?
+        result = await handler.on_get_conversations(
+            getattr(request.state, "claims_identity", None), None
+        )
+
+        return get_serialized_response(result)
 
     @router.get(base_url + "/v3/conversations/{conversation_id}/members")
     async def get_conversation_members(conversation_id: str, request: Request):
-        result = await service_routes.get_conversation_members(
-            FastApiRequestAdapter(request)
+        result = await handler.on_get_conversation_members(
+            getattr(request.state, "claims_identity", None),
+            conversation_id,
         )
-        return JSONResponse(content=result)
+
+        return get_serialized_response(result)
 
     @router.get(base_url + "/v3/conversations/{conversation_id}/members/{member_id}")
     async def get_conversation_member(
         conversation_id: str, member_id: str, request: Request
     ):
-        result = await service_routes.get_conversation_member(
-            FastApiRequestAdapter(request)
+        result = await handler.on_get_conversation_member(
+            getattr(request.state, "claims_identity", None),
+            member_id,
+            conversation_id,
         )
-        return JSONResponse(content=result)
+
+        return get_serialized_response(result)
 
     @router.get(base_url + "/v3/conversations/{conversation_id}/pagedmembers")
     async def get_conversation_paged_members(conversation_id: str, request: Request):
-        result = await service_routes.get_conversation_paged_members(
-            FastApiRequestAdapter(request)
+        # TODO: continuation token? page size?
+        result = await handler.on_get_conversation_paged_members(
+            getattr(request.state, "claims_identity", None),
+            conversation_id,
         )
-        return JSONResponse(content=result)
+
+        return get_serialized_response(result)
 
     @router.delete(base_url + "/v3/conversations/{conversation_id}/members/{member_id}")
     async def delete_conversation_member(
         conversation_id: str, member_id: str, request: Request
     ):
-        result = await service_routes.delete_conversation_member(
-            FastApiRequestAdapter(request)
+        result = await handler.on_delete_conversation_member(
+            getattr(request.state, "claims_identity", None),
+            conversation_id,
+            member_id,
         )
-        return JSONResponse(content=result)
+
+        return get_serialized_response(result)
 
     @router.post(base_url + "/v3/conversations/{conversation_id}/activities/history")
     async def send_conversation_history(conversation_id: str, request: Request):
-        result = await service_routes.send_conversation_history(
-            FastApiRequestAdapter(request)
+        transcript = await deserialize_from_body(request, Transcript)
+        result = await handler.on_send_conversation_history(
+            getattr(request.state, "claims_identity", None),
+            conversation_id,
+            transcript,
         )
-        return JSONResponse(content=result)
+
+        return get_serialized_response(result)
 
     @router.post(base_url + "/v3/conversations/{conversation_id}/attachments")
     async def upload_attachment(conversation_id: str, request: Request):
-        result = await service_routes.upload_attachment(FastApiRequestAdapter(request))
-        return JSONResponse(content=result)
+        attachment_data = await deserialize_from_body(request, AttachmentData)
+        result = await handler.on_upload_attachment(
+            getattr(request.state, "claims_identity", None),
+            conversation_id,
+            attachment_data,
+        )
+
+        return get_serialized_response(result)
 
     return router

microsoft_agents/hosting/fastapi/cloud_adapter.py

@@ -1,48 +1,32 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License.
+from traceback import format_exc
 from typing import Optional
 
-from fastapi import Request, Response
+from fastapi import Request, Response, HTTPException
 from fastapi.responses import JSONResponse
-
-from microsoft_agents.hosting.core import Agent
-from microsoft_agents.hosting.core.authorization import Connections
-from microsoft_agents.hosting.core.http import (
-    HttpAdapterBase,
-    HttpResponse,
+from microsoft_agents.hosting.core import error_resources
+from microsoft_agents.hosting.core.authorization import (
+    ClaimsIdentity,
+    Connections,
+)
+from microsoft_agents.activity import (
+    Activity,
+    DeliveryModes,
+)
+from microsoft_agents.hosting.core import (
+    Agent,
+    ChannelServiceAdapter,
+    ChannelServiceClientFactoryBase,
+    MessageFactory,
+    RestChannelServiceClientFactory,
+    TurnContext,
 )
-from microsoft_agents.hosting.core import ChannelServiceClientFactoryBase
 
 from .agent_http_adapter import AgentHttpAdapter
 
 
-class FastApiRequestAdapter:
-    """Adapter to make FastAPI Request compatible with HttpRequestProtocol."""
-
-    def __init__(self, request: Request):
-        self._request = request
-
-    @property
-    def method(self) -> str:
-        return self._request.method
-
-    @property
-    def headers(self):
-        return self._request.headers
-
-    async def json(self):
-        return await self._request.json()
-
-    def get_claims_identity(self):
-        return getattr(self._request.state, "claims_identity", None)
-
-    def get_path_param(self, name: str) -> str:
-        return self._request.path_params.get(name, "")
-
-
-class CloudAdapter(HttpAdapterBase, AgentHttpAdapter):
-    """CloudAdapter for FastAPI web framework."""
-
+class CloudAdapter(ChannelServiceAdapter, AgentHttpAdapter):
     def __init__(
         self,
         *,
@@ -52,43 +36,78 @@ class CloudAdapter(HttpAdapterBase, AgentHttpAdapter):
         """
         Initializes a new instance of the CloudAdapter class.
 
-        :param connection_manager: Optional connection manager for OAuth.
         :param channel_service_client_factory: The factory to use to create the channel service client.
         """
-        super().__init__(
-            connection_manager=connection_manager,
-            channel_service_client_factory=channel_service_client_factory,
-        )
 
-    async def process(self, request: Request, agent: Agent) -> Optional[Response]:
-        """Process a FastAPI request.
+        async def on_turn_error(context: TurnContext, error: Exception):
+            error_message = f"Exception caught : {error}"
+            print(format_exc())
 
-        Args:
-            request: The FastAPI request.
-            agent: The agent to handle the request.
+            await context.send_activity(MessageFactory.text(error_message))
 
-        Returns:
-            FastAPI Response object.
-        """
-        # Adapt request to protocol
-        adapted_request = FastApiRequestAdapter(request)
-
-        # Process using base implementation
-        http_response: HttpResponse = await self.process_request(adapted_request, agent)
-
-        # Convert HttpResponse to FastAPI Response
-        return self._to_fastapi_response(http_response)
-
-    @staticmethod
-    def _to_fastapi_response(http_response: HttpResponse) -> Response:
-        """Convert HttpResponse to FastAPI Response."""
-        if http_response.body is not None:
-            return JSONResponse(
-                content=http_response.body,
-                status_code=http_response.status_code,
-                headers=http_response.headers,
+            # Send a trace activity
+            await context.send_trace_activity(
+                "OnTurnError Trace",
+                error_message,
+                "https://www.botframework.com/schemas/error",
+                "TurnError",
             )
-        return Response(
-            status_code=http_response.status_code,
-            headers=http_response.headers,
+
+        self.on_turn_error = on_turn_error
+
+        channel_service_client_factory = (
+            channel_service_client_factory
+            or RestChannelServiceClientFactory(connection_manager)
         )
+
+        super().__init__(channel_service_client_factory)
+
+    async def process(self, request: Request, agent: Agent) -> Optional[Response]:
+        if not request:
+            raise TypeError(str(error_resources.RequestRequired))
+        if not agent:
+            raise TypeError(str(error_resources.AgentRequired))
+
+        if request.method == "POST":
+            # Deserialize the incoming Activity
+            content_type = request.headers.get("Content-Type", "")
+            if "application/json" in content_type:
+                body = await request.json()
+            else:
+                raise HTTPException(status_code=415, detail="Unsupported Media Type")
+
+            activity: Activity = Activity.model_validate(body)
+
+            # default to anonymous identity with no claims
+            claims_identity: ClaimsIdentity = getattr(
+                request.state, "claims_identity", ClaimsIdentity({}, False)
+            )
+
+            # A POST request must contain an Activity
+            if (
+                not activity.type
+                or not activity.conversation
+                or not activity.conversation.id
+            ):
+                raise HTTPException(status_code=400, detail="Bad Request")
+
+            try:
+                # Process the inbound activity with the agent
+                invoke_response = await self.process_activity(
+                    claims_identity, activity, agent.on_turn
+                )
+
+                if (
+                    activity.type == "invoke"
+                    or activity.delivery_mode == DeliveryModes.expect_replies
+                ):
+                    # Invoke and ExpectReplies cannot be performed async, the response must be written before the calling thread is released.
+                    return JSONResponse(
+                        content=invoke_response.body, status_code=invoke_response.status
+                    )
+
+                return Response(status_code=202)
+            except PermissionError:
+                raise HTTPException(status_code=401, detail="Unauthorized")
+        else:
+            raise HTTPException(status_code=405, detail="Method Not Allowed")

microsoft_agents/hosting/fastapi/jwt_authorization_middleware.py

@@ -7,6 +7,7 @@ from microsoft_agents.hosting.core import (
     JwtTokenValidator,
 )
 
+
 logger = logging.getLogger(__name__)
 
 

{microsoft_agents_hosting_fastapi-0.7.0.dist-info → microsoft_agents_hosting_fastapi-0.7.0.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microsoft-agents-hosting-fastapi
-Version: 0.7.0
+Version: 0.7.0.dev0
 Summary: Integration library for Microsoft Agents with FastAPI
 Author: Microsoft Corporation
 License-Expression: MIT
@@ -10,7 +10,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: microsoft-agents-hosting-core==0.7.0
+Requires-Dist: microsoft-agents-hosting-core==0.7.0.dev0
 Requires-Dist: fastapi>=0.104.0
 Dynamic: license-file
 Dynamic: requires-dist
@@ -19,33 +19,6 @@ Dynamic: requires-dist
 
 This library provides FastAPI integration for Microsoft Agents, enabling you to build conversational agents using the FastAPI web framework.
 
-## Release Notes
-<table style="width:100%">
-  <tr>
-    <th style="width:20%">Version</th>
-    <th style="width:20%">Date</th>
-    <th style="width:60%">Release Notes</th>
-  </tr>
-  <tr>
-    <td>0.6.1</td>
-    <td>2025-12-01</td>
-    <td>
-      <a href="https://github.com/microsoft/Agents-for-python/blob/main/changelog.md#microsoft-365-agents-sdk-for-python---release-notes-v061">
-        0.6.1 Release Notes
-      </a>
-    </td>
-  </tr>
-  <tr>
-    <td>0.6.0</td>
-    <td>2025-11-18</td>
-    <td>
-      <a href="https://github.com/microsoft/Agents-for-python/blob/main/changelog.md#microsoft-365-agents-sdk-for-python---release-notes-v060">
-        0.6.0 Release Notes
-      </a>
-    </td>
-  </tr>
-</table>
-
 ## Features
 
 - FastAPI integration for Microsoft Agents

{microsoft_agents_hosting_fastapi-0.7.0.dist-info → microsoft_agents_hosting_fastapi-0.7.0.dev0.dist-info}/RECORD

@@ -1,16 +1,16 @@
-microsoft_agents/hosting/fastapi/__init__.py,sha256=SJbcJL-CZSyTw_nGkeMljzopavgtvhfxH-O5Vjq3nd8,688
+microsoft_agents/hosting/fastapi/__init__.py,sha256=9IuCCWHY4FEPGAzv9uEyob0irIbMqAomjjiYKs95NPA,592
 microsoft_agents/hosting/fastapi/_start_agent_process.py,sha256=u4aTpiPYzhcOPD1nJjVD1stRFGmsysAE3QS8vOV_37c,946
 microsoft_agents/hosting/fastapi/agent_http_adapter.py,sha256=40fi8bPXzXMGMAdeK1NDT34RSbKP--jLzBvRJ159-BQ,427
-microsoft_agents/hosting/fastapi/channel_service_route_table.py,sha256=3BnYYFgTAXyMhne3St6iJxtY1-3NKXGr2h5Yr71m-Mg,5546
-microsoft_agents/hosting/fastapi/cloud_adapter.py,sha256=qZAbl11yENlocQ_NB7sEnuuLr8k3roIvYnyiRxrAI3Q,3010
-microsoft_agents/hosting/fastapi/jwt_authorization_middleware.py,sha256=6gGL4IYVOTHUQP42a_BbmpnY5_U5-S9XFRt7iWYug_Y,2599
+microsoft_agents/hosting/fastapi/channel_service_route_table.py,sha256=NHt5958_SpcT1O6tTSPuTtZX0R196IAcDUr5gWuTYZ4,7113
+microsoft_agents/hosting/fastapi/cloud_adapter.py,sha256=wg9wFjRvEvM1scD8lqBASXhcoGlsssB8cxfKMROp-Co,4028
+microsoft_agents/hosting/fastapi/jwt_authorization_middleware.py,sha256=YMLqoXrUcC5klaLiKT4uP_dF7Tz1KbsVJjL2PvWgkLQ,2600
 microsoft_agents/hosting/fastapi/app/__init__.py,sha256=TioskqZet16twXOsI3X2snyLzmuyeKNtN2dySD1Xw7s,253
 microsoft_agents/hosting/fastapi/app/streaming/__init__.py,sha256=G_VGmQ0m6TkHZsHjRV5HitaCOt2EBEjENIoBYabJMqM,292
 microsoft_agents/hosting/fastapi/app/streaming/citation.py,sha256=ZGaMUOWxxoMplwRrkFsjnK7Z12V6rT5odE7qZCu-mP8,498
 microsoft_agents/hosting/fastapi/app/streaming/citation_util.py,sha256=c95c3Y3genmFc0vSXppPaD1-ShFohAV1UABZnyJS_BQ,2478
 microsoft_agents/hosting/fastapi/app/streaming/streaming_response.py,sha256=c5jytVvOIV3f1zKWxpFFxvCS6nR_8mi7bhv5pYusIGw,13325
-microsoft_agents_hosting_fastapi-0.7.0.dist-info/licenses/LICENSE,sha256=oDrK6gJRdwYynx5l4UtyDa2nX_D1WWkvionBYrCebek,1073
-microsoft_agents_hosting_fastapi-0.7.0.dist-info/METADATA,sha256=ZYG_tZsddfBNtaBaFw2SSCfkBBcS8ohO1-ehRdMeL5E,2130
-microsoft_agents_hosting_fastapi-0.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-microsoft_agents_hosting_fastapi-0.7.0.dist-info/top_level.txt,sha256=lWKcT4v6fTA_NgsuHdNvuMjSrkiBMXohn64ApY7Xi8A,17
-microsoft_agents_hosting_fastapi-0.7.0.dist-info/RECORD,,
+microsoft_agents_hosting_fastapi-0.7.0.dev0.dist-info/licenses/LICENSE,sha256=oDrK6gJRdwYynx5l4UtyDa2nX_D1WWkvionBYrCebek,1073
+microsoft_agents_hosting_fastapi-0.7.0.dev0.dist-info/METADATA,sha256=_vpvIr9V7X1XwKTp27MybUG1PTM7rBOjY47xexKxHbY,1431
+microsoft_agents_hosting_fastapi-0.7.0.dev0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+microsoft_agents_hosting_fastapi-0.7.0.dev0.dist-info/top_level.txt,sha256=lWKcT4v6fTA_NgsuHdNvuMjSrkiBMXohn64ApY7Xi8A,17
+microsoft_agents_hosting_fastapi-0.7.0.dev0.dist-info/RECORD,,