diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5c83d48f..d8fc00cf 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -79,4 +79,4 @@ jobs:
       - name: Run Tests
         run: |
           source .venv/bin/activate
-          pytest packages
+          uv run poe test-cov-ci
diff --git a/.gitignore b/.gitignore
index 6ac0bf3f..f6c4a05b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,6 +18,12 @@ venv.bak/
 .dmypy.json
 dmypy.json
 
+# pytest-cov
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+
 .copilot-instructions.md
 
 # other
@@ -28,10 +34,10 @@ dmypy.json
 
 ref/
 py.typed
-CLAUDE.md
 
 .env.claude/
 .claude/
+tmpclaude-*-cwd
 
 examples/**/.vscode/
 examples/**/appPackage/
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 00000000..d02b590d
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,85 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Microsoft Teams Python SDK — a UV workspace with multiple packages providing APIs, common utilities, and integrations for Microsoft Teams.
+
+## Development Setup
+
+### Prerequisites
+- UV >= 0.8.11
+- Python >= 3.12
+
+### Commands
+```bash
+uv sync                    # Install virtual env and dependencies
+source .venv/bin/activate  # Activate virtual environment
+pre-commit install         # Install pre-commit hooks
+
+poe fmt                    # Format code with ruff
+poe lint                   # Lint code with ruff
+poe check                  # Run both format and lint
+poe test                   # Run tests with pytest
+pyright                    # Run type checker
+```
+
+## Tooling
+
+- **Formatter/Linter**: Ruff — line length 120, rules: E, F, W, B, Q, I, ASYNC
+- **Type checker**: Pyright
+- **Test framework**: pytest + pytest-asyncio (Ruff bans importing the unittest test framework; unittest.mock is allowed and used)
+
+## Architecture
+
+### Workspace Structure
+All packages live in `packages/`, each with `src/microsoft_teams/<package>/` layout:
+
+| Package | Description |
+|---------|-------------|
+| `api` | Core API clients, models (Account, Activity, Conversation), auth |
+| `apps` | App orchestrator, plugins, routing, events, HttpServer |
+| `common` | HTTP client abstraction, logging, storage |
+| `cards` | Adaptive cards |
+| `ai` | AI/function calling utilities |
+| `botbuilder` | Bot Framework integration plugin |
+| `devtools` | Development tools plugin |
+| `mcpplugin` | MCP server plugin |
+| `a2aprotocol` | A2A protocol plugin |
+| `graph` | Microsoft Graph integration |
+| `openai` | OpenAI integration |
+
+### Key Patterns
+
+**Imports**
+- ALL imports MUST be at the top of the file — no imports inside functions, classes, or conditional blocks
+- Avoid `TYPE_CHECKING` blocks unless absolutely necessary (genuine circular imports that can't be restructured)
+- Avoid dynamic/deferred imports unless absolutely necessary
+- Relative imports within the same package, absolute for external packages
+
+**Models**
+- Pydantic with `ConfigDict(alias_generator=to_camel)` — snake_case in Python, camelCase in JSON
+- `model_dump(by_alias=True)` for serialization, `model_dump(exclude_none=True)` for query params
+
+**Interfaces**
+- Protocol classes instead of Abstract Base Classes (ABC)
+- Prefer composition over inheritance
+
+**Clients**
+- Concrete clients inherit from `BaseClient` (`packages/api/src/microsoft_teams/api/clients/base_client.py`)
+- Composition with operation classes for sub-functionality
+- async/await for all API calls, return domain models
+
+## Scaffolding (cookiecutter)
+
+```bash
+cookiecutter templates/package -o packages   # New package
+cookiecutter templates/test -o tests         # New test package
+```
+
+## Dependencies and Build
+
+- UV workspace — packages reference each other via `{ workspace = true }`
+- Hatchling build backend
+- Dev dependencies in root `pyproject.toml`
diff --git a/examples/a2a-test/src/main.py b/examples/a2a-test/src/main.py
index b8fe1f23..05c6ecf6 100644
--- a/examples/a2a-test/src/main.py
+++ b/examples/a2a-test/src/main.py
@@ -4,6 +4,7 @@
 """
 
 import asyncio
+import logging
 import re
 import uuid
 from os import getenv
@@ -24,14 +25,20 @@
 from microsoft_teams.ai import ChatPrompt, Function, ModelMessage
 from microsoft_teams.api import MessageActivity, TypingActivityInput
 from microsoft_teams.apps import ActivityContext, App, PluginBase
-from microsoft_teams.common import ConsoleLogger, ConsoleLoggerOptions
+from microsoft_teams.common import ConsoleFormatter
 from microsoft_teams.devtools import DevToolsPlugin
 from microsoft_teams.openai.completions_model import OpenAICompletionsAIModel
 from pydantic import BaseModel
 
-logger = ConsoleLogger().create_logger("a2a", ConsoleLoggerOptions(level="debug"))
 PORT = getenv("PORT", "4000")
 
+# Setup logging
+logging.getLogger().setLevel(logging.DEBUG)
+stream_handler = logging.StreamHandler()
+stream_handler.setFormatter(ConsoleFormatter())
+logging.getLogger().addHandler(stream_handler)
+logger = logging.getLogger(__name__)
+
 
 # Setup AI
 def get_required_env(key: str) -> str:
@@ -146,7 +153,7 @@ class LocationParams(BaseModel):
 
 # Setup the A2A Server Plugin
 plugins: List[PluginBase] = [A2APlugin(A2APluginOptions(agent_card=agent_card)), DevToolsPlugin()]
-app = App(logger=logger, plugins=plugins)
+app = App(plugins=plugins)
 
 
 # A2A Server Event Handler
diff --git a/examples/dialogs/src/main.py b/examples/dialogs/src/main.py
index c3a10e5c..f5eafffa 100644
--- a/examples/dialogs/src/main.py
+++ b/examples/dialogs/src/main.py
@@ -4,8 +4,8 @@
 """
 
 import asyncio
+import logging
 import os
-from logging import Logger
 from typing import Any, Optional
 
 from microsoft_teams.api import (
@@ -25,10 +25,15 @@
 from microsoft_teams.apps import ActivityContext, App
 from microsoft_teams.apps.events.types import ErrorEvent
 from microsoft_teams.cards import AdaptiveCard, SubmitAction, SubmitActionData, TaskFetchSubmitActionData, TextBlock
-from microsoft_teams.common.logging import ConsoleLogger
+from microsoft_teams.common import ConsoleFormatter
+
+# Setup logging
+logging.getLogger().setLevel(logging.DEBUG)
+stream_handler = logging.StreamHandler()
+stream_handler.setFormatter(ConsoleFormatter())
+logging.getLogger().addHandler(stream_handler)
+logger = logging.getLogger(__name__)
 
-logger_instance = ConsoleLogger()
-logger: Logger = logger_instance.create_logger("@apps/dialogs")
 
 if not os.getenv("BOT_ENDPOINT"):
     logger.warning("No remote endpoint detected. Using webpages for dialog will not work as expected")
diff --git a/examples/dialogs/src/views/customform/index.html b/examples/dialogs/src/views/customform/index.html
index 02e3b0dc..caf28314 100644
--- a/examples/dialogs/src/views/customform/index.html
+++ b/examples/dialogs/src/views/customform/index.html
@@ -3,7 +3,7 @@
 <head>
   <title>Microsoft Teams Task Module Demo</title>
   <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.0/css/bootstrap.min.css">
-  <script src="https://statics.teams.cdn.office.net/sdk/v1.11.0/js/MicrosoftTeams.min.js"></script>
+  <script src="https://res.cdn.office.net/teams-js/2.31.1/js/MicrosoftTeams.min.js"></script>
   <style>
     body { margin: 0; padding: 10px; }
     .form-group { margin-bottom: 10px; }
@@ -25,17 +25,21 @@
   </div>
 
   <script>
-    microsoftTeams.initialize();
-    
-    document.getElementById('customForm').addEventListener('submit', function(event) {
-      event.preventDefault();
-      let formData = {
-        name: document.getElementById('name').value,
-        email: document.getElementById('email').value,
-        submissiondialogtype: 'webpage_dialog'
-      };
-      microsoftTeams.tasks.submitTask(formData);
-    });
+    async function init() {
+      await microsoftTeams.app.initialize();
+
+      document.getElementById('customForm').addEventListener('submit', function(event) {
+        event.preventDefault();
+        let formData = {
+          name: document.getElementById('name').value,
+          email: document.getElementById('email').value,
+          submissiondialogtype: 'webpage_dialog'
+        };
+        microsoftTeams.dialog.url.submit(formData);
+      });
+    }
+
+    init();
   </script>
 </body>
-</html>
\ No newline at end of file
+</html>
diff --git a/examples/graph/src/main.py b/examples/graph/src/main.py
index af80a27c..3f77f364 100644
--- a/examples/graph/src/main.py
+++ b/examples/graph/src/main.py
@@ -10,11 +10,17 @@
 from azure.core.exceptions import ClientAuthenticationError
 from microsoft_teams.api import MessageActivity
 from microsoft_teams.apps import ActivityContext, App, AppOptions, ErrorEvent, SignInEvent
+from microsoft_teams.common import ConsoleFormatter
 from microsoft_teams.graph import get_graph_client
 from msgraph.generated.users.item.messages.messages_request_builder import (  # type: ignore
     MessagesRequestBuilder,
 )
 
+# Setup logging
+logging.getLogger().setLevel(logging.DEBUG)
+stream_handler = logging.StreamHandler()
+stream_handler.setFormatter(ConsoleFormatter())
+logging.getLogger().addHandler(stream_handler)
 logger = logging.getLogger(__name__)
 
 app_options = AppOptions(default_connection_name=os.getenv("CONNECTION_NAME", "graph"))
@@ -39,7 +45,7 @@ async def get_authenticated_graph_client(ctx: ActivityContext[MessageActivity]):
         return get_graph_client(ctx.user_token)
 
     except Exception as e:
-        ctx.logger.error(f"Failed to create Graph client: {e}")
+        logger.error(f"Failed to create Graph client: {e}")
         await ctx.send("🔐 Failed to create authenticated client. Please try signing in again.")
         await ctx.sign_in()
         return None
@@ -90,12 +96,12 @@ async def handle_profile_command(ctx: ActivityContext[MessageActivity]):
             await ctx.send("❌ Could not retrieve your profile information.")
 
     except ClientAuthenticationError as e:
-        ctx.logger.error(f"Authentication error: {e}")
+        logger.error(f"Authentication error: {e}")
         await ctx.send("🔐 Authentication failed. Please try signing in again.")
         await ctx.sign_in()
 
     except Exception as e:
-        ctx.logger.error(f"Error getting profile: {e}")
+        logger.error(f"Error getting profile: {e}")
         await ctx.send(f"❌ Failed to get your profile: {str(e)}")
 
 
@@ -138,11 +144,11 @@ async def handle_emails_command(ctx: ActivityContext[MessageActivity]):
             await ctx.send("📪 No recent emails found.")
 
     except ClientAuthenticationError as e:
-        ctx.logger.error(f"Authentication error: {e}")
+        logger.error(f"Authentication error: {e}")
         await ctx.send("🔐 Authentication failed. You may need additional permissions to read emails.")
 
     except Exception as e:
-        ctx.logger.error(f"Error getting emails: {e}")
+        logger.error(f"Error getting emails: {e}")
         await ctx.send(f"❌ Failed to get your emails: {str(e)}")
 
 
diff --git a/examples/http-adapters/README.md b/examples/http-adapters/README.md
new file mode 100644
index 00000000..465af849
--- /dev/null
+++ b/examples/http-adapters/README.md
@@ -0,0 +1,55 @@
+# HTTP Adapters Examples
+
+Examples showing how to use custom `HttpServerAdapter` implementations and non-managed server patterns with the Teams Python SDK.
+
+## Examples
+
+### 1. Starlette Adapter (`starlette_echo.py`)
+
+A custom `HttpServerAdapter` implementation for [Starlette](https://www.starlette.io/). Demonstrates how to write an adapter for any ASGI framework.
+
+**Pattern**: Custom adapter, SDK-managed server lifecycle (`app.start()`)
+
+```bash
+python src/starlette_echo.py
+```
+
+### 2. Non-Managed FastAPI (`fastapi_non_managed.py`)
+
+Use your own FastAPI app with your own routes, and let the SDK register `/api/messages` on it. You manage the server lifecycle yourself.
+
+**Pattern**: Default `FastAPIAdapter` with user-provided FastAPI instance, user-managed server (`app.initialize()` + your own `uvicorn.Server`)
+
+```bash
+python src/fastapi_non_managed.py
+```
+
+## Key Concepts
+
+### Managed vs Non-Managed
+
+| | Managed | Non-Managed |
+|---|---|---|
+| **Entry point** | `app.start(port)` | `app.initialize()` + start server yourself |
+| **Who starts the server** | The SDK (via adapter) | You |
+| **When to use** | New apps, simple setup | Existing apps, custom server config |
+
+### Writing a Custom Adapter
+
+Implement the `HttpServerAdapter` protocol:
+
+```python
+class MyAdapter:
+    def register_route(self, method, path, handler): ...
+    def serve_static(self, path, directory): ...
+    async def start(self, port): ...
+    async def stop(self): ...
+```
+
+The handler signature is framework-agnostic:
+
+```python
+async def handler(request: HttpRequest) -> HttpResponse:
+    # request = { "body": dict, "headers": dict }
+    # return   { "status": int, "body": object }
+```
diff --git a/examples/http-adapters/pyproject.toml b/examples/http-adapters/pyproject.toml
new file mode 100644
index 00000000..e8bbacd2
--- /dev/null
+++ b/examples/http-adapters/pyproject.toml
@@ -0,0 +1,17 @@
+[project]
+name = "http-adapters"
+version = "0.1.0"
+description = "Examples showing custom HttpServerAdapter and non-managed server patterns"
+readme = "README.md"
+requires-python = ">=3.12,<3.15"
+dependencies = [
+    "dotenv>=0.9.9",
+    "microsoft-teams-apps",
+    "microsoft-teams-api",
+    "starlette",
+    "uvicorn",
+    "httptools",
+]
+
+[tool.uv.sources]
+microsoft-teams-apps = { workspace = true }
diff --git a/examples/http-adapters/src/fastapi_non_managed.py b/examples/http-adapters/src/fastapi_non_managed.py
new file mode 100644
index 00000000..9b392400
--- /dev/null
+++ b/examples/http-adapters/src/fastapi_non_managed.py
@@ -0,0 +1,104 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+# Non-Managed FastAPI Server
+# ==========================
+# Teams echo bot where YOU manage the server lifecycle.
+#
+# This demonstrates the "non-managed" pattern — you create your own FastAPI app
+# with your own routes, wrap it in a FastAPIAdapter, call app.initialize() to
+# register the Teams routes, then start uvicorn yourself.
+#
+# This is ideal when:
+# - You have an existing FastAPI app and want to add Teams bot support
+# - You need full control over server configuration (TLS, workers, middleware)
+# - You're deploying to a platform that manages the server (e.g. Azure Functions)
+#
+# Run:
+#     python src/fastapi_non_managed.py
+
+import asyncio
+import os
+import re
+
+import uvicorn
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse
+from microsoft_teams.api import MessageActivity
+from microsoft_teams.apps import ActivityContext, App, FastAPIAdapter
+
+# 1. Create your own FastAPI app with your own routes
+my_fastapi = FastAPI(title="My App + Teams Bot")
+
+
+@my_fastapi.get("/health")
+async def health():
+    return {"status": "healthy"}
+
+
+@my_fastapi.get("/api/users")
+async def users():
+    return {"users": [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]}
+
+
+@my_fastapi.get("/")
+async def homepage():
+    return HTMLResponse("""
+        <h1>FastAPI + Teams Bot</h1>
+        <p>Your FastAPI server is running with a Teams bot!</p>
+        <ul>
+            <li><a href="/health">Health Check</a></li>
+            <li><a href="/api/users">API: Users</a></li>
+            <li><b>/api/messages</b> — Teams bot endpoint (added by SDK)</li>
+        </ul>
+    """)
+
+
+# 2. Create a FastAPIAdapter wrapping your existing FastAPI app
+adapter = FastAPIAdapter(app=my_fastapi)
+
+# 3. Create the Teams app with the adapter
+app = App(http_server_adapter=adapter)
+
+
+# 4. Handle incoming messages — streaming demo
+@app.on_message_pattern(re.compile(r"^stream\b", re.IGNORECASE))
+async def handle_stream(ctx: ActivityContext[MessageActivity]):
+    ctx.stream.update("Starting stream...")
+    await asyncio.sleep(0.5)
+
+    words = "Hello from the FastAPI adapter! This message is being streamed word by word.".split()
+    for word in words:
+        await asyncio.sleep(0.3)
+        ctx.stream.emit(word + " ")
+
+
+# 5. Echo fallback
+@app.on_message
+async def handle_message(ctx: ActivityContext[MessageActivity]):
+    await ctx.send(f"[FastAPI non-managed] You said: '{ctx.activity.text}'")
+
+
+async def main():
+    port = int(os.getenv("PORT", "3978"))
+
+    # 5. Initialize only — registers /api/messages on our FastAPI app
+    #    Does NOT start a server
+    await app.initialize()
+
+    print(f"Starting server on http://localhost:{port}")
+    print("  GET  /              — Homepage")
+    print("  GET  /health        — Health check")
+    print("  GET  /api/users     — Users API")
+    print("  POST /api/messages  — Teams bot endpoint (added by SDK)")
+
+    # 6. Start your own uvicorn server
+    config = uvicorn.Config(app=my_fastapi, host="0.0.0.0", port=port, log_level="info")
+    server = uvicorn.Server(config)
+    await server.serve()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/examples/http-adapters/src/starlette_adapter.py b/examples/http-adapters/src/starlette_adapter.py
new file mode 100644
index 00000000..0dbab016
--- /dev/null
+++ b/examples/http-adapters/src/starlette_adapter.py
@@ -0,0 +1,91 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+
+Starlette Adapter
+=================
+A custom HttpServerAdapter implementation for Starlette.
+
+This shows how to implement the adapter protocol for any ASGI framework.
+The adapter translates between the framework's request/response model
+and the SDK's pure handler pattern: ({ body, headers }) -> { status, body }.
+"""
+
+from typing import Optional
+
+import uvicorn
+from microsoft_teams.apps.http.adapter import HttpMethod, HttpRequest, HttpResponse, HttpRouteHandler
+from starlette.applications import Starlette
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+from starlette.routing import Mount, Route
+from starlette.staticfiles import StaticFiles
+
+
+class StarletteAdapter:
+    """
+    HttpServerAdapter implementation wrapping Starlette + uvicorn.
+
+    Usage:
+        adapter = StarletteAdapter()
+        app = App(http_server_adapter=adapter)
+        await app.start(3978)
+
+    Or bring your own Starlette instance:
+        starlette_app = Starlette()
+        adapter = StarletteAdapter(starlette_app)
+        app = App(http_server_adapter=adapter)
+        await app.initialize()  # Just registers routes, doesn't start server
+    """
+
+    def __init__(self, app: Optional[Starlette] = None):
+        self._app = app or Starlette()
+        self._is_user_provided = app is not None
+        self._server: Optional[uvicorn.Server] = None
+        self._routes: list[Route] = []
+
+    @property
+    def app(self) -> Starlette:
+        """The underlying Starlette instance."""
+        return self._app
+
+    def register_route(self, method: HttpMethod, path: str, handler: HttpRouteHandler) -> None:
+        """Register a route handler on the Starlette app."""
+
+        async def starlette_handler(request: Request) -> Response:
+            body = await request.json()
+            headers = dict(request.headers)
+            http_request = HttpRequest(body=body, headers=headers)
+            result: HttpResponse = await handler(http_request)
+            status = result["status"]
+            resp_body = result.get("body")
+            if resp_body is not None:
+                return JSONResponse(content=resp_body, status_code=status)
+            return Response(status_code=status)
+
+        route = Route(path, starlette_handler, methods=[method])
+        self._routes.append(route)
+        self._app.routes.insert(0, route)
+
+    def serve_static(self, path: str, directory: str) -> None:
+        """Mount a static files directory."""
+        name = path.strip("/").replace("/", "-") or "static"
+        mount = Mount(path, app=StaticFiles(directory=directory, check_dir=True, html=True), name=name)
+        self._app.routes.append(mount)
+
+    async def start(self, port: int) -> None:
+        """Start the uvicorn server. Blocks until stopped."""
+        if self._is_user_provided:
+            raise RuntimeError(
+                "Cannot call start() when a Starlette instance was provided by user. "
+                "Manage the server lifecycle yourself."
+            )
+
+        config = uvicorn.Config(app=self._app, host="0.0.0.0", port=port, log_level="info")
+        self._server = uvicorn.Server(config)
+        await self._server.serve()
+
+    async def stop(self) -> None:
+        """Signal the server to stop."""
+        if self._server:
+            self._server.should_exit = True
diff --git a/examples/http-adapters/src/starlette_echo.py b/examples/http-adapters/src/starlette_echo.py
new file mode 100644
index 00000000..d816f4a6
--- /dev/null
+++ b/examples/http-adapters/src/starlette_echo.py
@@ -0,0 +1,60 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+# Starlette Echo Bot
+# ==================
+# Teams echo bot using a custom StarletteAdapter.
+#
+# This demonstrates the "managed" pattern — the SDK manages the server lifecycle
+# via app.start(). The adapter creates its own Starlette app and uvicorn server.
+#
+# Run:
+#     python src/starlette_echo.py
+
+import asyncio
+import re
+
+from microsoft_teams.api import MessageActivity
+from microsoft_teams.apps import ActivityContext, App
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from starlette_adapter import StarletteAdapter
+
+# 1. Create adapter
+adapter = StarletteAdapter()
+
+
+# 2. Add custom routes directly on the Starlette instance
+async def health(request: Request) -> JSONResponse:
+    return JSONResponse({"status": "healthy"})
+
+
+adapter.app.add_route("/health", health)
+
+
+# 3. Create the Teams app with the adapter
+app = App(http_server_adapter=adapter)
+
+
+# 4. Handle incoming messages — streaming demo
+@app.on_message_pattern(re.compile(r"^stream\b", re.IGNORECASE))
+async def handle_stream(ctx: ActivityContext[MessageActivity]):
+    ctx.stream.update("Starting stream...")
+    await asyncio.sleep(0.5)
+
+    words = "Hello from the Starlette adapter! This message is being streamed word by word.".split()
+    for word in words:
+        await asyncio.sleep(0.3)
+        ctx.stream.emit(word + " ")
+
+
+# 5. Echo fallback
+@app.on_message
+async def handle_message(ctx: ActivityContext[MessageActivity]):
+    await ctx.send(f"[Starlette] You said: '{ctx.activity.text}'")
+
+
+if __name__ == "__main__":
+    asyncio.run(app.start())
diff --git a/examples/oauth/src/main.py b/examples/oauth/src/main.py
index a9e343f2..9215f91d 100644
--- a/examples/oauth/src/main.py
+++ b/examples/oauth/src/main.py
@@ -4,11 +4,20 @@
 """
 
 import asyncio
+import logging
 
 from microsoft_teams.api import MessageActivity
 from microsoft_teams.api.activities.invoke.sign_in import SignInFailureInvokeActivity
 from microsoft_teams.apps import ActivityContext, App, SignInEvent
 from microsoft_teams.apps.events.types import ErrorEvent
+from microsoft_teams.common import ConsoleFormatter
+
+# Setup logging
+logging.getLogger().setLevel(logging.DEBUG)
+stream_handler = logging.StreamHandler()
+stream_handler.setFormatter(ConsoleFormatter())
+logging.getLogger().addHandler(stream_handler)
+logger = logging.getLogger(__name__)
 
 app = App()
 
@@ -19,7 +28,7 @@ async def handle_message(ctx: ActivityContext[MessageActivity]):
     print(f"[GENERATED onMessage] Message received: {ctx.activity.text}")
     print(f"[GENERATED onMessage] From: {ctx.activity.from_}")
 
-    ctx.logger.info("User requested sign-in.")
+    logger.info("User requested sign-in.")
     if ctx.is_signed_in:
         await ctx.send("You are already signed in. Logging you out.")
         await ctx.sign_out()
diff --git a/examples/proactive-messaging/README.md b/examples/proactive-messaging/README.md
new file mode 100644
index 00000000..2b1ece12
--- /dev/null
+++ b/examples/proactive-messaging/README.md
@@ -0,0 +1,57 @@
+# Proactive Messaging Example
+
+This example demonstrates how to send proactive messages to Teams users without running a server. This is useful for:
+- Scheduled notifications
+- Alert systems
+- Background jobs that need to notify users
+- Webhook handlers that send messages
+
+## Key Concepts
+
+- Uses `app.initialize()` instead of `app.start()` (no HTTP server)
+- Directly sends messages using `app.send()`
+- Requires a conversation ID (from previous interactions or from the Teams API)
+
+## How It Works
+
+The example shows the separation of activity sending from HTTP transport:
+
+1. **Initialize without server**: `await app.initialize()` sets up credentials, token manager, and activity sender without starting the HTTP server
+2. **Send messages**: `await app.send(conversation_id, message)` sends messages directly using the ActivitySender
+3. **No HTTP server**: Perfect for background jobs, scheduled tasks, or webhook handlers
+
+## Usage
+
+```bash
+# Set up your environment variables
+export CLIENT_ID=your_app_id
+export CLIENT_SECRET=your_app_secret
+export TENANT_ID=your_tenant_id
+
+# Run the example with a conversation ID
+uv run src/main.py <conversation_id>
+```
+
+## Getting a Conversation ID
+
+You need a conversation ID to send proactive messages. You can get this from:
+
+1. **Previous bot interactions**: Store the conversation ID when users first interact with your bot
+2. **Teams API**: Use the Microsoft Teams API to create or get conversation references
+3. **Testing**: Use an existing bot conversation and extract the conversation ID from the activity
+
+## Example Output
+
+```
+Initializing app (without starting server)...
+✓ App initialized
+
+Sending proactive message to conversation: 19:...
+Message: Hello! This is a proactive message sent without a running server 🚀
+✓ Message sent successfully! Activity ID: 1234567890
+
+Sending proactive card to conversation: 19:...
+✓ Card sent successfully! Activity ID: 1234567891
+
+✓ All proactive messages sent successfully!
+```
diff --git a/examples/proactive-messaging/pyproject.toml b/examples/proactive-messaging/pyproject.toml
new file mode 100644
index 00000000..800f9712
--- /dev/null
+++ b/examples/proactive-messaging/pyproject.toml
@@ -0,0 +1,13 @@
+[project]
+name = "proactive-messaging"
+version = "0.1.0"
+description = "Example showing proactive messaging without running a server"
+readme = "README.md"
+requires-python = ">=3.12,<3.15"
+dependencies = [
+    "dotenv>=0.9.9",
+    "microsoft-teams-apps",
+]
+
+[tool.uv.sources]
+microsoft-teams-apps = { workspace = true }
diff --git a/examples/proactive-messaging/src/main.py b/examples/proactive-messaging/src/main.py
new file mode 100644
index 00000000..006723a9
--- /dev/null
+++ b/examples/proactive-messaging/src/main.py
@@ -0,0 +1,110 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+
+Proactive Messaging Example
+===========================
+This example demonstrates how to send proactive messages to Teams users
+without running a server. This is useful for:
+- Scheduled notifications
+- Alert systems
+- Background jobs that need to notify users
+- Webhook handlers that send messages
+
+Key points:
+- Uses app.initialize() instead of app.start() (no HTTP server)
+- Directly sends messages using app.send()
+- Requires a conversation ID (from previous interactions or from the Teams API)
+"""
+
+import argparse
+import asyncio
+
+from microsoft_teams.apps import App
+from microsoft_teams.cards import ActionSet, AdaptiveCard, OpenUrlAction, TextBlock
+
+
+async def send_proactive_message(app: App, conversation_id: str, message: str) -> None:
+    """
+    Send a proactive message to a Teams conversation.
+
+    Args:
+        app: The initialized App instance
+        conversation_id: The Teams conversation ID to send the message to
+        message: The message text to send
+    """
+    print(f"Sending proactive message to conversation: {conversation_id}")
+    print(f"Message: {message}")
+
+    # Send the message
+    result = await app.send(conversation_id, message)
+
+    print(f"✓ Message sent successfully! Activity ID: {result.id}")
+
+
+async def send_proactive_card(app: App, conversation_id: str) -> None:
+    """
+    Send a proactive Adaptive Card to a Teams conversation.
+
+    Args:
+        app: The initialized App instance
+        conversation_id: The Teams conversation ID to send the card to
+    """
+    # Create an Adaptive Card
+    card = AdaptiveCard(
+        schema="http://adaptivecards.io/schemas/adaptive-card.json",
+        body=[
+            TextBlock(text="Proactive Notification", size="Large", weight="Bolder"),
+            TextBlock(text="This message was sent proactively without a server running!", wrap=True),
+            TextBlock(text="Status: Active • Priority: High • Time: Now", wrap=True, is_subtle=True),
+            ActionSet(actions=[OpenUrlAction(title="Learn More", url="https://aka.ms/teams-sdk")]),
+        ],
+    )
+
+    print(f"Sending proactive card to conversation: {conversation_id}")
+
+    result = await app.send(conversation_id, card)
+
+    print(f"✓ Card sent successfully! Activity ID: {result.id}")
+
+
+async def main():
+    """
+    Main function demonstrating proactive messaging.
+
+    In a real application, you would:
+    1. Store conversation IDs when users first interact with your bot
+    2. Use those IDs later to send proactive messages
+    3. Get conversation IDs from the Teams API or from previous interactions
+    """
+    parser = argparse.ArgumentParser(
+        description="Send proactive messages to a Teams conversation without running a server"
+    )
+    parser.add_argument("conversation_id", help="The Teams conversation ID to send messages to")
+    args = parser.parse_args()
+
+    # Create app (no plugins needed for sending only)
+    app = App()
+
+    # Initialize the app without starting the HTTP server
+    # This sets up credentials, token manager, and activity sender
+    print("Initializing app (without starting server)...")
+    await app.initialize()
+    print("✓ App initialized\n")
+
+    # Example 1: Send a simple text message
+    await send_proactive_message(
+        app, args.conversation_id, "Hello! This is a proactive message sent without a running server 🚀"
+    )
+
+    # Wait a bit between messages
+    await asyncio.sleep(2)
+
+    # Example 2: Send an Adaptive Card
+    await send_proactive_card(app, args.conversation_id)
+
+    print("\n✓ All proactive messages sent successfully!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/examples/tab/Web/src/App.tsx b/examples/tab/Web/src/App.tsx
index 3d333487..41d8a3bd 100644
--- a/examples/tab/Web/src/App.tsx
+++ b/examples/tab/Web/src/App.tsx
@@ -2,7 +2,6 @@ import React from 'react';
 import * as teamsJs from '@microsoft/teams-js';
 import * as client from '@microsoft/teams.client';
 import * as endpoints from '@microsoft/teams.graph-endpoints';
-import { ConsoleLogger } from '@microsoft/teams.common';
 
 import './App.css';
 
@@ -17,7 +16,6 @@ export default function App() {
       try {
           // initialize the app and prompt for Graph scope consent, if not already granted
           const app = new client.App(clientId, {
-            logger: new ConsoleLogger('@examples/tab', { level: 'debug' }),
               msalOptions: {
               prewarmScopes: [
                 'https://graph.microsoft.com/User.Read',
@@ -28,7 +26,7 @@ export default function App() {
           });
 
           await app.start();
-          app.log.info('app started');
+          console.info('app started');
           setApp(app);
         } catch (err) {
           console.error(err);
diff --git a/examples/targeted-messages/README.md b/examples/targeted-messages/README.md
index 921ea9e6..478d2a9b 100644
--- a/examples/targeted-messages/README.md
+++ b/examples/targeted-messages/README.md
@@ -16,7 +16,7 @@ Targeted messages are messages that only a specific recipient can see - other pa
 
 ## How It Works
 
-When responding to an incoming message, use `with_targeted_recipient(True)` - the recipient is automatically inferred from the message sender.
+When sending targeted messages, use `with_recipient(Account(...), is_targeted=True)` to mark the recipient as targeted.
 
 ## Testing in a Group Chat
 
diff --git a/examples/targeted-messages/src/main.py b/examples/targeted-messages/src/main.py
index 15712f1c..443c94bb 100644
--- a/examples/targeted-messages/src/main.py
+++ b/examples/targeted-messages/src/main.py
@@ -72,15 +72,15 @@ async def handle_message(ctx: ActivityContext[MessageActivity]):
         async def update_after_delay():
             await asyncio.sleep(3)
             try:
-                # For updates, we just set is_targeted but don't change the recipient
-                # The backend doesn't allow changing the recipient of a targeted message
+                # For targeted updates, do not include recipient in the payload.
                 updated_message = MessageActivityInput(
                     text="🔒 [UPDATE] ✅ UPDATED targeted message! (only you see this)"
                 )
                 updated_message.id = result.id
-                updated_message.is_targeted = True  # Mark as targeted for the API URL
 
-                await ctx.send(updated_message)
+                await ctx.api.conversations.activities(ctx.activity.conversation.id).update_targeted(
+                    result.id, updated_message
+                )
                 print("Targeted UPDATE completed")
             except Exception as err:
                 print(f"Targeted UPDATE error: {err}")
diff --git a/packages/a2aprotocol/src/microsoft_teams/a2a/__init__.py b/packages/a2aprotocol/src/microsoft_teams/a2a/__init__.py
index 98d34b6f..be841c65 100644
--- a/packages/a2aprotocol/src/microsoft_teams/a2a/__init__.py
+++ b/packages/a2aprotocol/src/microsoft_teams/a2a/__init__.py
@@ -3,10 +3,14 @@
 Licensed under the MIT License.
 """
 
+import logging
+
 from . import chat_prompt, server
 from .chat_prompt import *  # noqa: F403
 from .server import *  # noqa: F401, F403
 
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
 # Combine all exports from submodules
 __all__: list[str] = []
 __all__.extend(chat_prompt.__all__)
diff --git a/packages/a2aprotocol/src/microsoft_teams/a2a/chat_prompt/plugin.py b/packages/a2aprotocol/src/microsoft_teams/a2a/chat_prompt/plugin.py
index 51aa4950..509b522f 100644
--- a/packages/a2aprotocol/src/microsoft_teams/a2a/chat_prompt/plugin.py
+++ b/packages/a2aprotocol/src/microsoft_teams/a2a/chat_prompt/plugin.py
@@ -3,18 +3,17 @@
 Licensed under the MIT License.
 """
 
+import logging
 import re
 import uuid
 from dataclasses import asdict
 from functools import partial
-from logging import Logger
 from typing import Any, Dict, List, Optional, Union, Unpack, cast
 
 from httpx import AsyncClient
 from microsoft_teams.ai import Function as ChatFunction
 from microsoft_teams.ai import SystemMessage
 from microsoft_teams.ai.plugin import BaseAIPlugin
-from microsoft_teams.common.logging.console import ConsoleLogger
 from pydantic import BaseModel
 
 from a2a.client import ClientFactory
@@ -39,6 +38,8 @@
     InternalA2AClientPluginOptions,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class A2AClientMessageParams(BaseModel):
     message: str
@@ -46,7 +47,6 @@ class A2AClientMessageParams(BaseModel):
 
 
 class A2AClientPlugin(BaseAIPlugin):
-    log: Logger
     _agent_configs: Dict[str, AgentConfig] = {}
     _clients: Dict[str, AgentClientInfo] = {}
 
@@ -63,7 +63,6 @@ def __init__(self, **options: Unpack[A2AClientPluginOptions]):
         self._build_prompt = self.options.build_prompt
         self._build_message_for_agent = self.options.build_message_for_agent
         self._build_message_from_agent_response = self.options.build_message_from_agent_response
-        self.log = self.options.logger if self.options.logger else ConsoleLogger().create_logger(name="a2a:client")
 
     def on_use_plugin(self, args: A2APluginUseParams):
         # just store the config, defer client creation to on_build_functions
@@ -102,7 +101,7 @@ async def _get_agent_card(self, key: str, config: AgentConfig) -> Optional[Agent
             self._clients.update({key: client_info})
             return card
         except Exception as e:
-            self.log.error(f"Error creating client or fetching agent card for {key}: {e}")
+            logger.error(f"Error creating client or fetching agent card for {key}: {e}")
             return None
 
     def _default_function_metadata(self, card: AgentCard) -> FunctionMetadata:
@@ -143,7 +142,7 @@ async def on_build_functions(self, functions: list[ChatFunction[Any]]) -> list[C
             try:
                 agent_card = await self._get_agent_card(key, config)
                 if not agent_card:
-                    self.log.warning(f"Could not retrieve agent card for {key}, continuing to next agent.")
+                    logger.warning(f"Could not retrieve agent card for {key}, continuing to next agent.")
                     # skip if we couldn't get the agent card
                     continue
 
@@ -183,7 +182,7 @@ async def message_handler(
                         if not client_info:
                             raise ValueError(f"Client not found for agent {key}")
 
-                        self.log.debug(f"Calling agent {agent_card.name} with {message.model_dump_json()}")
+                        logger.debug(f"Calling agent {agent_card.name} with {message.model_dump_json()}")
 
                         last_message: Optional[Message] = None
                         async for event in client_info.client.send_message(message):
@@ -194,7 +193,7 @@ async def message_handler(
                                 last_message = event
 
                         if last_message is not None:
-                            self.log.debug(f"Got response from {agent_card.name}")
+                            logger.debug(f"Got response from {agent_card.name}")
                             # use custom response builder if provided, otherwise use default
                             metadata = BuildMessageFromAgentMetadata(
                                 card=agent_card, response=last_message, original_input=agent_message
@@ -209,7 +208,7 @@ async def message_handler(
                                 )
                             )
                     except Exception as e:
-                        self.log.error(e)
+                        logger.error(e)
                         raise e
 
                 message_handler_with_args = partial(message_handler, config=config, agent_card=agent_card, key=key)
@@ -222,9 +221,9 @@ async def message_handler(
                         handler=message_handler_with_args,
                     )
                 )
-                self.log.debug(f"Added function in ChatPrompt to call {agent_card.name}")
+                logger.debug(f"Added function in ChatPrompt to call {agent_card.name}")
             except Exception as e:
-                self.log.info(f"Failed to build function for agent {key}: {e}")
+                logger.info(f"Failed to build function for agent {key}: {e}")
                 # Continue with other agents even if one fails
 
         functions = functions + all_functions
@@ -247,7 +246,7 @@ async def on_build_instructions(self, instructions: Optional[SystemMessage] = No
                             )
                         )
             except Exception as e:
-                self.log.info(f"Failed to get agent card for {key}: {e}")
+                logger.info(f"Failed to get agent card for {key}: {e}")
 
         # use custom build_prompt if provided, otherwise use default
         if self._build_prompt:
diff --git a/packages/a2aprotocol/src/microsoft_teams/a2a/chat_prompt/types.py b/packages/a2aprotocol/src/microsoft_teams/a2a/chat_prompt/types.py
index 9c410eb5..d79d5e5d 100644
--- a/packages/a2aprotocol/src/microsoft_teams/a2a/chat_prompt/types.py
+++ b/packages/a2aprotocol/src/microsoft_teams/a2a/chat_prompt/types.py
@@ -4,7 +4,6 @@
 """
 
 from dataclasses import dataclass, field
-from logging import Logger
 from typing import Any, Callable, List, Optional, TypedDict, Union
 
 from a2a.client import Client
@@ -62,8 +61,6 @@ class A2AClientPluginOptions(TypedDict, total=False):
     "Optional function to customize the message format sent to each agent."
     build_message_from_agent_response: Optional[BuildMessageFromAgentResponse]
     "Optional function to customize how agent responses are processed into strings."
-    logger: Optional[Logger]
-    "The associated logger"
 
 
 @dataclass
@@ -75,7 +72,6 @@ class InternalA2AClientPluginOptions:
     build_prompt: Optional[BuildPrompt] = None
     build_message_for_agent: Optional[BuildMessageForAgent] = None
     build_message_from_agent_response: Optional[BuildMessageFromAgentResponse] = None
-    logger: Optional[Logger] = None
 
     @classmethod
     def from_typed_dict(cls, options: A2AClientPluginOptions) -> "InternalA2AClientPluginOptions":
diff --git a/packages/a2aprotocol/src/microsoft_teams/a2a/server/logging_middleware.py b/packages/a2aprotocol/src/microsoft_teams/a2a/server/logging_middleware.py
index 8473b9ab..5bc6b2dd 100644
--- a/packages/a2aprotocol/src/microsoft_teams/a2a/server/logging_middleware.py
+++ b/packages/a2aprotocol/src/microsoft_teams/a2a/server/logging_middleware.py
@@ -3,18 +3,19 @@
 Licensed under the MIT License.
 """
 
-from logging import Logger
+import logging
 
 from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
 from starlette.requests import Request
 from starlette.responses import Response
 from starlette.types import ASGIApp
 
+logger = logging.getLogger(__name__)
+
 
 class LoggingMiddleware(BaseHTTPMiddleware):
-    def __init__(self, app: ASGIApp, logger: Logger) -> None:
+    def __init__(self, app: ASGIApp) -> None:
         super().__init__(app)
-        self.logger = logger
 
     async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:
         log_message = f"A2A Request: {request.method} {request.url}"
@@ -22,6 +23,6 @@ async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -
         if request.method == "POST":
             body = await request.body()
             log_message += f" Body: {body.decode('utf-8')}"
-        self.logger.debug(log_message)
+        logger.debug(log_message)
         response = await call_next(request)
         return response
diff --git a/packages/a2aprotocol/src/microsoft_teams/a2a/server/plugin.py b/packages/a2aprotocol/src/microsoft_teams/a2a/server/plugin.py
index 5c106bd1..4b41e7d3 100644
--- a/packages/a2aprotocol/src/microsoft_teams/a2a/server/plugin.py
+++ b/packages/a2aprotocol/src/microsoft_teams/a2a/server/plugin.py
@@ -3,14 +3,14 @@
 Licensed under the MIT License.
 """
 
-from logging import Logger
+import logging
 from typing import Annotated, Any, Awaitable, Callable, List, Optional
 
 from microsoft_teams.apps import (
     DependencyMetadata,
     EventMetadata,
-    HttpPlugin,
-    LoggerDependencyOptions,
+    FastAPIAdapter,
+    HttpServer,
     Plugin,
     PluginBase,
 )
@@ -26,11 +26,12 @@
 from .custom_agent_executor import A2AMessageEvent, CustomAgentExecutor
 from .logging_middleware import LoggingMiddleware
 
+logger = logging.getLogger(__name__)
+
 
 @Plugin(name="a2a", version="0.3.7", description="A2A Server Plugin")
 class A2APlugin(PluginBase):
-    logger: Annotated[Logger, LoggerDependencyOptions()]
-    http: Annotated[HttpPlugin, DependencyMetadata()]
+    http_server: Annotated[HttpServer, DependencyMetadata()]
 
     emit: Annotated[Callable[[str, A2AMessageEvent], Awaitable[None]], EventMetadata(name="custom")]
 
@@ -68,15 +69,18 @@ async def on_init(self) -> None:
         self.app = a2a_app.build(agent_card_url=self.agent_card_path)
 
         # add the middleware
-        self.app.add_middleware(LoggingMiddleware, logger=self.logger)
+        self.app.add_middleware(LoggingMiddleware)
         for middleware_info in self._middlewares:
             middleware, kwargs = middleware_info
             self.app.add_middleware(middleware, **kwargs)
 
-        self.logger.info(f"A2A agent set up at {self.agent_card_path}")
-        self.logger.info(f"A2A agent listening at {self.path}")
+        logger.info(f"A2A agent set up at {self.agent_card_path}")
+        logger.info(f"A2A agent listening at {self.path}")
 
-        self.http.app.mount(self.path, self.app)
+        adapter = self.http_server.adapter
+        if not isinstance(adapter, FastAPIAdapter):
+            raise RuntimeError("A2APlugin requires FastAPIAdapter. Custom adapters are not supported.")
+        adapter.app.mount(self.path, self.app)
 
     def _setup_executor(self) -> AgentExecutor:
         return CustomAgentExecutor(self.emit)
diff --git a/packages/ai/src/microsoft_teams/ai/__init__.py b/packages/ai/src/microsoft_teams/ai/__init__.py
index b256d155..7e641d51 100644
--- a/packages/ai/src/microsoft_teams/ai/__init__.py
+++ b/packages/ai/src/microsoft_teams/ai/__init__.py
@@ -3,12 +3,16 @@
 Licensed under the MIT License.
 """
 
+import logging
+
 from .ai_model import AIModel
 from .chat_prompt import ChatPrompt, ChatSendResult
 from .function import Function, FunctionCall, FunctionHandler, FunctionHandlers, FunctionHandlerWithNoParams
 from .memory import ListMemory, Memory
 from .message import FunctionMessage, Message, ModelMessage, SystemMessage, UserMessage
 
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
 __all__ = [
     "ChatSendResult",
     "ChatPrompt",
diff --git a/packages/ai/tests/test_chat_prompt.py b/packages/ai/tests/test_chat_prompt.py
index 2805b222..12b270f9 100644
--- a/packages/ai/tests/test_chat_prompt.py
+++ b/packages/ai/tests/test_chat_prompt.py
@@ -392,6 +392,65 @@ def handler_no_params() -> str:
         assert result.response.content == "Function returned: Success"
 
 
+class TestBaseAIPluginLifecycle:
+    """Integration test: BaseAIPlugin subclass run through ChatPrompt to verify lifecycle call order."""
+
+    @pytest.mark.asyncio
+    async def test_plugin_lifecycle_order_through_chat_prompt(self) -> None:
+        """All plugin hooks are called in the expected order during a send with function calling."""
+        call_log: list[str] = []
+
+        class LifecyclePlugin(BaseAIPlugin):
+            async def on_build_instructions(self, instructions: SystemMessage | None) -> SystemMessage | None:
+                call_log.append("on_build_instructions")
+                return instructions
+
+            async def on_build_functions(
+                self, functions: list[Function[BaseModel]]
+            ) -> list[Function[BaseModel]] | None:
+                call_log.append("on_build_functions")
+                return functions
+
+            async def on_before_send(self, input: Message) -> Message | None:
+                call_log.append("on_before_send")
+                return input
+
+            async def on_after_send(self, response: ModelMessage) -> ModelMessage | None:
+                call_log.append("on_after_send")
+                return response
+
+            async def on_before_function_call(self, function_name: str, args: Optional[BaseModel] = None) -> None:
+                call_log.append(f"on_before_function_call:{function_name}")
+
+            async def on_after_function_call(
+                self, function_name: str, result: str, args: Optional[BaseModel] = None
+            ) -> str | None:
+                call_log.append(f"on_after_function_call:{function_name}")
+                return result
+
+        plugin = LifecyclePlugin("lifecycle")
+        mock_model = MockAIModel(should_call_function=True)
+
+        def handler(params: MockFunctionParams) -> str:
+            call_log.append("function_handler")
+            return "ok"
+
+        func = Function("test_function", "A test function", MockFunctionParams, handler)
+        prompt = ChatPrompt(mock_model, functions=[func], plugins=[plugin])
+
+        await prompt.send("Hello", instructions=SystemMessage(content="Be helpful"))
+
+        assert call_log == [
+            "on_before_send",
+            "on_build_instructions",
+            "on_build_functions",
+            "on_before_function_call:test_function",
+            "function_handler",
+            "on_after_function_call:test_function",
+            "on_after_send",
+        ]
+
+
 class MockPlugin(BaseAIPlugin):
     """Mock plugin for testing that tracks all hook calls"""
 
diff --git a/packages/api/pyproject.toml b/packages/api/pyproject.toml
index 8f46f4bf..b666a1d2 100644
--- a/packages/api/pyproject.toml
+++ b/packages/api/pyproject.toml
@@ -14,7 +14,7 @@ dependencies = [
     "pydantic>=2.0.0",
     "microsoft-teams-common",
     "microsoft-teams-cards",
-    "pyjwt[crypto]>=2.10.0",
+    "pyjwt[crypto]>=2.12.0",
 ]
 
 [tool.uv.sources]
diff --git a/packages/api/src/microsoft_teams/api/__init__.py b/packages/api/src/microsoft_teams/api/__init__.py
index 6e2fd5d5..59c0de16 100644
--- a/packages/api/src/microsoft_teams/api/__init__.py
+++ b/packages/api/src/microsoft_teams/api/__init__.py
@@ -3,12 +3,16 @@
 Licensed under the MIT License.
 """
 
+import logging
+
 from . import activities, auth, clients, models
 from .activities import *  # noqa: F403
 from .auth import *  # noqa: F403
 from .clients import *  # noqa: F403
 from .models import *  # noqa: F403
 
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
 # Combine all exports from submodules
 __all__: list[str] = []
 __all__.extend(activities.__all__)
diff --git a/packages/api/src/microsoft_teams/api/clients/api_client.py b/packages/api/src/microsoft_teams/api/clients/api_client.py
index 08971af9..3576b147 100644
--- a/packages/api/src/microsoft_teams/api/clients/api_client.py
+++ b/packages/api/src/microsoft_teams/api/clients/api_client.py
@@ -35,15 +35,22 @@ def __init__(
             api_client_settings: Optional API client settings.
         """
         super().__init__(options, api_client_settings)
-        self.service_url = service_url
+        self.service_url = service_url.rstrip("/")
 
         # Initialize all client types
         self.bots = BotClient(self._http, self._api_client_settings)
         self.users = UserClient(self._http, self._api_client_settings)
-        self.conversations = ConversationClient(service_url, self._http, self._api_client_settings)
-        self.teams = TeamClient(service_url, self._http, self._api_client_settings)
-        self.meetings = MeetingClient(service_url, self._http, self._api_client_settings)
-        self.reactions = ReactionClient(service_url, self._http, self._api_client_settings)
+        self.conversations = ConversationClient(self.service_url, self._http, self._api_client_settings)
+        self.teams = TeamClient(self.service_url, self._http, self._api_client_settings)
+        self.meetings = MeetingClient(self.service_url, self._http, self._api_client_settings)
+        self._reactions: Optional[ReactionClient] = None
+
+    @property
+    def reactions(self) -> ReactionClient:
+        """Get the reactions client (preview). Lazily instantiated to avoid warnings for non-users."""
+        if self._reactions is None:
+            self._reactions = ReactionClient(self.service_url, self._http, self._api_client_settings)
+        return self._reactions
 
     @property
     def http(self) -> HttpClient:
@@ -58,5 +65,6 @@ def http(self, value: HttpClient) -> None:
         self.users.http = value
         self.teams.http = value
         self.meetings.http = value
-        self.reactions.http = value
+        if self._reactions is not None:
+            self._reactions.http = value
         self._http = value
diff --git a/packages/api/src/microsoft_teams/api/clients/conversation/activity.py b/packages/api/src/microsoft_teams/api/clients/conversation/activity.py
index e68fb3b3..e72d1104 100644
--- a/packages/api/src/microsoft_teams/api/clients/conversation/activity.py
+++ b/packages/api/src/microsoft_teams/api/clients/conversation/activity.py
@@ -5,6 +5,7 @@
 
 from typing import List, Optional
 
+from microsoft_teams.common.experimental import experimental
 from microsoft_teams.common.http import Client
 
 from ...activities import ActivityParams, SentActivity
@@ -35,7 +36,7 @@ def __init__(
             api_client_settings: Optional API client settings.
         """
         super().__init__(http_client, api_client_settings)
-        self.service_url = service_url
+        self.service_url = service_url.rstrip("/")
 
     async def create(self, conversation_id: str, activity: ActivityParams) -> SentActivity:
         """
@@ -126,12 +127,17 @@ async def get_members(self, conversation_id: str, activity_id: str) -> List[Acco
         )
         return [Account.model_validate(member) for member in response.json()]
 
+    @experimental("ExperimentalTeamsTargeted")
     async def create_targeted(self, conversation_id: str, activity: ActivityParams) -> SentActivity:
         """
         Create a new targeted activity in a conversation.
 
         Targeted activities are only visible to the specified recipient.
 
+        .. warning:: Preview
+            This API is in preview and may change in the future.
+            Diagnostic: ExperimentalTeamsTargeted
+
         Args:
             conversation_id: The ID of the conversation
             activity: The activity to create
@@ -146,10 +152,15 @@ async def create_targeted(self, conversation_id: str, activity: ActivityParams)
         id = response.json().get("id", _PLACEHOLDER_ACTIVITY_ID)
         return SentActivity(id=id, activity_params=activity)
 
+    @experimental("ExperimentalTeamsTargeted")
     async def update_targeted(self, conversation_id: str, activity_id: str, activity: ActivityParams) -> SentActivity:
         """
         Update an existing targeted activity in a conversation.
 
+        .. warning:: Preview
+            This API is in preview and may change in the future.
+            Diagnostic: ExperimentalTeamsTargeted
+
         Args:
             conversation_id: The ID of the conversation
             activity_id: The ID of the activity to update
@@ -165,10 +176,15 @@ async def update_targeted(self, conversation_id: str, activity_id: str, activity
         id = response.json()["id"]
         return SentActivity(id=id, activity_params=activity)
 
+    @experimental("ExperimentalTeamsTargeted")
     async def delete_targeted(self, conversation_id: str, activity_id: str) -> None:
         """
         Delete a targeted activity from a conversation.
 
+        .. warning:: Preview
+            This API is in preview and may change in the future.
+            Diagnostic: ExperimentalTeamsTargeted
+
         Args:
             conversation_id: The ID of the conversation
             activity_id: The ID of the activity to delete
diff --git a/packages/api/src/microsoft_teams/api/clients/conversation/client.py b/packages/api/src/microsoft_teams/api/clients/conversation/client.py
index ff2a7a37..7ad5aa01 100644
--- a/packages/api/src/microsoft_teams/api/clients/conversation/client.py
+++ b/packages/api/src/microsoft_teams/api/clients/conversation/client.py
@@ -88,10 +88,10 @@ def __init__(
             api_client_settings: Optional API client settings.
         """
         super().__init__(options, api_client_settings)
-        self.service_url = service_url
+        self.service_url = service_url.rstrip("/")
 
-        self._activities_client = ConversationActivityClient(service_url, self.http, self._api_client_settings)
-        self._members_client = ConversationMemberClient(service_url, self.http, self._api_client_settings)
+        self._activities_client = ConversationActivityClient(self.service_url, self.http, self._api_client_settings)
+        self._members_client = ConversationMemberClient(self.service_url, self.http, self._api_client_settings)
 
     @property
     def http(self) -> Client:
diff --git a/packages/api/src/microsoft_teams/api/clients/conversation/member.py b/packages/api/src/microsoft_teams/api/clients/conversation/member.py
index a4e65aa5..f46692d3 100644
--- a/packages/api/src/microsoft_teams/api/clients/conversation/member.py
+++ b/packages/api/src/microsoft_teams/api/clients/conversation/member.py
@@ -32,7 +32,7 @@ def __init__(
             api_client_settings: Optional API client settings.
         """
         super().__init__(http_client, api_client_settings)
-        self.service_url = service_url
+        self.service_url = service_url.rstrip("/")
 
     async def get(self, conversation_id: str) -> List[TeamsChannelAccount]:
         """
diff --git a/packages/api/src/microsoft_teams/api/clients/meeting/client.py b/packages/api/src/microsoft_teams/api/clients/meeting/client.py
index ef817572..7b467fbd 100644
--- a/packages/api/src/microsoft_teams/api/clients/meeting/client.py
+++ b/packages/api/src/microsoft_teams/api/clients/meeting/client.py
@@ -30,7 +30,7 @@ def __init__(
             api_client_settings: Optional API client settings.
         """
         super().__init__(options, api_client_settings)
-        self.service_url = service_url
+        self.service_url = service_url.rstrip("/")
 
     async def get_by_id(self, id: str) -> MeetingInfo:
         """
diff --git a/packages/api/src/microsoft_teams/api/clients/reaction/client.py b/packages/api/src/microsoft_teams/api/clients/reaction/client.py
index dea23613..a1a20a94 100644
--- a/packages/api/src/microsoft_teams/api/clients/reaction/client.py
+++ b/packages/api/src/microsoft_teams/api/clients/reaction/client.py
@@ -5,6 +5,7 @@
 
 from typing import Optional
 
+from microsoft_teams.common.experimental import experimental
 from microsoft_teams.common.http import Client
 
 from ...models.message import MessageReactionType
@@ -12,9 +13,14 @@
 from ..base_client import BaseClient
 
 
+@experimental("ExperimentalTeamsReactions")
 class ReactionClient(BaseClient):
     """
     Client for working with app message reactions for a given conversation/activity.
+
+    .. warning:: Preview
+        This API is in preview and may change in the future.
+        Diagnostic: ExperimentalTeamsReactions
     """
 
     def __init__(
@@ -32,7 +38,7 @@ def __init__(
             api_client_settings: Optional API client settings.
         """
         super().__init__(http_client, api_client_settings)
-        self.service_url = service_url
+        self.service_url = service_url.rstrip("/")
 
     async def add(
         self,
diff --git a/packages/api/src/microsoft_teams/api/clients/team/client.py b/packages/api/src/microsoft_teams/api/clients/team/client.py
index 1d3ddd60..ddda3b10 100644
--- a/packages/api/src/microsoft_teams/api/clients/team/client.py
+++ b/packages/api/src/microsoft_teams/api/clients/team/client.py
@@ -30,7 +30,7 @@ def __init__(
             api_client_settings: Optional API client settings.
         """
         super().__init__(options, api_client_settings)
-        self.service_url = service_url
+        self.service_url = service_url.rstrip("/")
 
     async def get_by_id(self, id: str) -> TeamDetails:
         """
diff --git a/packages/api/src/microsoft_teams/api/models/account.py b/packages/api/src/microsoft_teams/api/models/account.py
index 28645068..5f3100c5 100644
--- a/packages/api/src/microsoft_teams/api/models/account.py
+++ b/packages/api/src/microsoft_teams/api/models/account.py
@@ -31,6 +31,13 @@ class Account(CustomBaseModel):
     """
     Additional properties for the account.
     """
+    is_targeted: Optional[bool] = None
+    """Indicates targeted-message routing for this recipient.
+
+    .. warning:: Preview
+        This field is in preview and may change in the future.
+        Diagnostic: ExperimentalTeamsTargeted
+    """
     name: Optional[str] = None
     """
     The name of the account.
diff --git a/packages/api/src/microsoft_teams/api/models/activity.py b/packages/api/src/microsoft_teams/api/models/activity.py
index 17f7baac..e021f779 100644
--- a/packages/api/src/microsoft_teams/api/models/activity.py
+++ b/packages/api/src/microsoft_teams/api/models/activity.py
@@ -3,6 +3,7 @@
 Licensed under the MIT License.
 """
 
+import warnings
 from datetime import datetime
 from typing import Any, List, Optional, Self
 
@@ -24,6 +25,7 @@
 from microsoft_teams.api.models.entity.entity import Entity
 from microsoft_teams.api.models.entity.message_entity import MessageEntity
 from microsoft_teams.api.models.meetings.meeting_info import MeetingInfo
+from microsoft_teams.common.experimental import ExperimentalWarning
 
 from .custom_base_model import CustomBaseModel
 
@@ -94,9 +96,6 @@ class ActivityInput(_ActivityBase):
     recipient: Optional[Account] = None
     """Identifies the recipient of the message."""
 
-    is_targeted: Optional[bool] = None
-    """Indicates if this is a targeted message visible only to a specific recipient."""
-
     @property
     def channel(self) -> Optional[ChannelInfo]:
         """Information about the channel in which the message was sent."""
@@ -159,15 +158,25 @@ def with_recipient(self, value: Account, is_targeted: Optional[bool] = None) ->
         Args:
             value: The recipient account
             is_targeted: If True, marks this as a targeted message visible only to this
-                recipient. If False, explicitly clears targeting. If None (the default),
-                the existing is_targeted value is left unchanged.
+                recipient. If False or None (the default), targeted routing is cleared.
+
+                .. warning:: Preview
+                    The ``is_targeted`` parameter is in preview and may change or be
+                    removed in future versions. Diagnostic: ExperimentalTeamsTargeted
 
         Returns:
             Self for method chaining
         """
-        self.recipient = value
-        if is_targeted is not None:
-            self.is_targeted = is_targeted
+        recipient = value.model_copy()
+        recipient.is_targeted = True if is_targeted is True else None
+        self.recipient = recipient
+        if is_targeted is True:
+            warnings.warn(
+                "The is_targeted parameter of with_recipient is in preview and may change "
+                "or be removed in future versions. Diagnostic: ExperimentalTeamsTargeted",
+                ExperimentalWarning,
+                stacklevel=2,
+            )
         return self
 
     def with_service_url(self, value: str) -> Self:
diff --git a/packages/api/tests/unit/test_api_client.py b/packages/api/tests/unit/test_api_client.py
new file mode 100644
index 00000000..b1b439e4
--- /dev/null
+++ b/packages/api/tests/unit/test_api_client.py
@@ -0,0 +1,68 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+# pyright: basic
+
+import pytest
+from microsoft_teams.api.clients import ApiClient, ReactionClient
+from microsoft_teams.common.http import Client, ClientOptions
+
+
+@pytest.mark.unit
+class TestApiClientReactionsProperty:
+    """Tests for the reactions property on ApiClient."""
+
+    def test_reactions_first_access_creates_reaction_client(self, mock_http_client):
+        """Test that accessing reactions for the first time creates a ReactionClient."""
+        client = ApiClient("https://mock.service.url", mock_http_client)
+        assert client._reactions is None
+
+        reactions = client.reactions
+
+        assert reactions is not None
+        assert isinstance(reactions, ReactionClient)
+
+    def test_reactions_second_access_returns_cached_client(self, mock_http_client):
+        """Test that the reactions property returns the same instance on subsequent accesses."""
+        client = ApiClient("https://mock.service.url", mock_http_client)
+        first = client.reactions
+        second = client.reactions
+        assert first is second
+
+    def test_http_setter_updates_all_sub_clients(self, mock_http_client):
+        """Test that setting http propagates the new client to all sub-clients."""
+        client = ApiClient("https://mock.service.url", mock_http_client)
+        new_http = Client(ClientOptions(base_url="https://new.service.url"))
+
+        client.http = new_http
+
+        assert client._http is new_http
+        assert client.bots.http is new_http
+        assert client.conversations.http is new_http
+        assert client.users.http is new_http
+        assert client.teams.http is new_http
+        assert client.meetings.http is new_http
+
+    def test_http_setter_without_reactions_does_not_error(self, mock_http_client):
+        """Test that setting http works correctly when reactions has never been accessed."""
+        client = ApiClient("https://mock.service.url", mock_http_client)
+        assert client._reactions is None
+
+        new_http = Client(ClientOptions(base_url="https://new.service.url"))
+        client.http = new_http
+
+        assert client._http is new_http
+        assert client._reactions is None
+
+    def test_http_setter_also_updates_reactions_when_instantiated(self, mock_http_client):
+        """Test that setting http propagates to the reactions client when it exists."""
+        client = ApiClient("https://mock.service.url", mock_http_client)
+        _ = client.reactions
+        assert client._reactions is not None
+
+        new_http = Client(ClientOptions(base_url="https://new.service.url"))
+        client.http = new_http
+
+        assert client._reactions.http is new_http
+        assert client._http is new_http
diff --git a/packages/api/tests/unit/test_conversation_client.py b/packages/api/tests/unit/test_conversation_client.py
index 8c440fb8..86053b3d 100644
--- a/packages/api/tests/unit/test_conversation_client.py
+++ b/packages/api/tests/unit/test_conversation_client.py
@@ -28,6 +28,15 @@ def test_conversation_client_initialization(self, mock_http_client):
         assert client.activities_client is not None
         assert client.members_client is not None
 
+    def test_conversation_client_strips_trailing_slash(self, mock_http_client):
+        """Test ConversationClient strips trailing slash from service_url."""
+        service_url = "https://test.service.url/"
+        client = ConversationClient(service_url, mock_http_client)
+
+        assert client.service_url == "https://test.service.url"
+        assert client.activities_client.service_url == "https://test.service.url"
+        assert client.members_client.service_url == "https://test.service.url"
+
     def test_conversation_client_initialization_with_options(self):
         """Test ConversationClient initialization with ClientOptions."""
 
diff --git a/packages/api/tests/unit/test_meeting_client.py b/packages/api/tests/unit/test_meeting_client.py
index 595ee622..7a2701e8 100644
--- a/packages/api/tests/unit/test_meeting_client.py
+++ b/packages/api/tests/unit/test_meeting_client.py
@@ -50,3 +50,10 @@ def test_http_client_property(self, mock_http_client):
         client.http = new_http_client
 
         assert client.http == new_http_client
+
+    def test_meeting_client_strips_trailing_slash(self, mock_http_client):
+        """Test MeetingClient strips trailing slash from service_url."""
+        service_url = "https://test.service.url/"
+        client = MeetingClient(service_url, mock_http_client)
+
+        assert client.service_url == "https://test.service.url"
diff --git a/packages/api/tests/unit/test_message_activities.py b/packages/api/tests/unit/test_message_activities.py
index 827cfa27..1109a8ad 100644
--- a/packages/api/tests/unit/test_message_activities.py
+++ b/packages/api/tests/unit/test_message_activities.py
@@ -50,6 +50,21 @@ def create_message_activity(self, text: str = "Hello world!") -> MessageActivity
         )
         return activity
 
+    def create_incoming_message_activity(self, text: str = "Hello world!") -> MessageActivity:
+        """Create a basic incoming MessageActivity for testing"""
+        from_account = Account(id="bot-123", name="Test Bot", role="bot")
+        recipient = Account(id="user-456", name="Test User", role="user")
+        conversation = ConversationAccount(id="conv-789", conversation_type="personal")
+
+        activity = MessageActivity(
+            id="msg-123",
+            text=text,
+            from_=from_account,
+            conversation=conversation,
+            recipient=recipient,
+        )
+        return activity
+
     def test_message_activity_creation(self):
         """Test basic message activity creation"""
         activity = self.create_message_activity("Test message")
@@ -57,11 +72,6 @@ def test_message_activity_creation(self):
         assert activity.text == "Test message"
         assert activity.id == "msg-123"
 
-    def test_message_activity_type_property(self):
-        """Test that type property returns correct value"""
-        activity = self.create_message_activity()
-        assert activity.type == "message"
-
     def test_message_activity_text_defaults_to_empty_string(self):
         """Test that text field defaults to empty string in MessageActivity"""
         from_account = Account(id="bot-123", name="Test Bot", role="bot")
@@ -347,6 +357,94 @@ def test_complex_message_building(self):
         assert activity.delivery_mode == "notification"
         assert activity.input_hint == "acceptingInput"
 
+    def test_is_recipient_mentioned_no_entities_received(self):
+        """Test MessageActivity.is_recipient_mentioned when no entities exist"""
+        activity = self.create_incoming_message_activity("Hello world!")
+        assert activity.is_recipient_mentioned() is False
+
+    def test_is_recipient_mentioned_no_recipient_received(self):
+        """Test MessageActivity.is_recipient_mentioned when recipient is None"""
+        from_account = Account(id="bot-123", name="Test Bot", role="bot")
+        conversation = ConversationAccount(id="conv-789", conversation_type="personal")
+        activity = MessageActivity(
+            id="msg-123",
+            text="Hello <at>Bot</at>!",
+            from_=from_account,
+            conversation=conversation,
+            recipient=Account(id="r-1", name="R"),
+        )
+        # Override recipient to None to test that branch
+        activity.recipient = None  # type: ignore[assignment]
+        account = Account(id="r-1", name="R", role="bot")
+        mention = MentionEntity(mentioned=account, text="<at>R</at>")
+        activity.entities = [mention]
+
+        assert activity.is_recipient_mentioned() is False
+
+    def test_is_recipient_mentioned_when_mentioned_received(self):
+        """Test MessageActivity.is_recipient_mentioned returns True when recipient is mentioned"""
+        activity = self.create_incoming_message_activity("Hello <at>Test User</at>!")
+        recipient = Account(id="user-456", name="Test User", role="user")
+        activity.recipient = recipient
+        mention = MentionEntity(mentioned=recipient, text="<at>Test User</at>")
+        activity.entities = [mention]
+
+        assert activity.is_recipient_mentioned() is True
+
+    def test_is_recipient_mentioned_not_mentioned_received(self):
+        """Test MessageActivity.is_recipient_mentioned returns False when recipient is not mentioned"""
+        activity = self.create_incoming_message_activity("Hello <at>Other</at>!")
+        recipient = Account(id="user-456", name="Test User", role="user")
+        activity.recipient = recipient
+        other = Account(id="other-999", name="Other", role="user")
+        mention = MentionEntity(mentioned=other, text="<at>Other</at>")
+        activity.entities = [mention]
+
+        assert activity.is_recipient_mentioned() is False
+
+    def test_get_account_mention_no_entities_received(self):
+        """Test MessageActivity.get_account_mention returns None when no entities"""
+        activity = self.create_incoming_message_activity("Hello world!")
+        # No entities set
+        result = activity.get_account_mention("user-456")
+        assert result is None
+
+    def test_get_account_mention_found_received(self):
+        """Test MessageActivity.get_account_mention returns MentionEntity when found"""
+        activity = self.create_incoming_message_activity("Hello <at>Test User</at>!")
+        account = Account(id="user-456", name="Test User", role="user")
+        mention = MentionEntity(mentioned=account, text="<at>Test User</at>")
+        activity.entities = [mention]
+
+        result = activity.get_account_mention("user-456")
+
+        assert result is not None
+        assert isinstance(result, MentionEntity)
+        assert result.mentioned.id == "user-456"
+        assert result.text == "<at>Test User</at>"
+
+    def test_get_account_mention_not_found_received(self):
+        """Test MessageActivity.get_account_mention returns None when account not in mentions"""
+        activity = self.create_incoming_message_activity("Hello <at>Test User</at>!")
+        account = Account(id="user-456", name="Test User", role="user")
+        mention = MentionEntity(mentioned=account, text="<at>Test User</at>")
+        activity.entities = [mention]
+
+        result = activity.get_account_mention("nonexistent-id")
+        assert result is None
+
+    def test_strip_mentions_text_updates_text_received(self):
+        """Test MessageActivity.strip_mentions_text sets text when stripped_text is not None"""
+        activity = self.create_incoming_message_activity("Hi <at>Test User</at>! How are you?")
+        account = Account(id="user-456", name="Test User", role="user")
+        mention = MentionEntity(mentioned=account, text="<at>Test User</at>")
+        activity.entities = [mention]
+
+        result = activity.strip_mentions_text()
+
+        assert result is activity
+        assert activity.text == "Hi ! How are you?"
+
 
 class TestMessageDeleteActivity:
     """Test MessageDeleteActivity functionality"""
@@ -380,12 +478,6 @@ def test_message_delete_channel_data_defaults(self):
         channel_data = MessageDeleteChannelData()
         assert channel_data.event_type == "softDeleteMessage"
 
-    def test_message_delete_activity_type_property(self):
-        """Test that type property returns correct value"""
-        activity = self.create_message_delete_activity("delete-456")
-
-        assert activity.type == "messageDelete"
-
 
 class TestMessageUpdateActivity:
     """Test MessageUpdateActivity functionality"""
@@ -450,12 +542,6 @@ def test_message_update_activity_optional_fields(self):
         assert activity.expiration == expiration
         assert activity.value == {"custom": "data"}
 
-    def test_message_update_activity_type_property(self):
-        """Test that type property returns correct value"""
-        activity = self.create_message_update_activity("update-999", "Test")
-
-        assert activity.type == "messageUpdate"
-
 
 class TestMessageReactionActivity:
     """Test MessageReactionActivity functionality"""
@@ -492,12 +578,6 @@ def test_message_reaction_activity_creation(self):
         assert activity.reactions_added is None
         assert activity.reactions_removed is None
 
-    def test_message_reaction_activity_type_property(self):
-        """Test that type property returns correct value"""
-        activity = self.create_message_reaction_activity("reaction-456")
-
-        assert activity.type == "messageReaction"
-
     def test_add_reaction_single(self):
         """Test adding a single reaction"""
         activity = self.create_message_reaction_activity("reaction-789")
@@ -778,12 +858,12 @@ def test_all_activity_types_have_correct_type(self):
             assert activity.type == expected_type
 
     def test_with_recipient_defaults_to_not_targeted(self):
-        """Test that with_recipient without is_targeted flag leaves is_targeted unchanged"""
+        """Test that with_recipient without is_targeted clears recipient-targeting."""
         account = Account(id="user-123", name="Test User", role="user")
         activity = MessageActivityInput(text="hello").with_recipient(account)
 
-        assert activity.is_targeted is None
         assert activity.recipient is not None
+        assert activity.recipient.is_targeted is None
         assert activity.recipient.id == "user-123"
 
     def test_with_recipient_sets_is_targeted_and_recipient(self):
@@ -791,8 +871,8 @@ def test_with_recipient_sets_is_targeted_and_recipient(self):
         account = Account(id="user-123", name="Test User", role="user")
         activity = MessageActivityInput(text="hello").with_recipient(account, is_targeted=True)
 
-        assert activity.is_targeted is True
         assert activity.recipient is not None
+        assert activity.recipient.is_targeted is True
         assert activity.recipient.id == "user-123"
         assert activity.recipient.name == "Test User"
         assert activity.recipient.role == "user"
@@ -803,6 +883,16 @@ def test_with_recipient_maintains_fluent_chaining(self):
         activity = MessageActivityInput(text="hello").with_recipient(account, is_targeted=True).add_text(" world")
 
         assert activity.text == "hello world"
-        assert activity.is_targeted is True
         assert activity.recipient is not None
+        assert activity.recipient.is_targeted is True
         assert activity.recipient.id == "user-123"
+
+    def test_with_recipient_targeted_serializes_on_recipient(self):
+        """Test that targeted routing serializes as recipient.isTargeted in payload JSON."""
+        account = Account(id="user-123", name="Test User", role="user")
+        activity = MessageActivityInput(text="targeted message").with_recipient(account, is_targeted=True)
+
+        data = activity.model_dump(by_alias=True, exclude_none=True)
+
+        assert "recipient" in data
+        assert data["recipient"]["isTargeted"] is True
diff --git a/packages/api/tests/unit/test_reaction_client.py b/packages/api/tests/unit/test_reaction_client.py
index 0179ffcd..f1786884 100644
--- a/packages/api/tests/unit/test_reaction_client.py
+++ b/packages/api/tests/unit/test_reaction_client.py
@@ -22,6 +22,13 @@ def test_reaction_client_initialization(self, mock_http_client):
         assert client.http == mock_http_client
         assert client.service_url == service_url
 
+    def test_reaction_client_strips_trailing_slash(self, mock_http_client):
+        """Test ReactionClient strips trailing slash from service_url."""
+        service_url = "https://test.service.url/"
+        client = ReactionClient(service_url, mock_http_client)
+
+        assert client.service_url == "https://test.service.url"
+
     def test_reaction_client_initialization_with_options(self):
         """Test ReactionClient initialization with ClientOptions."""
         service_url = "https://test.service.url"
diff --git a/packages/api/tests/unit/test_team_client.py b/packages/api/tests/unit/test_team_client.py
index 83e22b1e..a47b5edb 100644
--- a/packages/api/tests/unit/test_team_client.py
+++ b/packages/api/tests/unit/test_team_client.py
@@ -49,3 +49,10 @@ def test_http_client_property(self, mock_http_client):
         client.http = new_http_client
 
         assert client.http == new_http_client
+
+    def test_team_client_strips_trailing_slash(self, mock_http_client):
+        """Test TeamClient strips trailing slash from service_url."""
+        service_url = "https://test.service.url/"
+        client = TeamClient(service_url, mock_http_client)
+
+        assert client.service_url == "https://test.service.url"
diff --git a/packages/apps/pyproject.toml b/packages/apps/pyproject.toml
index 40b153c4..cc145ad5 100644
--- a/packages/apps/pyproject.toml
+++ b/packages/apps/pyproject.toml
@@ -15,7 +15,7 @@ dependencies = [
     "microsoft-teams-common",
     "uvicorn>=0.34.3",
     "cryptography>=3.4.0",
-    "pyjwt[crypto]>=2.10.0",
+    "pyjwt[crypto]>=2.12.0",
     "dependency-injector>=4.48.1",
     "msal>=1.33.0",
     "python-dotenv>=1.0.0",
diff --git a/packages/apps/scripts/generate_handlers.py b/packages/apps/scripts/generate_handlers.py
index e3286260..3a84f2cd 100644
--- a/packages/apps/scripts/generate_handlers.py
+++ b/packages/apps/scripts/generate_handlers.py
@@ -43,7 +43,6 @@ def generate_imports() -> str:
     """Generate import statements for the generated file."""
     imports = {
         "from abc import ABC, abstractmethod",
-        "from logging import Logger",
         "from typing import Callable, Optional, overload",
         "from microsoft_teams.api import InvokeResponse",
         "from .activity_context import ActivityContext",
@@ -113,14 +112,14 @@ def generate_method(config: ActivityConfig, config_key: str) -> str:
 
     return f'''    @overload
     def {method_name}(self, handler: {handler_type}) -> {handler_type}: ...
-        
+
     @overload
     def {method_name}(self) -> Callable[[{handler_type}], {handler_type}]: ...
-        
+
     def {method_name}(self, handler: Optional[{handler_type}] = None) -> {union_type}:
         """Register a {activity_name} activity handler."""
         def decorator(func: {handler_type}) -> {handler_type}:
-            validate_handler_type(self.logger, func, {input_class_name}, "{method_name}", "{input_class_name}")
+            validate_handler_type(func, {input_class_name}, "{method_name}", "{input_class_name}")
             config = ACTIVITY_ROUTES["{config_key}"]
             self.router.add_handler(config.selector, func)
             return func
@@ -148,12 +147,6 @@ def router(self) -> ActivityRouter:
         """The activity router instance. Must be implemented by the concrete class."""
         pass
 
-    @property
-    @abstractmethod
-    def logger(self) -> Logger:
-        """The logger instance used by the app."""
-        pass
-
 {methods_code}'''
 
 
diff --git a/packages/apps/src/microsoft_teams/apps/__init__.py b/packages/apps/src/microsoft_teams/apps/__init__.py
index 2aa32332..f5aa4080 100644
--- a/packages/apps/src/microsoft_teams/apps/__init__.py
+++ b/packages/apps/src/microsoft_teams/apps/__init__.py
@@ -3,19 +3,31 @@
 Licensed under the MIT License.
 """
 
+import logging
+
 from . import auth, contexts, events, plugins
 from .app import App
 from .auth import *  # noqa: F403
 from .contexts import *  # noqa: F403
 from .events import *  # noqa: F401, F403
-from .http_plugin import HttpPlugin
+from .http import FastAPIAdapter, HttpServer, HttpServerAdapter
 from .http_stream import HttpStream
 from .options import AppOptions
 from .plugins import *  # noqa: F401, F403
 from .routing import ActivityContext
 
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
 # Combine all exports from submodules
-__all__: list[str] = ["App", "AppOptions", "HttpPlugin", "HttpStream", "ActivityContext"]
+__all__: list[str] = [
+    "App",
+    "AppOptions",
+    "HttpServer",
+    "HttpServerAdapter",
+    "FastAPIAdapter",
+    "HttpStream",
+    "ActivityContext",
+]
 __all__.extend(auth.__all__)
 __all__.extend(events.__all__)
 __all__.extend(plugins.__all__)
diff --git a/packages/apps/src/microsoft_teams/apps/activity_sender.py b/packages/apps/src/microsoft_teams/apps/activity_sender.py
new file mode 100644
index 00000000..78d02ae8
--- /dev/null
+++ b/packages/apps/src/microsoft_teams/apps/activity_sender.py
@@ -0,0 +1,91 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+import logging
+from typing import cast
+
+from microsoft_teams.api import (
+    ActivityParams,
+    ApiClient,
+    ConversationReference,
+    MessageActivityInput,
+    SentActivity,
+)
+from microsoft_teams.common import Client
+
+from .http_stream import HttpStream
+from .plugins.streamer import StreamerProtocol
+
+logger = logging.getLogger(__name__)
+
+
+class ActivitySender:
+    """
+    Handles sending activities to the Bot Framework.
+    Separate from transport concerns (HTTP, WebSocket, etc.)
+    """
+
+    def __init__(self, client: Client):
+        """
+        Initialize ActivitySender.
+
+        Args:
+            client: HTTP client with token provider configured
+        """
+        self._client = client
+
+    async def send(self, activity: ActivityParams, ref: ConversationReference) -> SentActivity:
+        """
+        Send an activity to the Bot Framework.
+
+        Args:
+            activity: The activity to send
+            ref: The conversation reference
+
+        Returns:
+            The sent activity with id and other server-populated fields
+        """
+        # Create API client for this conversation's service URL
+        api = ApiClient(service_url=ref.service_url, options=self._client)
+
+        # Merge activity with conversation reference
+        activity.from_ = ref.bot
+        activity.conversation = ref.conversation
+
+        is_targeted = (
+            isinstance(activity, MessageActivityInput)
+            and activity.recipient is not None
+            and activity.recipient.is_targeted is True
+        )
+        is_update = hasattr(activity, "id") and activity.id
+        activities = api.conversations.activities(ref.conversation.id)
+
+        if is_update:
+            activity_id = cast(str, activity.id)
+            if is_targeted:
+                res = await activities.update_targeted(activity_id, activity)
+            else:
+                res = await activities.update(activity_id, activity)
+            return SentActivity.merge(activity, res)
+
+        if is_targeted:
+            res = await activities.create_targeted(activity)
+        else:
+            res = await activities.create(activity)
+        return SentActivity.merge(activity, res)
+
+    def create_stream(self, ref: ConversationReference) -> StreamerProtocol:
+        """
+        Create a new activity stream for real-time updates.
+
+        Args:
+            ref: The conversation reference
+
+        Returns:
+            A new streaming instance
+        """
+        # Create API client for this conversation's service URL
+        api = ApiClient(ref.service_url, self._client)
+        return HttpStream(api, ref)
diff --git a/packages/apps/src/microsoft_teams/apps/app.py b/packages/apps/src/microsoft_teams/apps/app.py
index edcd554f..2c76c9c0 100644
--- a/packages/apps/src/microsoft_teams/apps/app.py
+++ b/packages/apps/src/microsoft_teams/apps/app.py
@@ -5,13 +5,12 @@
 
 import asyncio
 import importlib.metadata
+import logging
 import os
-from logging import Logger
 from typing import Any, Awaitable, Callable, List, Optional, TypeVar, Union, Unpack, cast, overload
 
 from dependency_injector import providers
 from dotenv import find_dotenv, load_dotenv
-from fastapi import Request
 from microsoft_teams.api import (
     Account,
     ActivityBase,
@@ -27,14 +26,15 @@
     TokenCredentials,
 )
 from microsoft_teams.cards import AdaptiveCard
-from microsoft_teams.common import Client, ClientOptions, ConsoleLogger, EventEmitter, LocalStorage
+from microsoft_teams.common import Client, ClientOptions, EventEmitter, LocalStorage
 
+from .activity_sender import ActivitySender
 from .app_events import EventManager
 from .app_oauth import OauthHandlers
 from .app_plugins import PluginProcessor
 from .app_process import ActivityProcessor
 from .auth import TokenValidator
-from .auth.remote_function_jwt_middleware import remote_function_jwt_validation
+from .auth.remote_function_jwt_middleware import validate_remote_function_request
 from .container import Container
 from .contexts.function_context import FunctionContext
 from .events import (
@@ -45,9 +45,10 @@
     get_event_type_from_signature,
     is_registered_event,
 )
-from .http_plugin import HttpPlugin
+from .http import FastAPIAdapter, HttpServer
+from .http.adapter import HttpRequest, HttpResponse
 from .options import AppOptions, InternalAppOptions
-from .plugins import PluginBase, PluginStartEvent, get_metadata
+from .plugins import PluginBase, PluginStartEvent
 from .routing import ActivityHandlerMixin, ActivityRouter
 from .routing.activity_context import ActivityContext
 from .token_manager import TokenManager
@@ -60,6 +61,8 @@
 
 USER_AGENT = f"teams.py[apps]/{version}"
 
+logger = logging.getLogger(__name__)
+
 
 class App(ActivityHandlerMixin):
     """
@@ -71,7 +74,6 @@ class App(ActivityHandlerMixin):
     def __init__(self, **options: Unpack[AppOptions]):
         self.options = InternalAppOptions.from_typeddict(options)
 
-        self.log = self.options.logger or ConsoleLogger().create_logger("@teams/app")
         self.storage = self.options.storage or LocalStorage()
 
         self.http_client = Client(
@@ -87,14 +89,12 @@ def __init__(self, **options: Unpack[AppOptions]):
 
         self._token_manager = TokenManager(
             credentials=self.credentials,
-            logger=self.log,
         )
 
         self.container = Container()
         self.container.set_provider("id", providers.Object(self.id))
         self.container.set_provider("credentials", providers.Object(self.credentials))
         self.container.set_provider("bot_token", providers.Factory(lambda: self._get_bot_token))
-        self.container.set_provider("logger", providers.Object(self.log))
         self.container.set_provider("storage", providers.Object(self.storage))
         self.container.set_provider(self.http_client.__class__.__name__, providers.Factory(lambda: self.http_client))
 
@@ -110,38 +110,32 @@ def __init__(self, **options: Unpack[AppOptions]):
 
         plugins: List[PluginBase] = list(self.options.plugins)
 
-        http_plugin = None
-        for i, plugin in enumerate(plugins):
-            meta = get_metadata(type(plugin))
-            if meta.name == "http":
-                http_plugin = plugin
-                plugins.pop(i)
-                break
-
-        if not http_plugin:
-            http_plugin = HttpPlugin(logger=self.log, skip_auth=self.options.skip_auth)
-
-        plugins.insert(0, http_plugin)
-        self.http = cast(HttpPlugin, http_plugin)
+        # Create HttpServer (not a plugin — owned directly by App)
+        adapter = self.options.http_server_adapter or FastAPIAdapter()
+        self.server = HttpServer(adapter, messaging_endpoint=self.options.messaging_endpoint)
+        self.container.set_provider("HttpServer", providers.Object(self.server))
 
         self._port: Optional[int] = None
-        self._running = False
+        self._initialized = False
+
+        # initialize ActivitySender for sending activities
+        self.activity_sender = ActivitySender(self.http_client.clone(ClientOptions(token=self._get_bot_token)))
 
         # initialize all event, activity, and plugin processors
         self.activity_processor = ActivityProcessor(
             self._router,
-            self.log,
             self.id,
             self.storage,
             self.options.default_connection_name,
             self.http_client,
             self._token_manager,
             self.options.api_client_settings,
+            self.activity_sender,
         )
         self.event_manager = EventManager(self._events)
         self.activity_processor.event_manager = self.event_manager
         self._plugin_processor = PluginProcessor(
-            self.container, self.event_manager, self.log, self._events, self.activity_processor
+            self.container, self.event_manager, self._events, self.activity_processor
         )
         self.plugins = self._plugin_processor.initialize_plugins(plugins)
 
@@ -157,7 +151,7 @@ def __init__(self, **options: Unpack[AppOptions]):
         self.entra_token_validator: Optional[TokenValidator] = None
         if self.credentials and hasattr(self.credentials, "client_id"):
             self.entra_token_validator = TokenValidator.for_entra(
-                self.credentials.client_id, self.credentials.tenant_id, logger=self.log
+                self.credentials.client_id, self.credentials.tenant_id
             )
 
     @property
@@ -165,16 +159,6 @@ def port(self) -> Optional[int]:
         """Port the app is running on."""
         return self._port
 
-    @property
-    def is_running(self) -> bool:
-        """Whether the app is currently running."""
-        return self._running
-
-    @property
-    def logger(self) -> Logger:
-        """The logger instance used by the app."""
-        return self.log
-
     @property
     def events(self) -> EventEmitter[EventType]:
         """The event emitter instance used by the app."""
@@ -192,6 +176,41 @@ def id(self) -> Optional[str]:
             return None
         return self.credentials.client_id
 
+    async def initialize(self) -> None:
+        """
+        Initialize the Teams application without starting the HTTP server.
+
+        This method sets up credentials, token manager, activity sender, and plugins,
+        allowing you to use app.send() for proactive messaging without running a server.
+        """
+        if self._initialized:
+            logger.warning("App is already initialized")
+            return
+
+        try:
+            # Initialize plugins first (they may register routes, e.g. BotBuilder's /api/messages)
+            for plugin in self.plugins:
+                self._plugin_processor.inject(plugin)
+                if hasattr(plugin, "on_init") and callable(plugin.on_init):
+                    await plugin.on_init()
+
+            # Initialize HttpServer (JWT validation + messaging endpoint route)
+            self.server.on_request = self._process_activity_event
+            self.server.initialize(credentials=self.credentials, skip_auth=self.options.skip_auth)
+
+            self._initialized = True
+            logger.info("Teams app initialized successfully")
+
+        except Exception as error:
+            logger.error(f"Failed to initialize app: {error}")
+            self._events.emit("error", ErrorEvent(error, context={"method": "initialize"}))
+            raise
+
+    async def _process_activity_event(self, event: Any) -> Any:
+        """Process an activity event through the app pipeline. Used as HttpServer.on_request callback."""
+        await self.event_manager.on_activity(event)
+        return await self.activity_processor.process_activity(self.plugins, event)
+
     async def start(self, port: Optional[int] = None) -> None:
         """
         Start the Teams application and begin serving HTTP requests.
@@ -202,73 +221,68 @@ async def start(self, port: Optional[int] = None) -> None:
         Args:
             port: Port to listen on (defaults to PORT env var or 3978)
         """
-        if self._running:
-            self.log.warning("App is already running")
-            return
-
         self._port = port or int(os.getenv("PORT", "3978"))
 
         try:
-            for plugin in self.plugins:
-                # Inject the dependencies
-                self._plugin_processor.inject(plugin)
-                if hasattr(plugin, "on_init") and callable(plugin.on_init):
-                    await plugin.on_init()
-
-            # Set callback and start HTTP plugin
-            async def on_http_ready() -> None:
-                self.log.info("Teams app started successfully")
-                assert self._port is not None, "Port must be set before emitting start event"
-                self._events.emit("start", StartEvent(port=self._port))
-                self._running = True
-
-            self.http.on_ready_callback = on_http_ready
+            # Initialize the app if not already initialized
+            if not self._initialized:
+                await self.initialize()
 
+            # Start plugins and HTTP server concurrently (both may block with serve())
             tasks: List[Awaitable[Any]] = []
             event = PluginStartEvent(port=self._port)
             for plugin in self.plugins:
                 is_callable = hasattr(plugin, "on_start") and callable(plugin.on_start)
                 if is_callable:
                     tasks.append(plugin.on_start(event))
+
+            logger.info("Teams app started successfully")
+            self._events.emit("start", StartEvent(port=self._port))
+
+            tasks.append(self.server.adapter.start(self._port))
             await asyncio.gather(*tasks)
 
+        except (asyncio.CancelledError, KeyboardInterrupt):
+            logger.info("Teams app shutting down")
+            try:
+                await self._stop_plugins()
+            finally:
+                self._running = False
+                self._events.emit("stop", StopEvent())
+
         except Exception as error:
-            self._running = False
-            self.log.error(f"Failed to start app: {error}")
+            logger.error(f"Failed to start app: {error}")
             self._events.emit("error", ErrorEvent(error, context={"method": "start", "port": self._port}))
             raise
 
     async def stop(self) -> None:
         """Stop the Teams application."""
-        if not self._running:
-            return
-
         try:
-            # Set callback and stop HTTP plugin first
-            async def on_http_stopped() -> None:
-                # Stop all other plugins after HTTP is stopped
-                for plugin in reversed(self.plugins):
-                    is_callable = hasattr(plugin, "on_stop") and callable(plugin.on_stop)
-                    if plugin is not self.http and is_callable:
-                        await plugin.on_stop()
+            # Stop HTTP server first
+            await self.server.adapter.stop()
 
-                self._running = False
-                self.log.info("Teams app stopped")
-                self._events.emit("stop", StopEvent())
+            # Stop all plugins
+            for plugin in reversed(self.plugins):
+                is_callable = hasattr(plugin, "on_stop") and callable(plugin.on_stop)
+                if is_callable:
+                    await plugin.on_stop()
 
-            self.http.on_stopped_callback = on_http_stopped
-            await self.http.on_stop()
+            logger.info("Teams app stopped")
+            self._events.emit("stop", StopEvent())
 
         except Exception as error:
-            self.log.error(f"Failed to stop app: {error}")
+            logger.error(f"Failed to stop app: {error}")
             self._events.emit("error", ErrorEvent(error, context={"method": "stop"}))
             raise
 
     async def send(self, conversation_id: str, activity: str | ActivityParams | AdaptiveCard):
         """Send an activity proactively."""
 
+        if not self._initialized:
+            raise ValueError("app not initialized - call app.initialize() or app.start() first")
+
         if self.id is None:
-            raise ValueError("app not started")
+            raise ValueError("app credentials not configured")
 
         conversation_ref = ConversationReference(
             channel_id="msteams",
@@ -284,14 +298,7 @@ async def send(self, conversation_id: str, activity: str | ActivityParams | Adap
         else:
             activity = activity
 
-        # Validate targeted messages in proactive context
-        if isinstance(activity, MessageActivityInput) and activity.is_targeted and not activity.recipient:
-            raise ValueError(
-                "Targeted messages sent proactively must specify an explicit recipient account. "
-                "Use with_recipient(Account(...), is_targeted=True) with an explicit recipient account."
-            )
-
-        return await self.http.send(activity, conversation_ref)
+        return await self.activity_sender.send(activity, conversation_ref)
 
     def use(self, middleware: Callable[[ActivityContext[ActivityBase]], Awaitable[None]]) -> None:
         """Add middleware to run on all activities."""
@@ -305,14 +312,14 @@ def _init_credentials(self) -> Optional[Credentials]:
         token = self.options.token
         managed_identity_client_id = self.options.managed_identity_client_id or os.getenv("MANAGED_IDENTITY_CLIENT_ID")
 
-        self.log.debug(f"Using CLIENT_ID: {client_id}")
+        logger.debug(f"Using CLIENT_ID: {client_id}")
         if not tenant_id:
-            self.log.warning("TENANT_ID is not set, assuming multi-tenant app")
+            logger.warning("TENANT_ID is not set, assuming multi-tenant app")
         else:
-            self.log.debug(f"Using TENANT_ID: {tenant_id} (assuming single-tenant app)")
+            logger.debug(f"Using TENANT_ID: {tenant_id} (assuming single-tenant app)")
 
         if client_id and client_secret:
-            self.log.debug("Using client secret for auth")
+            logger.debug("Using client secret for auth")
             return ClientCredentials(client_id=client_id, client_secret=client_secret, tenant_id=tenant_id)
 
         if client_id and token:
@@ -320,7 +327,7 @@ def _init_credentials(self) -> Optional[Credentials]:
 
         if client_id:
             if managed_identity_client_id == "system":
-                self.log.debug("Using Federated Identity Credentials with system-assigned managed identity")
+                logger.debug("Using Federated Identity Credentials with system-assigned managed identity")
                 return FederatedIdentityCredentials(
                     client_id=client_id,
                     managed_identity_type="system",
@@ -329,7 +336,7 @@ def _init_credentials(self) -> Optional[Credentials]:
                 )
 
             if managed_identity_client_id and managed_identity_client_id != client_id:
-                self.log.debug("Using Federated Identity Credentials with user-assigned managed identity")
+                logger.debug("Using Federated Identity Credentials with user-assigned managed identity")
                 return FederatedIdentityCredentials(
                     client_id=client_id,
                     managed_identity_type="user",
@@ -337,7 +344,7 @@ def _init_credentials(self) -> Optional[Credentials]:
                     tenant_id=tenant_id,
                 )
 
-            self.log.debug("Using user-assigned managed identity (direct)")
+            logger.debug("Using user-assigned managed identity (direct)")
             mi_client_id = managed_identity_client_id or client_id
             return ManagedIdentityCredentials(
                 client_id=mi_client_id,
@@ -410,7 +417,7 @@ def decorator(func: F) -> F:
 
             # Validate the detected type against registered events or custom event
             if not is_registered_event(detected_type):
-                self.logger.info(f"Event type '{detected_type}' is not a registered type.")
+                logger.info(f"Event type '{detected_type}' is not a registered type.")
             detected_type = cast(EventType, detected_type)
 
             # add it to the event emitter
@@ -440,7 +447,7 @@ def page(self, name: str, dir_path: str, page_path: Optional[str] = None) -> Non
             app.page("customform", os.path.join(os.path.dirname(__file__), "views", "customform"), "/tabs/dialog-form")
             ```
         """
-        self.http.mount(name, dir_path, page_path=page_path)
+        self.server.adapter.serve_static(page_path or f"/{name}", dir_path)
 
     def tab(self, name: str, path: str) -> None:
         """
@@ -474,25 +481,26 @@ async def post_to_chat(ctx: FunctionContext[Any]):
 
         def decorator(func: FCtx) -> FCtx:
             endpoint_name = name_or_func if isinstance(name_or_func, str) else func.__name__.replace("_", "-")
-            self.logger.debug("Generated endpoint name for function '%s': %s", func.__name__, endpoint_name)
-
-            async def endpoint(req: Request):
-                middleware = remote_function_jwt_validation(self.log, self.entra_token_validator)
-
-                async def call_next(r: Request) -> Any:
-                    ctx = FunctionContext(
-                        id=self.id,
-                        api=self.api,
-                        http=self.http,
-                        log=self.log,
-                        data=await r.json(),
-                        **r.state.context.__dict__,
-                    )
-                    return await func(ctx)
+            logger.debug("Generated endpoint name for function '%s': %s", func.__name__, endpoint_name)
 
-                return await middleware(req, call_next)
+            async def handler(request: HttpRequest) -> HttpResponse:
+                client_context, error = await validate_remote_function_request(
+                    request["headers"], self.entra_token_validator
+                )
+                if error or not client_context:
+                    return HttpResponse(status=401, body={"detail": error or "unauthorized"})
+
+                ctx = FunctionContext(
+                    id=self.id,
+                    api=self.api,
+                    activity_sender=self.activity_sender,
+                    data=request["body"],
+                    **client_context.__dict__,
+                )
+                result = await func(ctx)
+                return HttpResponse(status=200, body=result)
 
-            self.http.post(f"/api/functions/{endpoint_name}")(endpoint)
+            self.server.adapter.register_route("POST", f"/api/functions/{endpoint_name}", handler)
             return func
 
         # Direct decoration: @app.func
@@ -502,5 +510,10 @@ async def call_next(r: Request) -> Any:
         # Named decoration: @app.func("name")
         return decorator
 
+    async def _stop_plugins(self) -> None:
+        for plugin in reversed(self.plugins):
+            if hasattr(plugin, "on_stop") and callable(plugin.on_stop):
+                await plugin.on_stop()
+
     async def _get_bot_token(self):
         return await self._token_manager.get_bot_token()
diff --git a/packages/apps/src/microsoft_teams/apps/app_events.py b/packages/apps/src/microsoft_teams/apps/app_events.py
index 97f72856..88eb3fe6 100644
--- a/packages/apps/src/microsoft_teams/apps/app_events.py
+++ b/packages/apps/src/microsoft_teams/apps/app_events.py
@@ -8,7 +8,7 @@
 from microsoft_teams.common import EventEmitter
 
 from .events import ActivityEvent, ActivityResponseEvent, ActivitySentEvent, ErrorEvent, EventType
-from .plugins import PluginActivityResponseEvent, PluginActivitySentEvent, PluginBase, PluginErrorEvent, Sender
+from .plugins import PluginActivityResponseEvent, PluginActivitySentEvent, PluginBase, PluginErrorEvent
 
 
 class EventManager:
@@ -18,34 +18,29 @@ def __init__(self, event_emitter: EventEmitter[EventType]):
     async def on_error(self, event: ErrorEvent, plugins: List[PluginBase]) -> None:
         for plugin in plugins:
             if hasattr(plugin, "on_error_event") and callable(plugin.on_error):
-                await plugin.on_error(PluginErrorEvent(error=event.error, sender=plugin, activity=event.activity))
+                await plugin.on_error(PluginErrorEvent(error=event.error, activity=event.activity))
 
         self.event_emitter.emit("error", event)
 
     async def on_activity(self, event: ActivityEvent) -> None:
         self.event_emitter.emit("activity", event)
 
-    async def on_activity_sent(self, sender: Sender, event: ActivitySentEvent, plugins: List[PluginBase]) -> None:
+    async def on_activity_sent(self, event: ActivitySentEvent, plugins: List[PluginBase]) -> None:
         for plugin in plugins:
             if callable(plugin.on_activity_sent):
                 await plugin.on_activity_sent(
-                    PluginActivitySentEvent(
-                        sender=event.sender, activity=event.activity, conversation_ref=event.conversation_ref
-                    )
+                    PluginActivitySentEvent(activity=event.activity, conversation_ref=event.conversation_ref)
                 )
-        self.event_emitter.emit("activity_sent", {"event": event, "sender": sender})
+        self.event_emitter.emit("activity_sent", event)
 
-    async def on_activity_response(
-        self, sender: Sender, event: ActivityResponseEvent, plugins: List[PluginBase]
-    ) -> None:
+    async def on_activity_response(self, event: ActivityResponseEvent, plugins: List[PluginBase]) -> None:
         for plugin in plugins:
             if callable(plugin.on_activity_response):
                 await plugin.on_activity_response(
                     PluginActivityResponseEvent(
                         activity=event.activity,
-                        sender=sender,
                         response=event.response,
                         conversation_ref=event.conversation_ref,
                     )
                 )
-        self.event_emitter.emit("activity_response", {"event": event, "sender": sender})
+        self.event_emitter.emit("activity_response", event)
diff --git a/packages/apps/src/microsoft_teams/apps/app_oauth.py b/packages/apps/src/microsoft_teams/apps/app_oauth.py
index 535eadf3..e6417478 100644
--- a/packages/apps/src/microsoft_teams/apps/app_oauth.py
+++ b/packages/apps/src/microsoft_teams/apps/app_oauth.py
@@ -3,6 +3,7 @@
 Licensed under the MIT License.
 """
 
+import logging
 from typing import Optional, Union
 
 from httpx import HTTPStatusError
@@ -22,6 +23,8 @@
 from .events import ErrorEvent, EventType, SignInEvent
 from .routing import ActivityContext
 
+logger = logging.getLogger(__name__)
+
 
 class OauthHandlers:
     def __init__(self, default_connection_name: str, event_emitter: EventEmitter[EventType]) -> None:
@@ -34,13 +37,12 @@ async def sign_in_token_exchange(
         """
         Decorator to register a function that handles the sign-in token exchange.
         """
-        log = ctx.logger
         activity = ctx.activity
         api = ctx.api
         next_handler = ctx.next
         try:
             if activity.value.connection_name != self.default_connection_name:
-                log.warning(
+                logger.warning(
                     f"Sign-in token exchange invoked with connection name '{activity.value.connection_name}', "
                     f"but default connection name is '{self.default_connection_name}'. "
                     f"Token verification will likely fail."
@@ -63,18 +65,18 @@ async def sign_in_token_exchange(
                 if isinstance(e, HTTPStatusError):
                     status = e.response.status_code
                     if status not in (404, 400, 412):
-                        log.error(
+                        logger.error(
                             f"Error exchanging token for user {activity.from_.id} in "
                             f"conversation {activity.conversation.id}: {e}"
                         )
                         self.event_emitter.emit("error", ErrorEvent(error=e, context={"activity": activity}))
                         return InvokeResponse(status=status or 500)
-                    log.info(
+                    logger.info(
                         f"Unable to exchange token for user {activity.from_.id} in "
                         f"conversation {activity.conversation.id}: {e}"
                     )
                 else:
-                    log.error(
+                    logger.error(
                         f"Unable to exchange token for user {activity.from_.id} in "
                         f"conversation {activity.conversation.id}: {e}"
                     )
@@ -147,19 +149,18 @@ async def sign_in_verify_state(
         """
         Decorator to register a function that handles the sign-in token exchange.
         """
-        log = ctx.logger
         activity = ctx.activity
         api = ctx.api
         next_handler = ctx.next
         try:
             if not activity.value.state:
-                log.warning(
+                logger.warning(
                     f"Auth state not present for conversation id '{activity.conversation.id}' "
                     f"and user id '{activity.from_.id}'. "
                 )
                 return InvokeResponse(status=404)
 
-            log.debug(
+            logger.debug(
                 f"Verifying sign-in state for user {activity.from_.id} in conversation"
                 f"{activity.conversation.id} with state {activity.value.state}"
             )
@@ -174,12 +175,12 @@ async def sign_in_verify_state(
                     )
                 )
                 self.event_emitter.emit("sign_in", SignInEvent(activity_ctx=ctx, token_response=token))
-                log.debug(
+                logger.debug(
                     f"Sign-in state verified for user {activity.from_.id} in conversation {activity.conversation.id}"
                 )
                 return None
             except Exception as e:
-                log.error(
+                logger.error(
                     f"Error verifying sign-in state for user {activity.from_.id} in conversation"
                     f"{activity.conversation.id}: {e}"
                 )
diff --git a/packages/apps/src/microsoft_teams/apps/app_plugins.py b/packages/apps/src/microsoft_teams/apps/app_plugins.py
index 0f3486b6..e4a17ab7 100644
--- a/packages/apps/src/microsoft_teams/apps/app_plugins.py
+++ b/packages/apps/src/microsoft_teams/apps/app_plugins.py
@@ -3,7 +3,7 @@
 Licensed under the MIT License.
 """
 
-from logging import Logger
+import logging
 from typing import Any, List, Optional, cast, get_type_hints
 
 from dependency_injector import providers
@@ -17,13 +17,13 @@
 from .plugins import (
     DependencyMetadata,
     EventMetadata,
-    PluginActivityEvent,
     PluginBase,
     PluginErrorEvent,
-    Sender,
     get_metadata,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class PluginProcessor:
     """
@@ -37,14 +37,12 @@ def __init__(
         self,
         container: Container,
         event_manager: EventManager,
-        logger: Logger,
         event_emitter: EventEmitter[EventType],
         activity_processor: ActivityProcessor,
     ):
         self.plugins: List[PluginBase] = []
         self.container = container
         self.event_manager = event_manager
-        self.logger = logger
         self.event_emitter = event_emitter
         self.activity_processor = activity_processor
 
@@ -56,7 +54,7 @@ def initialize_plugins(self, plugins: List[PluginBase]) -> List[PluginBase]:
             name = metadata.name
             class_name = plugin.__class__.__name__
 
-            self.logger.debug(f"Initializing the plugin {class_name}")
+            logger.debug(f"Initializing the plugin {class_name}")
 
             if not name:
                 raise ValueError(f"Plugin {class_name} missing name in metadata")
@@ -70,7 +68,7 @@ def initialize_plugins(self, plugins: List[PluginBase]) -> List[PluginBase]:
             if class_name != name:
                 self.container.set_provider(class_name, providers.Object(plugin))
 
-        self.logger.debug("Successfully initialized all plugins")
+        logger.debug("Successfully initialized all plugins")
         return self.plugins
 
     def get_plugin(self, name: str) -> Optional[PluginBase]:
@@ -90,7 +88,7 @@ def inject(self, plugin: PluginBase) -> None:
             metadata = getattr(annotated_type, "__metadata__", ())
 
             for meta in metadata:
-                self.logger.debug(f"Initializing the dependency {field_name} for {plugin.__class__.__name__}")
+                logger.debug(f"Initializing the dependency {field_name} for {plugin.__class__.__name__}")
                 if isinstance(meta, EventMetadata):
                     self._inject_event(meta, plugin, field_name)
 
@@ -100,33 +98,27 @@ def inject(self, plugin: PluginBase) -> None:
     def _inject_event(self, meta: EventMetadata, plugin: PluginBase, field_name: str) -> None:
         """Injects event handler into the plugin based on metadata info."""
         if meta.name == "error":
-            self.logger.debug("Injecting the error event")
+            logger.debug("Injecting the error event")
 
             async def error_handler(event: PluginErrorEvent) -> None:
                 activity = cast(Activity, event.activity)
-                await self.event_manager.on_error(
-                    ErrorEvent(error=event.error, activity=activity, sender=plugin), self.plugins
-                )
+                await self.event_manager.on_error(ErrorEvent(error=event.error, activity=activity), self.plugins)
 
             setattr(plugin, field_name, error_handler)
         elif meta.name == "activity":
-            self.logger.debug("Injecting the activity event")
+            logger.debug("Injecting the activity event")
 
-            async def activity_handler(event: PluginActivityEvent) -> InvokeResponse[Any]:
-                sender = cast(Sender, plugin)
-                activity_event = ActivityEvent(activity=event.activity, sender=sender, token=event.token)
-                await self.event_manager.on_activity(activity_event)
-                return await self.activity_processor.process_activity(self.plugins, sender, activity_event)
+            async def activity_handler(event: ActivityEvent) -> InvokeResponse[Any]:
+                await self.event_manager.on_activity(event)
+                return await self.activity_processor.process_activity(self.plugins, event)
 
             setattr(plugin, field_name, activity_handler)
         elif meta.name == "custom":
-            self.logger.debug("Injecting the custom event")
+            logger.debug("Injecting the custom event")
 
             async def custom_handler(name: str, event: Any) -> None:
                 if is_registered_event(name):
-                    self.logger.warning(
-                        f"event {name} is reserved by core app-events but an plugin is trying to emit it"
-                    )
+                    logger.warning(f"event {name} is reserved by core app-events but an plugin is trying to emit it")
                     return
                 self.event_emitter.emit(name, event)
 
@@ -149,8 +141,5 @@ def _inject_dependency(self, meta: DependencyMetadata, plugin: PluginBase, type_
         else:
             # Calling the provider to get the actual instance
             dependency = dependency()
-            if field_name == "logger":
-                logger_dependency = cast(Logger, dependency)
-                dependency = logger_dependency.getChild(plugin.__class__.__name__)
             setattr(plugin, field_name, dependency)
-            self.logger.debug(f"Successfully injected the dependency {field_name} into {plugin.__class__.__name__}")
+            logger.debug(f"Successfully injected the dependency {field_name} into {plugin.__class__.__name__}")
diff --git a/packages/apps/src/microsoft_teams/apps/app_process.py b/packages/apps/src/microsoft_teams/apps/app_process.py
index 21d2df51..9b048113 100644
--- a/packages/apps/src/microsoft_teams/apps/app_process.py
+++ b/packages/apps/src/microsoft_teams/apps/app_process.py
@@ -3,12 +3,13 @@
 Licensed under the MIT License.
 """
 
-from logging import Logger
+import logging
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union, cast
 
 from microsoft_teams.api import (
     ActivityBase,
     ActivityParams,
+    ActivityTypeAdapter,
     ApiClient,
     ApiClientSettings,
     ConversationReference,
@@ -23,13 +24,17 @@
 
 if TYPE_CHECKING:
     from .app_events import EventManager
+
+from .activity_sender import ActivitySender
 from .events import ActivityEvent, ActivityResponseEvent, ActivitySentEvent, ErrorEvent
-from .plugins import PluginActivityEvent, PluginBase, Sender
+from .plugins import PluginActivityEvent, PluginBase
 from .routing.activity_context import ActivityContext
 from .routing.router import ActivityHandler, ActivityRouter
 from .token_manager import TokenManager
 from .utils import extract_tenant_id
 
+logger = logging.getLogger(__name__)
+
 
 class ActivityProcessor:
     """Provides activity processing functionality with middleware chain support."""
@@ -37,22 +42,22 @@ class ActivityProcessor:
     def __init__(
         self,
         router: ActivityRouter,
-        logger: Logger,
         id: Optional[str],
         storage: Union[Storage[str, Any], LocalStorage[Any]],
         default_connection_name: str,
         http_client: Client,
         token_manager: TokenManager,
         api_client_settings: Optional[ApiClientSettings],
+        activity_sender: ActivitySender,
     ) -> None:
         self.router = router
-        self.logger = logger
         self.id = id
         self.storage = storage
         self.default_connection_name = default_connection_name
         self.http_client = http_client
         self.token_manager = token_manager
         self.api_client_settings = api_client_settings
+        self.activity_sender = activity_sender
 
         # This will be set after the EventManager is initialized due to
         # a circular dependency
@@ -63,7 +68,6 @@ async def _build_context(
         activity: ActivityBase,
         token: TokenProtocol,
         plugins: List[PluginBase],
-        sender: Sender,
     ) -> ActivityContext[ActivityBase]:
         """Build the context object for activity processing.
 
@@ -106,7 +110,7 @@ async def _build_context(
             is_signed_in = True
         except Exception:
             # User token not available
-            self.logger.debug("No user token available")
+            logger.debug("No user token available")
             pass
 
         tenant_id = extract_tenant_id(activity)
@@ -114,14 +118,13 @@ async def _build_context(
         activityCtx = ActivityContext(
             activity,
             self.id or "",
-            self.logger,
             self.storage,
             api_client,
             user_token,
             conversation_ref,
             is_signed_in,
             self.default_connection_name,
-            sender,
+            activity_sender=self.activity_sender,
             app_token=lambda: self.token_manager.get_graph_token(tenant_id),
         )
 
@@ -136,12 +139,11 @@ async def updated_send(
             if not self.event_manager:
                 raise ValueError("EventManager was not initialized properly")
 
-            self.logger.debug("Calling on_activity_sent for plugins")
+            logger.debug("Calling on_activity_sent for plugins")
             ref = conversation_ref or activityCtx.conversation_ref
 
             await self.event_manager.on_activity_sent(
-                sender,
-                ActivitySentEvent(sender=sender, activity=res, conversation_ref=ref),
+                ActivitySentEvent(activity=res, conversation_ref=ref),
                 plugins=plugins,
             )
             return res
@@ -151,16 +153,14 @@ async def updated_send(
         async def handle_chunk(chunk_activity: SentActivity):
             if self.event_manager:
                 await self.event_manager.on_activity_sent(
-                    sender,
-                    ActivitySentEvent(sender=sender, activity=chunk_activity, conversation_ref=conversation_ref),
+                    ActivitySentEvent(activity=chunk_activity, conversation_ref=conversation_ref),
                     plugins=plugins,
                 )
 
         async def handle_close(close_activity: SentActivity):
             if self.event_manager:
                 await self.event_manager.on_activity_sent(
-                    sender,
-                    ActivitySentEvent(sender=sender, activity=close_activity, conversation_ref=conversation_ref),
+                    ActivitySentEvent(activity=close_activity, conversation_ref=conversation_ref),
                     plugins=plugins,
                 )
 
@@ -169,12 +169,13 @@ async def handle_close(close_activity: SentActivity):
 
         return activityCtx
 
-    async def process_activity(
-        self, plugins: List[PluginBase], sender: Sender, event: ActivityEvent
-    ) -> InvokeResponse[Any]:
-        activityCtx = await self._build_context(event.activity, event.token, plugins, sender)
+    async def process_activity(self, plugins: List[PluginBase], event: ActivityEvent) -> InvokeResponse[Any]:
+        activity_dict = event.body.model_dump(by_alias=True, exclude_none=True)
+        activity = ActivityTypeAdapter.validate_python(activity_dict)
+
+        activityCtx = await self._build_context(activity, event.token, plugins)
 
-        self.logger.debug(f"Received activity: {activityCtx.activity}")
+        logger.debug(f"Received activity: {activityCtx.activity}")
 
         # Get registered handlers for this activity type
         handlers = self.router.select_handlers(activityCtx.activity)
@@ -183,8 +184,7 @@ def create_route(plugin: PluginBase) -> ActivityHandler:
             async def route(ctx: ActivityContext[ActivityBase]) -> Optional[Any]:
                 await plugin.on_activity(
                     PluginActivityEvent(
-                        sender=sender,
-                        activity=event.activity,
+                        activity=activity,
                         token=event.token,
                         conversation_ref=activityCtx.conversation_ref,
                     )
@@ -217,19 +217,18 @@ async def route(ctx: ActivityContext[ActivityBase]) -> Optional[Any]:
                 response = InvokeResponse[Any](status=200, body=middleware_result)
 
             await self.event_manager.on_activity_response(
-                sender,
                 ActivityResponseEvent(
-                    activity=event.activity,
+                    activity=activity,
                     response=response,
                     conversation_ref=activityCtx.conversation_ref,
                 ),
                 plugins=plugins,
             )
         except Exception as error:
-            await self.event_manager.on_error(ErrorEvent(error=error, activity=event.activity, sender=sender), plugins)
+            await self.event_manager.on_error(ErrorEvent(error=error, activity=activity), plugins)
             raise error
 
-        self.logger.debug("Completed processing activity")
+        logger.debug("Completed processing activity")
 
         return response
 
diff --git a/packages/apps/src/microsoft_teams/apps/auth/__init__.py b/packages/apps/src/microsoft_teams/apps/auth/__init__.py
index 6fa5f743..46b58cfe 100644
--- a/packages/apps/src/microsoft_teams/apps/auth/__init__.py
+++ b/packages/apps/src/microsoft_teams/apps/auth/__init__.py
@@ -4,7 +4,7 @@
 """
 
 from .jwt_middleware import create_jwt_validation_middleware
-from .remote_function_jwt_middleware import remote_function_jwt_validation
+from .remote_function_jwt_middleware import validate_remote_function_request
 from .token_validator import TokenValidator
 
-__all__ = ["TokenValidator", "create_jwt_validation_middleware", "remote_function_jwt_validation"]
+__all__ = ["TokenValidator", "create_jwt_validation_middleware", "validate_remote_function_request"]
diff --git a/packages/apps/src/microsoft_teams/apps/auth/jwt_middleware.py b/packages/apps/src/microsoft_teams/apps/auth/jwt_middleware.py
index 026f29fb..e56a8a14 100644
--- a/packages/apps/src/microsoft_teams/apps/auth/jwt_middleware.py
+++ b/packages/apps/src/microsoft_teams/apps/auth/jwt_middleware.py
@@ -3,7 +3,7 @@
 Licensed under the MIT License.
 """
 
-from logging import Logger
+import logging
 from typing import Awaitable, Callable
 
 import jwt
@@ -12,10 +12,11 @@
 
 from .token_validator import TokenValidator
 
+logger = logging.getLogger(__name__)
+
 
 def create_jwt_validation_middleware(
     app_id: str,
-    logger: Logger,
     paths: list[str],
 ):
     """
@@ -23,14 +24,13 @@ def create_jwt_validation_middleware(
 
     Args:
         app_id: Bot's Microsoft App ID for audience validation
-        logger: Logger instance
         paths: List of paths to validate
 
     Returns:
         Middleware function that can be added to FastAPI app
     """
     # Create service token validator
-    token_validator = TokenValidator.for_service(app_id, logger)
+    token_validator = TokenValidator.for_service(app_id)
 
     async def middleware(request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
         """JWT validation middleware function."""
diff --git a/packages/apps/src/microsoft_teams/apps/auth/remote_function_jwt_middleware.py b/packages/apps/src/microsoft_teams/apps/auth/remote_function_jwt_middleware.py
index 5e1b87aa..a9bf95c2 100644
--- a/packages/apps/src/microsoft_teams/apps/auth/remote_function_jwt_middleware.py
+++ b/packages/apps/src/microsoft_teams/apps/auth/remote_function_jwt_middleware.py
@@ -3,80 +3,88 @@
 Licensed under the MIT License.
 """
 
-from logging import Logger
-from typing import Any, Awaitable, Callable, Dict, List, Optional
-
-from fastapi import HTTPException, Request, Response
+import logging
+from typing import Dict, Optional
 
 from ..contexts import ClientContext
 from .token_validator import TokenValidator
 
+logger = logging.getLogger(__name__)
+
 
-def require_fields(fields: Dict[str, Optional[Any]], context: str, logger: Logger) -> None:
-    missing: List[str] = [name for name, value in fields.items() if not value]
+def _require_fields(fields: Dict[str, Optional[str]], context: str) -> Optional[str]:
+    """Validate required fields are present. Returns error message if any are missing, None otherwise."""
+    missing = [name for name, value in fields.items() if not value]
     if missing:
         message = f"Missing or invalid fields in {context}: {', '.join(missing)}"
         logger.warning(message)
-        raise HTTPException(status_code=401, detail=message)
+        return message
+    return None
 
 
-def remote_function_jwt_validation(logger: Logger, entra_token_validator: Optional[TokenValidator]):
+async def validate_remote_function_request(
+    headers: Dict[str, str],
+    entra_token_validator: Optional[TokenValidator],
+) -> tuple[Optional[ClientContext], Optional[str]]:
     """
-    Middleware to validate JWT for remote function calls.
+    Validate JWT and extract client context from request headers for remote function calls.
+
     Args:
-        entra_token_validator: TokenValidator instance for Entra ID tokens
-        logger: Logger instance
+        headers: Request headers dict.
+        entra_token_validator: TokenValidator instance for Entra ID tokens.
 
     Returns:
-        Middleware function that can be added to FastAPI app
+        Tuple of (ClientContext, None) on success or (None, error_message) on failure.
     """
+    # Extract auth token
+    authorization = headers.get("Authorization") or headers.get("authorization") or ""
+    parts = authorization.split(" ")
+    auth_token = parts[1] if len(parts) == 2 and parts[0].lower() == "bearer" else ""
+
+    # Validate headers
+    error = _require_fields(
+        {
+            "X-Teams-App-Session-Id": headers.get("X-Teams-App-Session-Id") or headers.get("x-teams-app-session-id"),
+            "X-Teams-Page-Id": headers.get("X-Teams-Page-Id") or headers.get("x-teams-page-id"),
+            "Authorization (Bearer token)": auth_token,
+        },
+        "header",
+    )
+    if error:
+        return None, error
+
+    if not entra_token_validator:
+        return None, "Token validator not configured"
+
+    # Validate token
+    token_payload = await entra_token_validator.validate_token(auth_token)
+
+    # Validate required fields in token
+    error = _require_fields(
+        {"oid": token_payload.get("oid"), "tid": token_payload.get("tid"), "name": token_payload.get("name")},
+        "token payload",
+    )
+    if error:
+        return None, error
+
+    def _h(name: str) -> str:
+        """Get header value case-insensitively."""
+        return headers.get(name) or headers.get(name.lower()) or ""
+
+    context = ClientContext(
+        app_session_id=_h("X-Teams-App-Session-Id"),
+        tenant_id=token_payload["tid"],
+        user_id=token_payload["oid"],
+        user_name=token_payload["name"],
+        page_id=_h("X-Teams-Page-Id"),
+        auth_token=auth_token,
+        app_id=token_payload.get("appId"),
+        channel_id=_h("X-Teams-Channel-Id") or None,
+        chat_id=_h("X-Teams-Chat-Id") or None,
+        meeting_id=_h("X-Teams-Meeting-Id") or None,
+        message_id=_h("X-Teams-Message-Id") or None,
+        sub_page_id=_h("X-Teams-Sub-Page-Id") or None,
+        team_id=_h("X-Teams-Team-Id") or None,
+    )
 
-    async def middleware(request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
-        # Extract auth token
-        authorization = request.headers.get("Authorization", "")
-        parts = authorization.split(" ")
-        auth_token = parts[1] if len(parts) == 2 and parts[0].lower() == "bearer" else ""
-
-        # Validate headers
-        require_fields(
-            {
-                "X-Teams-App-Session-Id": request.headers.get("X-Teams-App-Session-Id"),
-                "X-Teams-Page-Id": request.headers.get("X-Teams-Page-Id"),
-                "Authorization (Bearer token)": auth_token,
-            },
-            "header",
-            logger,
-        )
-
-        if not entra_token_validator:
-            raise HTTPException(status_code=500, detail="Token validator not configured")
-
-        # Validate token
-        token_payload = await entra_token_validator.validate_token(auth_token)
-
-        # Validate required fields in token
-        require_fields(
-            {"oid": token_payload.get("oid"), "tid": token_payload.get("tid"), "name": token_payload.get("name")},
-            "token payload",
-            logger,
-        )
-
-        # Build context
-        request.state.context = ClientContext(
-            app_session_id=request.headers.get("X-Teams-App-Session-Id"),  # type: ignore
-            tenant_id=token_payload["tid"],
-            user_id=token_payload["oid"],
-            user_name=token_payload["name"],
-            page_id=request.headers.get("X-Teams-Page-Id"),  # type: ignore
-            auth_token=auth_token,  # type: ignore
-            app_id=token_payload.get("appId"),
-            channel_id=request.headers.get("X-Teams-Channel-Id"),
-            chat_id=request.headers.get("X-Teams-Chat-Id"),
-            meeting_id=request.headers.get("X-Teams-Meeting-Id"),
-            message_id=request.headers.get("X-Teams-Message-Id"),
-            sub_page_id=request.headers.get("X-Teams-Sub-Page-Id"),
-            team_id=request.headers.get("X-Teams-Team-Id"),
-        )
-        return await call_next(request)
-
-    return middleware
+    return context, None
diff --git a/packages/apps/src/microsoft_teams/apps/auth/token_validator.py b/packages/apps/src/microsoft_teams/apps/auth/token_validator.py
index da70a895..0a0f1ea5 100644
--- a/packages/apps/src/microsoft_teams/apps/auth/token_validator.py
+++ b/packages/apps/src/microsoft_teams/apps/auth/token_validator.py
@@ -3,15 +3,16 @@
 Licensed under the MIT License.
 """
 
+import logging
 from dataclasses import dataclass
-from logging import Logger
 from typing import Any, Dict, List, Optional
 
 import jwt
-from microsoft_teams.common.logging import ConsoleLogger
 
 JWT_LEEWAY_SECONDS = 300  # Allowable clock skew when validating JWTs
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class JwtValidationOptions:
@@ -36,29 +37,25 @@ class TokenValidator:
     JWT token validator using PyJWKClient for simplified validation.
     """
 
-    def __init__(self, jwt_validation_options: JwtValidationOptions, logger: Optional[Logger] = None):
+    def __init__(self, jwt_validation_options: JwtValidationOptions):
         """
         Initialize the token validator.
 
         Args:
             jwt_validation_options: Configuration for JWT validation
         """
-        self.logger = logger or ConsoleLogger().create_logger("@teams/token-validator")
         self.options = jwt_validation_options
 
     # ----- Factory constructors -----
     @classmethod
-    def for_service(
-        cls, app_id: str, logger: Optional[Logger] = None, service_url: Optional[str] = None
-    ) -> "TokenValidator":
+    def for_service(cls, app_id: str, service_url: Optional[str] = None) -> "TokenValidator":
         """Create a validator for Bot Framework service tokens.
 
         Reference: https://learn.microsoft.com/en-us/azure/bot-service/rest-api/bot-framework-rest-connector-authentication
 
         Args:
             app_id: The bot's Microsoft App ID (used for audience validation)
-            service_url: Optional service URL to validate against token claims
-            logger: Optional logger instance"""
+            service_url: Optional service URL to validate against token claims"""
 
         options = JwtValidationOptions(
             valid_issuers=["https://api.botframework.com"],
@@ -66,19 +63,16 @@ def for_service(
             jwks_uri="https://login.botframework.com/v1/.well-known/keys",
             service_url=service_url,
         )
-        return cls(options, logger)
+        return cls(options)
 
     @classmethod
-    def for_entra(
-        cls, app_id: str, tenant_id: Optional[str], scope: Optional[str] = None, logger: Optional[Logger] = None
-    ) -> "TokenValidator":
+    def for_entra(cls, app_id: str, tenant_id: Optional[str], scope: Optional[str] = None) -> "TokenValidator":
         """Create a validator for Entra ID tokens.
 
         Args:
             app_id: The app's Microsoft App ID (used for audience validation)
             tenant_id: The Azure AD tenant ID
             scope: Optional scope that must be present in the token
-            logger: Optional logger instance
 
         """
 
@@ -92,7 +86,7 @@ def for_entra(
             jwks_uri=f"https://login.microsoftonline.com/{tenant_id}/discovery/v2.0/keys",
             scope=scope,
         )
-        return cls(options, logger)
+        return cls(options)
 
     async def validate_token(
         self, raw_token: str, service_url: Optional[str] = None, scope: Optional[str] = None
@@ -112,7 +106,7 @@ async def validate_token(
             jwt.InvalidTokenError: When token validation fails
         """
         if not raw_token:
-            self.logger.error("No token provided")
+            logger.error("No token provided")
             raise jwt.InvalidTokenError("No token provided")
 
         try:
@@ -146,11 +140,11 @@ async def validate_token(
             if required_scope:
                 self._validate_scope(payload, required_scope)
 
-            self.logger.debug("Token validation successful")
+            logger.debug("Token validation successful")
             return payload
 
         except jwt.InvalidTokenError as e:
-            self.logger.error(f"Token validation failed: {e}")
+            logger.error(f"Token validation failed: {e}")
             raise
 
     def _validate_service_url(self, payload: Dict[str, Any], expected_service_url: str) -> None:
@@ -163,7 +157,7 @@ def _validate_service_url(self, payload: Dict[str, Any], expected_service_url: s
         token_service_url = payload.get("serviceurl")
 
         if not token_service_url:
-            self.logger.error("Token missing serviceurl claim")
+            logger.error("Token missing serviceurl claim")
             raise jwt.InvalidTokenError("Token missing serviceurl claim")
 
         # Normalize URLs (remove trailing slashes)
@@ -171,9 +165,7 @@ def _validate_service_url(self, payload: Dict[str, Any], expected_service_url: s
         normalized_expected_url = expected_service_url.rstrip("/")
 
         if normalized_token_url != normalized_expected_url:
-            self.logger.error(
-                f"Service URL mismatch. Token: {normalized_token_url}, Expected: {normalized_expected_url}"
-            )
+            logger.error(f"Service URL mismatch. Token: {normalized_token_url}, Expected: {normalized_expected_url}")
             raise jwt.InvalidTokenError(
                 f"Service URL mismatch. Token: {normalized_token_url}, Expected: {normalized_expected_url}"
             )
@@ -187,5 +179,5 @@ def _validate_scope(self, payload: Dict[str, Any], required_scope: str) -> None:
         """
         scopes = payload.get("scp", "") or ""
         if required_scope not in scopes:
-            self.logger.error(f"Token missing required scope: {required_scope}")
+            logger.error(f"Token missing required scope: {required_scope}")
             raise jwt.InvalidTokenError(f"Token missing required scope: {required_scope}")
diff --git a/packages/apps/src/microsoft_teams/apps/contexts/function_context.py b/packages/apps/src/microsoft_teams/apps/contexts/function_context.py
index 8766ba2e..eb209ec5 100644
--- a/packages/apps/src/microsoft_teams/apps/contexts/function_context.py
+++ b/packages/apps/src/microsoft_teams/apps/contexts/function_context.py
@@ -5,8 +5,8 @@
 
 from __future__ import annotations
 
+import logging
 from dataclasses import dataclass
-from logging import Logger
 from typing import Generic, Optional, TypeVar
 
 from microsoft_teams.api import (
@@ -21,11 +21,13 @@
 )
 from microsoft_teams.cards import AdaptiveCard
 
-from ..http_plugin import HttpPlugin
+from ..activity_sender import ActivitySender
 from .client_context import ClientContext
 
 T = TypeVar("T")
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass(kw_only=True)
 class FunctionContext(ClientContext, Generic[T]):
@@ -42,11 +44,8 @@ class FunctionContext(ClientContext, Generic[T]):
     api: ApiClient
     """The API client instance for conversation client."""
 
-    http: HttpPlugin
-    """The HTTP plugin instance for sending messages."""
-
-    log: Logger
-    """The app logger instance."""
+    activity_sender: ActivitySender
+    """The activity sender instance for sending messages."""
 
     data: T
     """The function payload."""
@@ -63,7 +62,7 @@ async def send(self, activity: str | ActivityParams | AdaptiveCard) -> Optional[
         conversation_id = await self._resolve_conversation_id(activity)
 
         if not conversation_id:
-            self.log.warning("Cannot send activity: conversation ID could not be resolved")
+            logger.warning("Cannot send activity: conversation ID could not be resolved")
             return None
 
         conversation_ref = ConversationReference(
@@ -80,7 +79,7 @@ async def send(self, activity: str | ActivityParams | AdaptiveCard) -> Optional[
         else:
             activity = activity
 
-        return await self.http.send(activity, conversation_ref)
+        return await self.activity_sender.send(activity, conversation_ref)
 
     async def _resolve_conversation_id(self, activity: str | ActivityParams | AdaptiveCard) -> Optional[str]:
         """Resolve or create a conversation ID for the current user/context.
@@ -107,12 +106,12 @@ async def _resolve_conversation_id(self, activity: str | ActivityParams | Adapti
                     self._resolved_conversation_id, self.user_id
                 )
                 if not member:
-                    self.log.warning(
+                    logger.warning(
                         f"User {self.user_id} is not a member of conversation {self._resolved_conversation_id}"
                     )
                     self._resolved_conversation_id = None
             except Exception as e:
-                self.log.error(f"Failed to get conversation member: {e}")
+                logger.error(f"Failed to get conversation member: {e}")
                 self._resolved_conversation_id = None
 
         else:
@@ -129,7 +128,7 @@ async def _resolve_conversation_id(self, activity: str | ActivityParams | Adapti
                 conversation = await self.api.conversations.create(conversation_params)
                 self._resolved_conversation_id = conversation.id
             except Exception as e:
-                self.log.error(f"Failed to create conversation: {e}")
+                logger.error(f"Failed to create conversation: {e}")
                 self._resolved_conversation_id = None
 
         return self._resolved_conversation_id
diff --git a/packages/apps/src/microsoft_teams/apps/events/__init__.py b/packages/apps/src/microsoft_teams/apps/events/__init__.py
index fa0b3f62..75004759 100644
--- a/packages/apps/src/microsoft_teams/apps/events/__init__.py
+++ b/packages/apps/src/microsoft_teams/apps/events/__init__.py
@@ -9,6 +9,7 @@
     ActivityEvent,
     ActivityResponseEvent,
     ActivitySentEvent,
+    CoreActivity,
     ErrorEvent,
     SignInEvent,
     StartEvent,
@@ -27,4 +28,5 @@
     "is_registered_event",
     "ActivitySentEvent",
     "ActivityResponseEvent",
+    "CoreActivity",
 ]
diff --git a/packages/apps/src/microsoft_teams/apps/events/types.py b/packages/apps/src/microsoft_teams/apps/events/types.py
index bc041744..821e326f 100644
--- a/packages/apps/src/microsoft_teams/apps/events/types.py
+++ b/packages/apps/src/microsoft_teams/apps/events/types.py
@@ -16,21 +16,38 @@
     TokenProtocol,
     TokenResponse,
 )
+from pydantic import BaseModel, ConfigDict
 
-from ..plugins import PluginBase, Sender
 from ..routing import ActivityContext
 
 
+class CoreActivity(BaseModel):
+    """
+    Core activity fields that all transports need to know about.
+    Extensible for protocol-specific fields via extra="allow".
+    """
+
+    model_config = ConfigDict(extra="allow")
+
+    service_url: Optional[str] = None
+    """Service URL for routing"""
+
+    id: Optional[str] = None
+    """Activity ID for correlation"""
+
+    type: Optional[str] = None
+    """Activity type for basic routing"""
+
+
 @dataclass
 class ActivityEvent:
     """Event emitted when an activity is processed."""
 
-    activity: Activity
-    sender: Sender
+    body: CoreActivity
     token: TokenProtocol
 
     def __repr__(self) -> str:
-        return f"ActivityEvent(activity={self.activity}, token={self.token}, sender={self.sender})"
+        return f"ActivityEvent(body={self.body}, token={self.token})"
 
 
 @dataclass
@@ -40,29 +57,24 @@ class ErrorEvent:
     error: Exception
     context: Optional[Dict[str, Any]] = None
     activity: Optional[Activity] = None
-    sender: Optional[PluginBase] = None
 
     def __post_init__(self) -> None:
         if self.context is None:
             self.context = {}
 
     def __repr__(self) -> str:
-        return f"ErrorEvent(error={self.error}, context={self.context}, activity={self.activity}, sender={self.sender})"
+        return f"ErrorEvent(error={self.error}, context={self.context}, activity={self.activity})"
 
 
 @dataclass
 class ActivitySentEvent:
-    """Event emitted by a plugin when an activity is sent."""
+    """Event emitted when an activity is sent."""
 
-    sender: Sender
     activity: SentActivity
     conversation_ref: ConversationReference
 
     def __repr__(self) -> str:
-        return (
-            f"ActivitySentEvent(sender={self.sender}, activity={self.activity}, "
-            + f"conversation_ref={self.conversation_ref})"
-        )
+        return f"ActivitySentEvent(activity={self.activity}, conversation_ref={self.conversation_ref})"
 
 
 @dataclass
diff --git a/packages/apps/src/microsoft_teams/apps/http/__init__.py b/packages/apps/src/microsoft_teams/apps/http/__init__.py
new file mode 100644
index 00000000..f7751fd1
--- /dev/null
+++ b/packages/apps/src/microsoft_teams/apps/http/__init__.py
@@ -0,0 +1,18 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+from .adapter import HttpMethod, HttpRequest, HttpResponse, HttpRouteHandler, HttpServerAdapter
+from .fastapi_adapter import FastAPIAdapter
+from .http_server import HttpServer
+
+__all__ = [
+    "HttpMethod",
+    "HttpRequest",
+    "HttpResponse",
+    "HttpRouteHandler",
+    "HttpServer",
+    "HttpServerAdapter",
+    "FastAPIAdapter",
+]
diff --git a/packages/apps/src/microsoft_teams/apps/http/adapter.py b/packages/apps/src/microsoft_teams/apps/http/adapter.py
new file mode 100644
index 00000000..8bbb8bd2
--- /dev/null
+++ b/packages/apps/src/microsoft_teams/apps/http/adapter.py
@@ -0,0 +1,46 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+from typing import Dict, Literal, Protocol, TypedDict, runtime_checkable
+
+HttpMethod = Literal["POST"]
+
+
+class HttpRequest(TypedDict):
+    body: Dict[str, object]
+    headers: Dict[str, str]
+
+
+class HttpResponse(TypedDict):
+    status: int
+    body: object
+
+
+class HttpRouteHandler(Protocol):
+    async def __call__(self, request: HttpRequest) -> HttpResponse: ...
+
+
+@runtime_checkable
+class HttpServerAdapter(Protocol):
+    """Protocol for framework-specific HTTP server adapters.
+
+    Implement this adapter to plug in any HTTP framework (FastAPI, Starlette, Flask, etc.).
+    The SDK calls these methods with framework-agnostic ``HttpRequest``/``HttpResponse``
+    objects so the adapter can translate to/from the underlying framework.
+    """
+
+    def register_route(self, method: HttpMethod, path: str, handler: HttpRouteHandler) -> None:
+        """Register a route handler. Required."""
+        ...
+
+    def serve_static(self, path: str, directory: str) -> None:
+        """Serve static files from a directory. Optional — no-op by default."""
+
+    async def start(self, port: int) -> None:
+        """Start the server. Optional — raises if not implemented."""
+        raise NotImplementedError("This adapter does not support managed server lifecycle. Start the server yourself.")
+
+    async def stop(self) -> None:
+        """Stop the server. Optional — no-op by default."""
diff --git a/packages/apps/src/microsoft_teams/apps/http/fastapi_adapter.py b/packages/apps/src/microsoft_teams/apps/http/fastapi_adapter.py
new file mode 100644
index 00000000..586cf4c9
--- /dev/null
+++ b/packages/apps/src/microsoft_teams/apps/http/fastapi_adapter.py
@@ -0,0 +1,100 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+import warnings
+from contextlib import AsyncExitStack, asynccontextmanager
+from typing import Any, Callable, Dict, List, Optional
+
+import uvicorn
+from fastapi import FastAPI, Request, Response
+from fastapi.responses import JSONResponse
+from fastapi.staticfiles import StaticFiles
+from starlette.types import ASGIApp, Lifespan
+
+from .adapter import HttpMethod, HttpRequest, HttpResponse, HttpRouteHandler
+
+
+class FastAPIAdapter:
+    """Default HttpServerAdapter implementation wrapping FastAPI + uvicorn."""
+
+    lifespans: List[Lifespan[ASGIApp]]
+
+    def __init__(
+        self,
+        app: Optional[FastAPI] = None,
+        server_factory: Optional[Callable[[FastAPI], uvicorn.Server]] = None,
+    ):
+        self.lifespans = []
+        self._fastapi = app or FastAPI()
+        self._server: Optional[uvicorn.Server] = None
+        self._server_factory = server_factory
+
+        # Replace the FastAPI app's lifespan with one that chains plugin lifespans
+        original_lifespan = self._fastapi.router.lifespan_context
+
+        @asynccontextmanager
+        async def combined_lifespan(app: ASGIApp):
+            async with AsyncExitStack() as stack:
+                for lifespan in self.lifespans:
+                    await stack.enter_async_context(lifespan(app))
+                await stack.enter_async_context(original_lifespan(app))
+                yield
+
+        self._fastapi.router.lifespan_context = combined_lifespan
+
+        if server_factory:
+            self._server = server_factory(self._fastapi)
+            if self._server.config.app is not self._fastapi:
+                raise ValueError(
+                    "server_factory must return a uvicorn.Server configured with the provided FastAPI app instance."
+                )
+
+    @property
+    def app(self) -> FastAPI:
+        """The underlying FastAPI instance."""
+        return self._fastapi
+
+    def register_route(self, method: HttpMethod, path: str, handler: HttpRouteHandler) -> None:
+        """Register a route handler on the FastAPI app."""
+
+        async def fastapi_handler(request: Request) -> Response:
+            body: Dict[str, Any] = await request.json()
+            headers: Dict[str, str] = dict(request.headers)
+            http_request = HttpRequest(body=body, headers=headers)
+            result: HttpResponse = await handler(http_request)
+            status = result["status"]
+            resp_body = result.get("body")
+            if resp_body is not None:
+                return JSONResponse(content=resp_body, status_code=status)
+            return Response(status_code=status)
+
+        if method != "POST":
+            raise ValueError(f"Unsupported HTTP method: {method}")
+        self._fastapi.post(path)(fastapi_handler)
+
+    def serve_static(self, path: str, directory: str) -> None:
+        """Mount a static files directory."""
+        name = path.strip("/").replace("/", "-") or "static"
+        self._fastapi.mount(path, StaticFiles(directory=directory, check_dir=True, html=True), name=name)
+
+    async def start(self, port: int) -> None:
+        """Start the uvicorn server. Blocks until stopped."""
+        if self._server:
+            if self._server.config.port != port:
+                warnings.warn(
+                    f"server_factory configured port {self._server.config.port}, "
+                    f"but app.start() requested port {port}. Using server_factory port.",
+                    stacklevel=2,
+                )
+        else:
+            config = uvicorn.Config(app=self._fastapi, host="0.0.0.0", port=port, log_level="info")
+            self._server = uvicorn.Server(config)
+
+        await self._server.serve()
+
+    async def stop(self) -> None:
+        """Signal the server to stop."""
+        if self._server:
+            self._server.should_exit = True
diff --git a/packages/apps/src/microsoft_teams/apps/http/http_server.py b/packages/apps/src/microsoft_teams/apps/http/http_server.py
new file mode 100644
index 00000000..8aab280b
--- /dev/null
+++ b/packages/apps/src/microsoft_teams/apps/http/http_server.py
@@ -0,0 +1,163 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+import logging
+from types import SimpleNamespace
+from typing import Any, Awaitable, Callable, Dict, Optional, cast
+
+from microsoft_teams.api import Credentials, InvokeResponse, TokenProtocol
+from microsoft_teams.api.auth.json_web_token import JsonWebToken
+from pydantic import BaseModel
+
+from ..auth import TokenValidator
+from ..events import ActivityEvent, CoreActivity
+from .adapter import HttpRequest, HttpResponse, HttpServerAdapter
+
+logger = logging.getLogger(__name__)
+
+
+class HttpServer:
+    """
+    Core Teams HTTP server. Not a plugin — owned directly by the App.
+
+    Manages an HttpServerAdapter instance and handles JWT validation
+    and activity processing for the Teams protocol.
+    """
+
+    def __init__(self, adapter: HttpServerAdapter, messaging_endpoint: str = "/api/messages"):
+        self._adapter = adapter
+        normalized_endpoint = messaging_endpoint.strip()
+        if not normalized_endpoint or not normalized_endpoint.startswith("/"):
+            raise ValueError("messaging_endpoint must be a non-empty path starting with '/'.")
+        self._messaging_endpoint = normalized_endpoint
+        self._on_request: Optional[Callable[[ActivityEvent], Awaitable[InvokeResponse[Any]]]] = None
+        self._token_validator: Optional[TokenValidator] = None
+        self._skip_auth: bool = False
+        self._initialized: bool = False
+
+    @property
+    def adapter(self) -> HttpServerAdapter:
+        """The underlying HttpServerAdapter."""
+        return self._adapter
+
+    @property
+    def messaging_endpoint(self) -> str:
+        """The URL path for the Teams messaging endpoint."""
+        return self._messaging_endpoint
+
+    @property
+    def on_request(self) -> Optional[Callable[[ActivityEvent], Awaitable[InvokeResponse[Any]]]]:
+        """Callback set by App to process activities."""
+        return self._on_request
+
+    @on_request.setter
+    def on_request(self, callback: Optional[Callable[[ActivityEvent], Awaitable[InvokeResponse[Any]]]]) -> None:
+        self._on_request = callback
+
+    def initialize(
+        self,
+        credentials: Optional[Credentials] = None,
+        skip_auth: bool = False,
+    ) -> None:
+        """
+        Set up JWT validation and register the messaging endpoint route.
+
+        Args:
+            credentials: App credentials for JWT validation.
+            skip_auth: Whether to skip JWT validation.
+        """
+        if self._initialized:
+            return
+
+        self._skip_auth = skip_auth
+
+        app_id = getattr(credentials, "client_id", None) if credentials else None
+        if app_id and not skip_auth:
+            self._token_validator = TokenValidator.for_service(app_id)
+            logger.debug("JWT validation enabled for %s", self._messaging_endpoint)
+
+        self._adapter.register_route("POST", self._messaging_endpoint, self.handle_request)
+        self._initialized = True
+
+    async def handle_request(self, request: HttpRequest) -> HttpResponse:
+        """Handle incoming activity request. Public so plugins (e.g. BotBuilder) can route through SDK auth."""
+        try:
+            body = request["body"]
+            headers = request["headers"]
+
+            # Validate JWT token
+            authorization = headers.get("authorization") or headers.get("Authorization") or ""
+
+            if self._token_validator and not self._skip_auth:
+                if not authorization.startswith("Bearer "):
+                    return HttpResponse(status=401, body={"error": "Unauthorized"})
+
+                raw_token = authorization.removeprefix("Bearer ")
+                service_url = cast(Optional[str], body.get("serviceUrl"))
+
+                try:
+                    await self._token_validator.validate_token(raw_token, service_url)
+                except Exception as e:
+                    logger.warning(f"JWT token validation failed: {e}")
+                    return HttpResponse(status=401, body={"error": "Unauthorized"})
+
+                token: TokenProtocol = cast(TokenProtocol, JsonWebToken(value=raw_token))
+            else:
+                # No auth — use a default token
+                service_url = cast(Optional[str], body.get("serviceUrl"))
+                token = cast(
+                    TokenProtocol,
+                    SimpleNamespace(
+                        app_id="",
+                        app_display_name="",
+                        tenant_id="",
+                        service_url=service_url or "",
+                        from_="azure",
+                        from_id="",
+                        is_expired=lambda: False,
+                    ),
+                )
+
+            core_activity = CoreActivity.model_validate(body)
+            activity_type = core_activity.type or "unknown"
+            activity_id = core_activity.id or "unknown"
+            logger.debug(f"Received activity: {activity_type} (ID: {activity_id})")
+
+            # Process the activity via the App callback
+            result = await self._process_activity(core_activity, token)
+            return self._format_response(result)
+        except Exception as e:
+            logger.exception(str(e))
+            return HttpResponse(status=500, body={"error": "Internal server error"})
+
+    async def _process_activity(self, core_activity: CoreActivity, token: TokenProtocol) -> InvokeResponse[Any]:
+        """Process an activity via the registered on_request callback."""
+        event = ActivityEvent(body=core_activity, token=token)
+        if self._on_request:
+            return await self._on_request(event)
+
+        logger.warning("No on_request handler registered")
+        return InvokeResponse(status=500)
+
+    def _format_response(self, result: Any) -> HttpResponse:
+        """Format an InvokeResponse into an HttpResponse."""
+        status_code: int = 200
+        body: Optional[Any] = None
+
+        resp_dict: Optional[Dict[str, Any]] = None
+        if isinstance(result, dict):
+            resp_dict = cast(Dict[str, Any], result)
+        elif isinstance(result, BaseModel):
+            resp_dict = result.model_dump(exclude_none=True)
+
+        if resp_dict and "status" in resp_dict:
+            status_code = resp_dict.get("status", 200)
+
+        if resp_dict and "body" in resp_dict:
+            body = resp_dict.get("body")
+
+        if body is not None:
+            return HttpResponse(status=status_code, body=body)
+        return HttpResponse(status=status_code, body=None)
diff --git a/packages/apps/src/microsoft_teams/apps/http_plugin.py b/packages/apps/src/microsoft_teams/apps/http_plugin.py
index a0be6501..534d68bc 100644
--- a/packages/apps/src/microsoft_teams/apps/http_plugin.py
+++ b/packages/apps/src/microsoft_teams/apps/http_plugin.py
@@ -5,8 +5,8 @@
 
 import importlib.metadata
 import inspect
+import logging
 from contextlib import AsyncExitStack, asynccontextmanager
-from logging import Logger
 from pathlib import Path
 from types import SimpleNamespace
 from typing import (
@@ -27,69 +27,54 @@
 from fastapi import FastAPI, Request, Response
 from fastapi.staticfiles import StaticFiles
 from microsoft_teams.api import (
-    Activity,
-    ActivityParams,
-    ActivityTypeAdapter,
-    ApiClient,
-    ConversationReference,
     Credentials,
     InvokeResponse,
-    MessageActivityInput,
-    SentActivity,
     TokenProtocol,
 )
-from microsoft_teams.apps.http_stream import HttpStream
-from microsoft_teams.common import Client, ClientOptions, ConsoleLogger, Token
-from pydantic import BaseModel, ValidationError
+from pydantic import BaseModel
 from starlette.applications import Starlette
 from starlette.types import Lifespan
 
 from .auth import create_jwt_validation_middleware
-from .events import ActivityEvent, ErrorEvent
+from .events import ActivityEvent, CoreActivity, ErrorEvent
 from .plugins import (
     DependencyMetadata,
     EventMetadata,
-    LoggerDependencyOptions,
     PluginActivityResponseEvent,
+    PluginBase,
     PluginStartEvent,
-    Sender,
-    StreamerProtocol,
 )
 from .plugins.metadata import Plugin
 
 version = importlib.metadata.version("microsoft-teams-apps")
 
+logger = logging.getLogger(__name__)
+
 
 class HttpPluginOptions(TypedDict, total=False):
     """Options for configuring the HTTP plugin."""
 
-    logger: Logger
     skip_auth: bool
     server_factory: Callable[[FastAPI], uvicorn.Server]
 
 
-@Plugin(name="http", version=version, description="the default plugin for sending/receiving activities")
-class HttpPlugin(Sender):
+@Plugin(name="http", version=version, description="the default plugin for receiving activities via HTTP")
+class HttpPlugin(PluginBase):
     """
     Basic HTTP plugin that provides a FastAPI server for Teams activities.
+    Handles HTTP server setup, routing, and authentication.
     """
 
-    logger: Annotated[Logger, LoggerDependencyOptions()]
     credentials: Annotated[Optional[Credentials], DependencyMetadata(optional=True)]
 
     on_error_event: Annotated[Callable[[ErrorEvent], None], EventMetadata(name="error")]
     on_activity_event: Annotated[Callable[[ActivityEvent], InvokeResponse[Any]], EventMetadata(name="activity")]
 
-    client: Annotated[Client, DependencyMetadata()]
-
-    bot_token: Annotated[Optional[Callable[[], Token]], DependencyMetadata(optional=True)]
-
     lifespans: list[Lifespan[Starlette]] = []
 
     def __init__(self, **options: Unpack[HttpPluginOptions]):
         """
         Args:
-            logger: Optional logger.
             skip_auth: Whether to skip JWT validation.
             server_factory: Optional function that takes an ASGI app
                 and returns a configured `uvicorn.Server`.
@@ -103,7 +88,6 @@ def custom_server_factory(app: FastAPI) -> uvicorn.Server:
                 ```
         """
         super().__init__()
-        self.logger = options.get("logger") or ConsoleLogger().create_logger("@teams/http-plugin")
         self._port: Optional[int] = None
         self._skip_auth: bool = options.get("skip_auth", False)
         self._server: Optional[uvicorn.Server] = None
@@ -114,12 +98,12 @@ def custom_server_factory(app: FastAPI) -> uvicorn.Server:
         @asynccontextmanager
         async def default_lifespan(_app: Starlette) -> AsyncGenerator[None, None]:
             # Startup
-            self.logger.info(f"listening on port {self._port} 🚀")
+            logger.info(f"listening on port {self._port} 🚀")
             if self._on_ready_callback:
                 await self._on_ready_callback()
             yield
             # Shutdown
-            self.logger.info("Server shutting down")
+            logger.info("Server shutting down")
             if self._on_stopped_callback:
                 await self._on_stopped_callback()
 
@@ -183,9 +167,7 @@ async def on_init(self) -> None:
         # Add JWT validation middleware
         app_id = getattr(self.credentials, "client_id", None)
         if app_id and not self._skip_auth:
-            jwt_middleware = create_jwt_validation_middleware(
-                app_id=app_id, logger=self.logger, paths=["/api/messages"]
-            )
+            jwt_middleware = create_jwt_validation_middleware(app_id=app_id, paths=["/api/messages"])
             self.app.middleware("http")(jwt_middleware)
 
     async def on_start(self, event: PluginStartEvent) -> None:
@@ -194,7 +176,7 @@ async def on_start(self, event: PluginStartEvent) -> None:
 
         try:
             if self._server and self._server.config.port != self._port:
-                self.logger.warning(
+                logger.warning(
                     "Using port configured by server factory: %d, but plugin start event has port %d.",
                     self._server.config.port,
                     self._port,
@@ -204,23 +186,23 @@ async def on_start(self, event: PluginStartEvent) -> None:
                 config = uvicorn.Config(app=self.app, host="0.0.0.0", port=self._port, log_level="info")
                 self._server = uvicorn.Server(config)
 
-            self.logger.info("Starting HTTP server on port %d", self._port)
+            logger.info("Starting HTTP server on port %d", self._port)
 
             # The lifespan handler will call the callback when the server is ready
             await self._server.serve()
 
         except OSError as error:
             # Handle port in use, permission errors, etc.
-            self.logger.error("Server startup failed: %s", error)
+            logger.error("Server startup failed: %s", error)
             raise
         except Exception as error:
-            self.logger.error("Failed to start server: %s", error)
+            logger.error("Failed to start server: %s", error)
             raise
 
     async def on_stop(self) -> None:
         """Stop the HTTP server."""
         if self._server:
-            self.logger.info("Stopping HTTP server")
+            logger.info("Stopping HTTP server")
             self._server.should_exit = True
 
     async def on_activity_response(self, event: PluginActivityResponseEvent) -> None:
@@ -235,99 +217,30 @@ async def on_activity_response(self, event: PluginActivityResponseEvent) -> None
             response_data: The response data to send back
             plugin: The plugin that sent the response
         """
-        self.logger.debug(f"Completing activity response for {event.activity.id}")
-
-    async def send(self, activity: ActivityParams, ref: ConversationReference) -> SentActivity:
-        api = ApiClient(service_url=ref.service_url, options=self.client.clone(ClientOptions(token=self.bot_token)))
-
-        activity.from_ = ref.bot
-        activity.conversation = ref.conversation
-
-        # Check if this is a targeted message
-        is_targeted = isinstance(activity, MessageActivityInput) and activity.is_targeted is True
-
-        if hasattr(activity, "id") and activity.id:
-            if is_targeted:
-                res = await api.conversations.activities(ref.conversation.id).update_targeted(activity.id, activity)
-            else:
-                res = await api.conversations.activities(ref.conversation.id).update(activity.id, activity)
-            return SentActivity.merge(activity, res)
-
-        if is_targeted:
-            res = await api.conversations.activities(ref.conversation.id).create_targeted(activity)
-        else:
-            res = await api.conversations.activities(ref.conversation.id).create(activity)
-        return SentActivity.merge(activity, res)
+        logger.debug(f"Completing activity response for {event.activity.id}")
 
-    async def _process_activity(
-        self, activity: Activity, activity_id: str, token: TokenProtocol
-    ) -> InvokeResponse[Any]:
+    async def _process_activity(self, core_activity: CoreActivity, token: TokenProtocol) -> InvokeResponse[Any]:
         """
         Process an activity via the registered handler.
 
         Args:
-            activity: The Teams activity data
+            core_activity: The core activity payload
             token: The authorization token (if any)
-            activity_id: The activity ID for response coordination
         """
         result: InvokeResponse[Any]
         try:
-            event = ActivityEvent(activity=activity, sender=self, token=token)
+            event = ActivityEvent(body=core_activity, token=token)
             if inspect.iscoroutinefunction(self.on_activity_event):
                 result = await self.on_activity_event(event)
             else:
                 result = self.on_activity_event(event)
         except Exception as error:
             # Log with full traceback
-            self.logger.exception(str(error))
+            logger.exception(str(error))
             result = InvokeResponse(status=500)
 
         return result
 
-    async def _handle_activity_request(self, request: Request) -> Any:
-        """
-        Process the activity request and coordinate response.
-
-        Args:
-            request: The FastAPI request object (token is in request.state.validated_token)
-
-        Returns:
-            The activity processing result
-        """
-        # Parse activity data
-        body = await request.json()
-
-        # Get validated token from middleware (if present - will be missing if skip_auth is True)
-        if hasattr(request.state, "validated_token") and request.state.validated_token:
-            token = request.state.validated_token
-        else:
-            token = cast(
-                TokenProtocol,
-                SimpleNamespace(
-                    app_id="",
-                    app_display_name="",
-                    tenant_id="",
-                    service_url=body.get("serviceUrl", ""),
-                    from_="azure",
-                    from_id="",
-                    is_expired=lambda: False,
-                ),
-            )
-
-        activity_type = body.get("type", "unknown")
-        activity_id = body.get("id", "unknown")
-
-        self.logger.debug(f"Received activity: {activity_type} (ID: {activity_id})")
-
-        try:
-            activity = ActivityTypeAdapter.validate_python(body)
-        except ValidationError as e:
-            self.logger.error(e.errors())
-            raise
-
-        self.logger.debug(f"Processing activity {activity_id} via handler...")
-        return await self._process_activity(activity, activity_id, token)
-
     def _handle_activity_response(self, response: Response, result: Any) -> Union[Response, Dict[str, object]]:
         """
         Handle the activity response formatting.
@@ -358,15 +271,38 @@ def _handle_activity_response(self, response: Response, result: Any) -> Union[Re
             response.status_code = status_code
 
         if body is not None:
-            self.logger.debug(f"Returning body {body}")
+            logger.debug(f"Returning body {body}")
             return body
-        self.logger.debug("Returning empty body")
+        logger.debug("Returning empty body")
         return response
 
-    async def on_activity_request(self, request: Request, response: Response) -> Any:
+    async def on_activity_request(self, core_activity: CoreActivity, request: Request, response: Response) -> Any:
         """Handle incoming Teams activity."""
-        # Process the activity (token validation handled by middleware)
-        result = await self._handle_activity_request(request)
+        # Get validated token from middleware (if present - will be missing if skip_auth is True)
+        if hasattr(request.state, "validated_token") and request.state.validated_token:
+            token = request.state.validated_token
+        else:
+            token = cast(
+                TokenProtocol,
+                SimpleNamespace(
+                    app_id="",
+                    app_display_name="",
+                    tenant_id="",
+                    service_url=core_activity.service_url or "",
+                    from_="azure",
+                    from_id="",
+                    is_expired=lambda: False,
+                ),
+            )
+
+        activity_type = core_activity.type or "unknown"
+        activity_id = core_activity.id or "unknown"
+
+        logger.debug(f"Received activity: {activity_type} (ID: {activity_id})")
+        logger.debug(f"Processing activity {activity_id} via handler...")
+
+        # Process the activity
+        result = await self._process_activity(core_activity, token)
         return self._handle_activity_response(response, result)
 
     def _setup_routes(self) -> None:
@@ -380,13 +316,6 @@ async def health_check() -> Dict[str, Any]:
 
         self.app.get("/")(health_check)
 
-    def create_stream(self, ref: ConversationReference) -> StreamerProtocol:
-        """Create a new streaming instance."""
-
-        api = ApiClient(ref.service_url, self.client.clone(ClientOptions(token=self.bot_token)))
-
-        return HttpStream(api, ref, self.logger)
-
     def mount(self, name: str, dir_path: Path | str, page_path: Optional[str] = None) -> None:
         """
         Serve a static page at the given path.
diff --git a/packages/apps/src/microsoft_teams/apps/http_stream.py b/packages/apps/src/microsoft_teams/apps/http_stream.py
index 47383b6c..645025c8 100644
--- a/packages/apps/src/microsoft_teams/apps/http_stream.py
+++ b/packages/apps/src/microsoft_teams/apps/http_stream.py
@@ -4,8 +4,8 @@
 """
 
 import asyncio
+import logging
 from collections import deque
-from logging import Logger
 from typing import Awaitable, Callable, List, Optional, Union
 
 from microsoft_teams.api import (
@@ -18,11 +18,13 @@
     SentActivity,
     TypingActivityInput,
 )
-from microsoft_teams.common import ConsoleLogger, EventEmitter
+from microsoft_teams.common import EventEmitter
 
 from .plugins.streamer import StreamerEvent, StreamerProtocol
 from .utils import RetryOptions, retry
 
+logger = logging.getLogger(__name__)
+
 
 class HttpStream(StreamerProtocol):
     """
@@ -40,21 +42,17 @@ class HttpStream(StreamerProtocol):
     The delays between flushes is to ensure we dont hit API rate limits with Microsoft Teams.
     """
 
-    def __init__(self, client: ApiClient, ref: ConversationReference, logger: Optional[Logger] = None):
+    def __init__(self, client: ApiClient, ref: ConversationReference):
         """
         Initialize a new HttpStream instance.
 
         Args:
             client (ApiClient): The API client used to send activities to Microsoft Teams.
             ref (ConversationReference): Reference to the Teams conversation.
-            logger (Optional[Logger]): Custom logger instance for debugging and monitoring..
         """
         super().__init__()
         self._client = client
         self._ref = ref
-        self._logger = (
-            logger.getChild("@teams/http-stream") if logger else ConsoleLogger().create_logger("@teams/http-stream")
-        )
         self._events = EventEmitter[StreamerEvent]()
 
         self._result: Optional[SentActivity] = None
@@ -139,21 +137,21 @@ async def _poll():
     async def close(self) -> Optional[SentActivity]:
         # wait for lock to be free
         if self._result is not None:
-            self._logger.debug("stream already closed with result")
+            logger.debug("stream already closed with result")
             return self._result
 
         if self._index == 1 and not self._queue and not self._lock.locked():
-            self._logger.debug("stream has no content to send, returning None")
+            logger.debug("stream has no content to send, returning None")
             return None
 
         # Wait until _id is set and queue is empty
         result = await self._wait_for_id_and_queue()
         if not result:
-            self._logger.warning("Timeout while waiting for _id to be set and queue to be empty, cannot close stream")
+            logger.warning("Timeout while waiting for _id to be set and queue to be empty, cannot close stream")
             return None
 
         if self._text == "" and self._attachments == []:
-            self._logger.warning("no text or attachments to send, cannot close stream")
+            logger.warning("no text or attachments to send, cannot close stream")
             return None
 
         # Build final message
@@ -161,7 +159,7 @@ async def close(self) -> Optional[SentActivity]:
         activity = MessageActivityInput(text=self._text).with_id(self._id).with_channel_data(self._channel_data)
         activity.add_attachments(*self._attachments).add_entities(*self._entities).add_stream_final()
 
-        res = await retry(lambda: self._send(activity), options=RetryOptions(logger=self._logger))
+        res = await retry(lambda: self._send(activity), options=RetryOptions())
 
         # Emit close event
         self._events.emit("close", res)
@@ -169,7 +167,7 @@ async def close(self) -> Optional[SentActivity]:
         # Reset state
         self._reset_state()
         self._result = res
-        self._logger.debug("stream closed with result: %s", res)
+        logger.debug("stream closed with result: %s", res)
 
         return res
 
@@ -215,7 +213,7 @@ async def _flush(self) -> None:
                 i += 1
 
             if i == 0:
-                self._logger.debug("No activities to flush")
+                logger.debug("No activities to flush")
                 return
 
             # Send informative updates immediately
@@ -252,7 +250,7 @@ async def _send_activity(self, to_send: TypingActivityInput):
 
         res = await retry(
             lambda: self._send(to_send),
-            options=RetryOptions(logger=self._logger, max_delay=4.0, jitter_type="none", max_attempts=8),
+            options=RetryOptions(max_delay=4.0, jitter_type="none", max_attempts=8),
         )
         self._events.emit("chunk", res)
         self._index += 1
diff --git a/packages/apps/src/microsoft_teams/apps/options.py b/packages/apps/src/microsoft_teams/apps/options.py
index 6bd5846c..517ff6ae 100644
--- a/packages/apps/src/microsoft_teams/apps/options.py
+++ b/packages/apps/src/microsoft_teams/apps/options.py
@@ -3,14 +3,16 @@
 Licensed under the MIT License.
 """
 
+from __future__ import annotations
+
 from dataclasses import dataclass, field
-from logging import Logger
 from typing import Any, Awaitable, Callable, List, Optional, TypedDict, Union, cast
 
 from microsoft_teams.api import ApiClientSettings
 from microsoft_teams.common import Storage
 from typing_extensions import Unpack
 
+from .http.adapter import HttpServerAdapter
 from .plugins import PluginBase
 
 
@@ -37,11 +39,17 @@ class AppOptions(TypedDict, total=False):
     """
 
     # Infrastructure
-    logger: Optional[Logger]
     storage: Optional[Storage[str, Any]]
     plugins: Optional[List[PluginBase]]
     skip_auth: Optional[bool]
 
+    # HTTP adapter
+    http_server_adapter: Optional[HttpServerAdapter]
+    """Custom HTTP server adapter. Defaults to FastAPIAdapter if not provided."""
+
+    messaging_endpoint: Optional[str]
+    """URL path for the Teams messaging endpoint. Defaults to '/api/messages'."""
+
     # OAuth
     default_connection_name: Optional[str]
     """The OAuth connection name to use for authentication. Defaults to 'graph'."""
@@ -87,7 +95,6 @@ class InternalAppOptions:
     If set to a different client ID than client_id, triggers Federated Identity Credentials with user-assigned MI.
     If not set or equals client_id, uses direct managed identity (no federation).
     """
-    logger: Optional[Logger] = None
     storage: Optional[Storage[str, Any]] = None
     service_url: Optional[str] = None
     """
@@ -95,6 +102,10 @@ class InternalAppOptions:
     Uses environment variable SERVICE_URL if not provided
     and defaults to https://smba.trafficmanager.net/teams
     """
+    http_server_adapter: Optional[HttpServerAdapter] = None
+    """Custom HTTP server adapter. Defaults to FastAPIAdapter if not provided."""
+    messaging_endpoint: str = "/api/messages"
+    """URL path for the Teams messaging endpoint. Defaults to '/api/messages'."""
 
     @classmethod
     def from_typeddict(cls, options: AppOptions) -> "InternalAppOptions":
diff --git a/packages/apps/src/microsoft_teams/apps/plugins/__init__.py b/packages/apps/src/microsoft_teams/apps/plugins/__init__.py
index 1b5b0034..e78a2de0 100644
--- a/packages/apps/src/microsoft_teams/apps/plugins/__init__.py
+++ b/packages/apps/src/microsoft_teams/apps/plugins/__init__.py
@@ -3,19 +3,17 @@
 Licensed under the MIT License.
 """
 
-from .metadata import DependencyMetadata, EventMetadata, LoggerDependencyOptions, Plugin, PluginOptions, get_metadata
+from .metadata import DependencyMetadata, EventMetadata, Plugin, PluginOptions, get_metadata
 from .plugin_activity_event import PluginActivityEvent
 from .plugin_activity_response_event import PluginActivityResponseEvent
 from .plugin_activity_sent_event import PluginActivitySentEvent
 from .plugin_base import PluginBase
 from .plugin_error_event import PluginErrorEvent
 from .plugin_start_event import PluginStartEvent
-from .sender import Sender
 from .streamer import StreamerProtocol
 
 __all__ = [
     "PluginBase",
-    "Sender",
     "StreamerProtocol",
     "PluginActivityEvent",
     "PluginActivityResponseEvent",
@@ -27,6 +25,5 @@
     "PluginOptions",
     "DependencyMetadata",
     "EventMetadata",
-    "LoggerDependencyOptions",
     "Plugin",
 ]
diff --git a/packages/apps/src/microsoft_teams/apps/plugins/metadata.py b/packages/apps/src/microsoft_teams/apps/plugins/metadata.py
index 98b34a9f..c4585aed 100644
--- a/packages/apps/src/microsoft_teams/apps/plugins/metadata.py
+++ b/packages/apps/src/microsoft_teams/apps/plugins/metadata.py
@@ -99,12 +99,6 @@ class BotTokenDependencyOptions(DependencyMetadata):
     optional = True
 
 
-@dataclass
-class LoggerDependencyOptions(DependencyMetadata):
-    name = "logger"
-    optional = False
-
-
 @dataclass
 class StorageDependencyOptions(DependencyMetadata):
     name = "storage"
@@ -123,7 +117,6 @@ class PluginDependencyOptions(DependencyMetadata):
     ManifestDependencyOptions,
     CredentialsDependencyOptions,
     BotTokenDependencyOptions,
-    LoggerDependencyOptions,
     StorageDependencyOptions,
     PluginDependencyOptions,
 ]
diff --git a/packages/apps/src/microsoft_teams/apps/plugins/plugin_activity_event.py b/packages/apps/src/microsoft_teams/apps/plugins/plugin_activity_event.py
index 40c1d7f6..df4d5264 100644
--- a/packages/apps/src/microsoft_teams/apps/plugins/plugin_activity_event.py
+++ b/packages/apps/src/microsoft_teams/apps/plugins/plugin_activity_event.py
@@ -3,13 +3,10 @@
 Licensed under the MIT License.
 """
 
-from typing import TYPE_CHECKING, NamedTuple, Optional
+from typing import NamedTuple
 
 from microsoft_teams.api import Activity, ConversationReference, TokenProtocol
 
-if TYPE_CHECKING:
-    from .sender import Sender
-
 
 class PluginActivityEvent(NamedTuple):
     """Event emitted by a plugin when an activity is received."""
@@ -22,6 +19,3 @@ class PluginActivityEvent(NamedTuple):
 
     conversation_ref: ConversationReference
     """The conversation reference for the activity"""
-
-    sender: Optional["Sender"] = None
-    """The sender"""
diff --git a/packages/apps/src/microsoft_teams/apps/plugins/plugin_activity_response_event.py b/packages/apps/src/microsoft_teams/apps/plugins/plugin_activity_response_event.py
index f9347b86..e26435f8 100644
--- a/packages/apps/src/microsoft_teams/apps/plugins/plugin_activity_response_event.py
+++ b/packages/apps/src/microsoft_teams/apps/plugins/plugin_activity_response_event.py
@@ -3,19 +3,13 @@
 Licensed under the MIT License.
 """
 
-from typing import TYPE_CHECKING, Any, NamedTuple, Optional
+from typing import Any, NamedTuple, Optional
 
 from microsoft_teams.api import Activity, ConversationReference, InvokeResponse
 
-if TYPE_CHECKING:
-    from .sender import Sender
-
 
 class PluginActivityResponseEvent(NamedTuple):
-    """Event emitted by a plugin before an activity response is sent"""
-
-    sender: "Sender"
-    """The sender"""
+    """Event emitted before an activity response is sent"""
 
     activity: Activity
     """The inbound request activity payload"""
diff --git a/packages/apps/src/microsoft_teams/apps/plugins/plugin_activity_sent_event.py b/packages/apps/src/microsoft_teams/apps/plugins/plugin_activity_sent_event.py
index 1cab011c..f8916625 100644
--- a/packages/apps/src/microsoft_teams/apps/plugins/plugin_activity_sent_event.py
+++ b/packages/apps/src/microsoft_teams/apps/plugins/plugin_activity_sent_event.py
@@ -3,20 +3,14 @@
 Licensed under the MIT License.
 """
 
-from typing import TYPE_CHECKING, NamedTuple
+from typing import NamedTuple
 
 from microsoft_teams.api.activities import SentActivity
 from microsoft_teams.api.models import ConversationReference
 
-if TYPE_CHECKING:
-    from .sender import Sender
-
 
 class PluginActivitySentEvent(NamedTuple):
-    """Event emitted by a plugin when an activity is sent."""
-
-    sender: "Sender"
-    """The sender of the activity"""
+    """Event emitted when an activity is sent."""
 
     activity: SentActivity
     """The sent activity"""
diff --git a/packages/apps/src/microsoft_teams/apps/plugins/plugin_base.py b/packages/apps/src/microsoft_teams/apps/plugins/plugin_base.py
index b63103c9..51c7e932 100644
--- a/packages/apps/src/microsoft_teams/apps/plugins/plugin_base.py
+++ b/packages/apps/src/microsoft_teams/apps/plugins/plugin_base.py
@@ -3,15 +3,11 @@
 Licensed under the MIT License.
 """
 
-from microsoft_teams.api.activities import ActivityParams, SentActivity
-from microsoft_teams.api.models.conversation import ConversationReference
-
 from .plugin_activity_event import PluginActivityEvent
 from .plugin_activity_response_event import PluginActivityResponseEvent
 from .plugin_activity_sent_event import PluginActivitySentEvent
 from .plugin_error_event import PluginErrorEvent
 from .plugin_start_event import PluginStartEvent
-from .streamer import StreamerProtocol
 
 
 class PluginBase:
@@ -44,11 +40,3 @@ async def on_activity_sent(self, event: PluginActivitySentEvent) -> None:
     async def on_activity_response(self, event: PluginActivityResponseEvent) -> None:
         """Called by the App when an activity response is sent."""
         ...
-
-    async def send(self, activity: ActivityParams, ref: ConversationReference) -> SentActivity:
-        """Called by the App to send an activity"""
-        ...
-
-    def create_stream(self, ref: ConversationReference) -> StreamerProtocol:
-        """Called by the App to create a new activity stream"""
-        ...
diff --git a/packages/apps/src/microsoft_teams/apps/plugins/plugin_error_event.py b/packages/apps/src/microsoft_teams/apps/plugins/plugin_error_event.py
index 5dc82ee3..6720c2de 100644
--- a/packages/apps/src/microsoft_teams/apps/plugins/plugin_error_event.py
+++ b/packages/apps/src/microsoft_teams/apps/plugins/plugin_error_event.py
@@ -3,13 +3,10 @@
 Licensed under the MIT License.
 """
 
-from typing import TYPE_CHECKING, NamedTuple, Optional
+from typing import NamedTuple, Optional
 
 from microsoft_teams.api import Activity
 
-if TYPE_CHECKING:
-    from .plugin_base import PluginBase
-
 
 class PluginErrorEvent(NamedTuple):
     """Event emitted when an error occurs."""
@@ -17,8 +14,5 @@ class PluginErrorEvent(NamedTuple):
     error: Exception
     """The error"""
 
-    sender: Optional["PluginBase"] = None
-    """The sender"""
-
     activity: Optional[Activity] = None
     """The activity"""
diff --git a/packages/apps/src/microsoft_teams/apps/plugins/sender.py b/packages/apps/src/microsoft_teams/apps/plugins/sender.py
deleted file mode 100644
index 31450b5a..00000000
--- a/packages/apps/src/microsoft_teams/apps/plugins/sender.py
+++ /dev/null
@@ -1,26 +0,0 @@
-"""
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the MIT License.
-"""
-
-from abc import abstractmethod
-
-from microsoft_teams.api.activities import ActivityParams, SentActivity
-from microsoft_teams.api.models import ConversationReference
-
-from .plugin_base import PluginBase
-from .streamer import StreamerProtocol
-
-
-class Sender(PluginBase):
-    """A plugin that can send activities"""
-
-    @abstractmethod
-    async def send(self, activity: ActivityParams, ref: ConversationReference) -> SentActivity:
-        """Called by the App to send an activity"""
-        pass
-
-    @abstractmethod
-    def create_stream(self, ref: ConversationReference) -> StreamerProtocol:
-        """Called by the App to create a new activity stream"""
-        pass
diff --git a/packages/apps/src/microsoft_teams/apps/routing/activity_context.py b/packages/apps/src/microsoft_teams/apps/routing/activity_context.py
index ce6de9bf..243463b3 100644
--- a/packages/apps/src/microsoft_teams/apps/routing/activity_context.py
+++ b/packages/apps/src/microsoft_teams/apps/routing/activity_context.py
@@ -5,8 +5,8 @@
 
 import base64
 import json
+import logging
 from dataclasses import dataclass
-from logging import Logger
 from typing import TYPE_CHECKING, Any, Awaitable, Callable, Generic, Optional, TypeVar, cast
 
 from microsoft_teams.api import (
@@ -36,14 +36,13 @@
 from microsoft_teams.common import Storage
 from microsoft_teams.common.http.client_token import Token
 
+from ..activity_sender import ActivitySender
+
 if TYPE_CHECKING:
     from msgraph.graph_service_client import GraphServiceClient
 
-from ..plugins import Sender
-
 T = TypeVar("T", bound=ActivityBase, contravariant=True)
-
-SendCallable = Callable[[str | ActivityParams | AdaptiveCard], Awaitable[SentActivity]]
+logger = logging.getLogger(__name__)
 
 
 def _get_graph_client(token: Token):
@@ -87,14 +86,13 @@ def __init__(
         self,
         activity: T,
         app_id: str,
-        logger: Logger,
         storage: Storage[str, Any],
         api: ApiClient,
         user_token: Optional[str],
         conversation_ref: ConversationReference,
         is_signed_in: bool,
         connection_name: str,
-        sender: Sender,
+        activity_sender: ActivitySender,
         app_token: Token,
     ):
         self.activity = activity
@@ -106,9 +104,9 @@ def __init__(
         self.user_token = user_token
         self.connection_name = connection_name
         self.is_signed_in = is_signed_in
-        self._plugin = sender
+        self._activity_sender = activity_sender
         self._app_token = app_token
-        self.stream = self._plugin.create_stream(self.conversation_ref)
+        self.stream = activity_sender.create_stream(conversation_ref)
 
         self._next_handler: Optional[Callable[[], Awaitable[None]]] = None
 
@@ -184,18 +182,8 @@ async def send(
         else:
             activity = message
 
-        # For targeted send, set the recipient if not already set.
-        # For targeted update (activity.id exists), we dont update recipient since recipient cannot be changed.
-        if (
-            isinstance(activity, MessageActivityInput)
-            and activity.is_targeted
-            and not activity.id
-            and not activity.recipient
-        ):
-            activity.recipient = self.activity.from_
-
         ref = conversation_ref or self.conversation_ref
-        res = await self._plugin.send(activity, ref)
+        res = await self._activity_sender.send(activity, ref)
         return res
 
     async def reply(self, input: str | ActivityParams) -> SentActivity:
diff --git a/packages/apps/src/microsoft_teams/apps/routing/activity_handlers.py b/packages/apps/src/microsoft_teams/apps/routing/activity_handlers.py
index 280ff949..d44cc87d 100644
--- a/packages/apps/src/microsoft_teams/apps/routing/activity_handlers.py
+++ b/packages/apps/src/microsoft_teams/apps/routing/activity_handlers.py
@@ -4,7 +4,6 @@
 """
 
 from abc import ABC, abstractmethod
-from logging import Logger
 from typing import Awaitable, Callable, Optional, Pattern, Union, overload
 
 from microsoft_teams.api import (
@@ -27,12 +26,6 @@ def router(self) -> ActivityRouter:
         """The activity router instance. Must be implemented by the concrete class."""
         pass
 
-    @property
-    @abstractmethod
-    def logger(self) -> Logger:
-        """The logger instance used by the app."""
-        pass
-
     @overload
     def on_message_pattern(
         self, pattern: str | Pattern[str]
@@ -102,7 +95,7 @@ def on_message_pattern(
         def decorator(
             func: Callable[[ActivityContext[MessageActivity]], Awaitable[None]],
         ) -> Callable[[ActivityContext[MessageActivity]], Awaitable[None]]:
-            validate_handler_type(self.logger, func, MessageActivity, "on_message", "MessageActivity")
+            validate_handler_type(func, MessageActivity, "on_message", "MessageActivity")
 
             def selector(ctx: ActivityBase) -> bool:
                 if not isinstance(ctx, MessageActivity):
diff --git a/packages/apps/src/microsoft_teams/apps/routing/generated_handlers.py b/packages/apps/src/microsoft_teams/apps/routing/generated_handlers.py
index ba4a63a2..c1a8b710 100644
--- a/packages/apps/src/microsoft_teams/apps/routing/generated_handlers.py
+++ b/packages/apps/src/microsoft_teams/apps/routing/generated_handlers.py
@@ -10,7 +10,6 @@
 """
 
 from abc import ABC, abstractmethod
-from logging import Logger
 from typing import Callable, Optional, overload
 
 from microsoft_teams.api.activities import (
@@ -92,12 +91,6 @@ def router(self) -> ActivityRouter:
         """The activity router instance. Must be implemented by the concrete class."""
         pass
 
-    @property
-    @abstractmethod
-    def logger(self) -> Logger:
-        """The logger instance used by the app."""
-        pass
-
     @overload
     def on_message(self, handler: BasicHandler[MessageActivity]) -> BasicHandler[MessageActivity]: ...
 
@@ -108,7 +101,7 @@ def on_message(self, handler: Optional[BasicHandler[MessageActivity]] = None) ->
         """Register a message activity handler."""
 
         def decorator(func: BasicHandler[MessageActivity]) -> BasicHandler[MessageActivity]:
-            validate_handler_type(self.logger, func, MessageActivity, "on_message", "MessageActivity")
+            validate_handler_type(func, MessageActivity, "on_message", "MessageActivity")
             config = ACTIVITY_ROUTES["message"]
             self.router.add_handler(config.selector, func)
             return func
@@ -133,9 +126,7 @@ def on_message_delete(
         """Register a message_delete activity handler."""
 
         def decorator(func: BasicHandler[MessageDeleteActivity]) -> BasicHandler[MessageDeleteActivity]:
-            validate_handler_type(
-                self.logger, func, MessageDeleteActivity, "on_message_delete", "MessageDeleteActivity"
-            )
+            validate_handler_type(func, MessageDeleteActivity, "on_message_delete", "MessageDeleteActivity")
             config = ACTIVITY_ROUTES["message_delete"]
             self.router.add_handler(config.selector, func)
             return func
@@ -160,9 +151,7 @@ def on_soft_delete_message(
         """Register a soft_delete_message activity handler."""
 
         def decorator(func: BasicHandler[MessageDeleteActivity]) -> BasicHandler[MessageDeleteActivity]:
-            validate_handler_type(
-                self.logger, func, MessageDeleteActivity, "on_soft_delete_message", "MessageDeleteActivity"
-            )
+            validate_handler_type(func, MessageDeleteActivity, "on_soft_delete_message", "MessageDeleteActivity")
             config = ACTIVITY_ROUTES["soft_delete_message"]
             self.router.add_handler(config.selector, func)
             return func
@@ -187,9 +176,7 @@ def on_message_reaction(
         """Register a message_reaction activity handler."""
 
         def decorator(func: BasicHandler[MessageReactionActivity]) -> BasicHandler[MessageReactionActivity]:
-            validate_handler_type(
-                self.logger, func, MessageReactionActivity, "on_message_reaction", "MessageReactionActivity"
-            )
+            validate_handler_type(func, MessageReactionActivity, "on_message_reaction", "MessageReactionActivity")
             config = ACTIVITY_ROUTES["message_reaction"]
             self.router.add_handler(config.selector, func)
             return func
@@ -214,9 +201,7 @@ def on_message_update(
         """Register a message_update activity handler."""
 
         def decorator(func: BasicHandler[MessageUpdateActivity]) -> BasicHandler[MessageUpdateActivity]:
-            validate_handler_type(
-                self.logger, func, MessageUpdateActivity, "on_message_update", "MessageUpdateActivity"
-            )
+            validate_handler_type(func, MessageUpdateActivity, "on_message_update", "MessageUpdateActivity")
             config = ACTIVITY_ROUTES["message_update"]
             self.router.add_handler(config.selector, func)
             return func
@@ -241,9 +226,7 @@ def on_undelete_message(
         """Register a undelete_message activity handler."""
 
         def decorator(func: BasicHandler[MessageUpdateActivity]) -> BasicHandler[MessageUpdateActivity]:
-            validate_handler_type(
-                self.logger, func, MessageUpdateActivity, "on_undelete_message", "MessageUpdateActivity"
-            )
+            validate_handler_type(func, MessageUpdateActivity, "on_undelete_message", "MessageUpdateActivity")
             config = ACTIVITY_ROUTES["undelete_message"]
             self.router.add_handler(config.selector, func)
             return func
@@ -266,7 +249,7 @@ def on_edit_message(
         """Register a edit_message activity handler."""
 
         def decorator(func: BasicHandler[MessageUpdateActivity]) -> BasicHandler[MessageUpdateActivity]:
-            validate_handler_type(self.logger, func, MessageUpdateActivity, "on_edit_message", "MessageUpdateActivity")
+            validate_handler_type(func, MessageUpdateActivity, "on_edit_message", "MessageUpdateActivity")
             config = ACTIVITY_ROUTES["edit_message"]
             self.router.add_handler(config.selector, func)
             return func
@@ -287,7 +270,7 @@ def on_command(
         """Register a command activity handler."""
 
         def decorator(func: BasicHandler[CommandSendActivity]) -> BasicHandler[CommandSendActivity]:
-            validate_handler_type(self.logger, func, CommandSendActivity, "on_command", "CommandSendActivity")
+            validate_handler_type(func, CommandSendActivity, "on_command", "CommandSendActivity")
             config = ACTIVITY_ROUTES["command"]
             self.router.add_handler(config.selector, func)
             return func
@@ -312,9 +295,7 @@ def on_command_result(
         """Register a command_result activity handler."""
 
         def decorator(func: BasicHandler[CommandResultActivity]) -> BasicHandler[CommandResultActivity]:
-            validate_handler_type(
-                self.logger, func, CommandResultActivity, "on_command_result", "CommandResultActivity"
-            )
+            validate_handler_type(func, CommandResultActivity, "on_command_result", "CommandResultActivity")
             config = ACTIVITY_ROUTES["command_result"]
             self.router.add_handler(config.selector, func)
             return func
@@ -340,7 +321,7 @@ def on_conversation_update(
 
         def decorator(func: BasicHandler[ConversationUpdateActivity]) -> BasicHandler[ConversationUpdateActivity]:
             validate_handler_type(
-                self.logger, func, ConversationUpdateActivity, "on_conversation_update", "ConversationUpdateActivity"
+                func, ConversationUpdateActivity, "on_conversation_update", "ConversationUpdateActivity"
             )
             config = ACTIVITY_ROUTES["conversation_update"]
             self.router.add_handler(config.selector, func)
@@ -366,9 +347,7 @@ def on_channel_created(
         """Register a channel_created activity handler."""
 
         def decorator(func: BasicHandler[ConversationUpdateActivity]) -> BasicHandler[ConversationUpdateActivity]:
-            validate_handler_type(
-                self.logger, func, ConversationUpdateActivity, "on_channel_created", "ConversationUpdateActivity"
-            )
+            validate_handler_type(func, ConversationUpdateActivity, "on_channel_created", "ConversationUpdateActivity")
             config = ACTIVITY_ROUTES["channel_created"]
             self.router.add_handler(config.selector, func)
             return func
@@ -393,9 +372,7 @@ def on_channel_deleted(
         """Register a channel_deleted activity handler."""
 
         def decorator(func: BasicHandler[ConversationUpdateActivity]) -> BasicHandler[ConversationUpdateActivity]:
-            validate_handler_type(
-                self.logger, func, ConversationUpdateActivity, "on_channel_deleted", "ConversationUpdateActivity"
-            )
+            validate_handler_type(func, ConversationUpdateActivity, "on_channel_deleted", "ConversationUpdateActivity")
             config = ACTIVITY_ROUTES["channel_deleted"]
             self.router.add_handler(config.selector, func)
             return func
@@ -420,9 +397,7 @@ def on_channel_renamed(
         """Register a channel_renamed activity handler."""
 
         def decorator(func: BasicHandler[ConversationUpdateActivity]) -> BasicHandler[ConversationUpdateActivity]:
-            validate_handler_type(
-                self.logger, func, ConversationUpdateActivity, "on_channel_renamed", "ConversationUpdateActivity"
-            )
+            validate_handler_type(func, ConversationUpdateActivity, "on_channel_renamed", "ConversationUpdateActivity")
             config = ACTIVITY_ROUTES["channel_renamed"]
             self.router.add_handler(config.selector, func)
             return func
@@ -447,9 +422,7 @@ def on_channel_restored(
         """Register a channel_restored activity handler."""
 
         def decorator(func: BasicHandler[ConversationUpdateActivity]) -> BasicHandler[ConversationUpdateActivity]:
-            validate_handler_type(
-                self.logger, func, ConversationUpdateActivity, "on_channel_restored", "ConversationUpdateActivity"
-            )
+            validate_handler_type(func, ConversationUpdateActivity, "on_channel_restored", "ConversationUpdateActivity")
             config = ACTIVITY_ROUTES["channel_restored"]
             self.router.add_handler(config.selector, func)
             return func
@@ -474,9 +447,7 @@ def on_team_archived(
         """Register a team_archived activity handler."""
 
         def decorator(func: BasicHandler[ConversationUpdateActivity]) -> BasicHandler[ConversationUpdateActivity]:
-            validate_handler_type(
-                self.logger, func, ConversationUpdateActivity, "on_team_archived", "ConversationUpdateActivity"
-            )
+            validate_handler_type(func, ConversationUpdateActivity, "on_team_archived", "ConversationUpdateActivity")
             config = ACTIVITY_ROUTES["team_archived"]
             self.router.add_handler(config.selector, func)
             return func
@@ -501,9 +472,7 @@ def on_team_deleted(
         """Register a team_deleted activity handler."""
 
         def decorator(func: BasicHandler[ConversationUpdateActivity]) -> BasicHandler[ConversationUpdateActivity]:
-            validate_handler_type(
-                self.logger, func, ConversationUpdateActivity, "on_team_deleted", "ConversationUpdateActivity"
-            )
+            validate_handler_type(func, ConversationUpdateActivity, "on_team_deleted", "ConversationUpdateActivity")
             config = ACTIVITY_ROUTES["team_deleted"]
             self.router.add_handler(config.selector, func)
             return func
@@ -529,7 +498,7 @@ def on_team_hard_deleted(
 
         def decorator(func: BasicHandler[ConversationUpdateActivity]) -> BasicHandler[ConversationUpdateActivity]:
             validate_handler_type(
-                self.logger, func, ConversationUpdateActivity, "on_team_hard_deleted", "ConversationUpdateActivity"
+                func, ConversationUpdateActivity, "on_team_hard_deleted", "ConversationUpdateActivity"
             )
             config = ACTIVITY_ROUTES["team_hard_deleted"]
             self.router.add_handler(config.selector, func)
@@ -555,9 +524,7 @@ def on_team_renamed(
         """Register a team_renamed activity handler."""
 
         def decorator(func: BasicHandler[ConversationUpdateActivity]) -> BasicHandler[ConversationUpdateActivity]:
-            validate_handler_type(
-                self.logger, func, ConversationUpdateActivity, "on_team_renamed", "ConversationUpdateActivity"
-            )
+            validate_handler_type(func, ConversationUpdateActivity, "on_team_renamed", "ConversationUpdateActivity")
             config = ACTIVITY_ROUTES["team_renamed"]
             self.router.add_handler(config.selector, func)
             return func
@@ -582,9 +549,7 @@ def on_team_restored(
         """Register a team_restored activity handler."""
 
         def decorator(func: BasicHandler[ConversationUpdateActivity]) -> BasicHandler[ConversationUpdateActivity]:
-            validate_handler_type(
-                self.logger, func, ConversationUpdateActivity, "on_team_restored", "ConversationUpdateActivity"
-            )
+            validate_handler_type(func, ConversationUpdateActivity, "on_team_restored", "ConversationUpdateActivity")
             config = ACTIVITY_ROUTES["team_restored"]
             self.router.add_handler(config.selector, func)
             return func
@@ -609,9 +574,7 @@ def on_team_unarchived(
         """Register a team_unarchived activity handler."""
 
         def decorator(func: BasicHandler[ConversationUpdateActivity]) -> BasicHandler[ConversationUpdateActivity]:
-            validate_handler_type(
-                self.logger, func, ConversationUpdateActivity, "on_team_unarchived", "ConversationUpdateActivity"
-            )
+            validate_handler_type(func, ConversationUpdateActivity, "on_team_unarchived", "ConversationUpdateActivity")
             config = ACTIVITY_ROUTES["team_unarchived"]
             self.router.add_handler(config.selector, func)
             return func
@@ -637,7 +600,7 @@ def on_end_of_conversation(
 
         def decorator(func: BasicHandler[EndOfConversationActivity]) -> BasicHandler[EndOfConversationActivity]:
             validate_handler_type(
-                self.logger, func, EndOfConversationActivity, "on_end_of_conversation", "EndOfConversationActivity"
+                func, EndOfConversationActivity, "on_end_of_conversation", "EndOfConversationActivity"
             )
             config = ACTIVITY_ROUTES["end_of_conversation"]
             self.router.add_handler(config.selector, func)
@@ -657,7 +620,7 @@ def on_event(self, handler: Optional[BasicHandler[EventActivity]] = None) -> Bas
         """Register a event activity handler."""
 
         def decorator(func: BasicHandler[EventActivity]) -> BasicHandler[EventActivity]:
-            validate_handler_type(self.logger, func, EventActivity, "on_event", "EventActivity")
+            validate_handler_type(func, EventActivity, "on_event", "EventActivity")
             config = ACTIVITY_ROUTES["event"]
             self.router.add_handler(config.selector, func)
             return func
@@ -682,9 +645,7 @@ def on_read_receipt(
         """Register a read_receipt activity handler."""
 
         def decorator(func: BasicHandler[ReadReceiptEventActivity]) -> BasicHandler[ReadReceiptEventActivity]:
-            validate_handler_type(
-                self.logger, func, ReadReceiptEventActivity, "on_read_receipt", "ReadReceiptEventActivity"
-            )
+            validate_handler_type(func, ReadReceiptEventActivity, "on_read_receipt", "ReadReceiptEventActivity")
             config = ACTIVITY_ROUTES["read_receipt"]
             self.router.add_handler(config.selector, func)
             return func
@@ -709,9 +670,7 @@ def on_meeting_start(
         """Register a meeting_start activity handler."""
 
         def decorator(func: BasicHandler[MeetingStartEventActivity]) -> BasicHandler[MeetingStartEventActivity]:
-            validate_handler_type(
-                self.logger, func, MeetingStartEventActivity, "on_meeting_start", "MeetingStartEventActivity"
-            )
+            validate_handler_type(func, MeetingStartEventActivity, "on_meeting_start", "MeetingStartEventActivity")
             config = ACTIVITY_ROUTES["meeting_start"]
             self.router.add_handler(config.selector, func)
             return func
@@ -736,9 +695,7 @@ def on_meeting_end(
         """Register a meeting_end activity handler."""
 
         def decorator(func: BasicHandler[MeetingEndEventActivity]) -> BasicHandler[MeetingEndEventActivity]:
-            validate_handler_type(
-                self.logger, func, MeetingEndEventActivity, "on_meeting_end", "MeetingEndEventActivity"
-            )
+            validate_handler_type(func, MeetingEndEventActivity, "on_meeting_end", "MeetingEndEventActivity")
             config = ACTIVITY_ROUTES["meeting_end"]
             self.router.add_handler(config.selector, func)
             return func
@@ -768,7 +725,6 @@ def decorator(
             func: BasicHandler[MeetingParticipantJoinEventActivity],
         ) -> BasicHandler[MeetingParticipantJoinEventActivity]:
             validate_handler_type(
-                self.logger,
                 func,
                 MeetingParticipantJoinEventActivity,
                 "on_meeting_participant_join",
@@ -803,7 +759,6 @@ def decorator(
             func: BasicHandler[MeetingParticipantLeaveEventActivity],
         ) -> BasicHandler[MeetingParticipantLeaveEventActivity]:
             validate_handler_type(
-                self.logger,
                 func,
                 MeetingParticipantLeaveEventActivity,
                 "on_meeting_participant_leave",
@@ -838,9 +793,7 @@ def on_config_open(
         def decorator(
             func: InvokeHandler[ConfigFetchInvokeActivity, ConfigInvokeResponse],
         ) -> InvokeHandler[ConfigFetchInvokeActivity, ConfigInvokeResponse]:
-            validate_handler_type(
-                self.logger, func, ConfigFetchInvokeActivity, "on_config_open", "ConfigFetchInvokeActivity"
-            )
+            validate_handler_type(func, ConfigFetchInvokeActivity, "on_config_open", "ConfigFetchInvokeActivity")
             config = ACTIVITY_ROUTES["config.open"]
             self.router.add_handler(config.selector, func)
             return func
@@ -870,9 +823,7 @@ def on_config_submit(
         def decorator(
             func: InvokeHandler[ConfigSubmitInvokeActivity, ConfigInvokeResponse],
         ) -> InvokeHandler[ConfigSubmitInvokeActivity, ConfigInvokeResponse]:
-            validate_handler_type(
-                self.logger, func, ConfigSubmitInvokeActivity, "on_config_submit", "ConfigSubmitInvokeActivity"
-            )
+            validate_handler_type(func, ConfigSubmitInvokeActivity, "on_config_submit", "ConfigSubmitInvokeActivity")
             config = ACTIVITY_ROUTES["config.submit"]
             self.router.add_handler(config.selector, func)
             return func
@@ -899,9 +850,7 @@ def on_file_consent(
         def decorator(
             func: VoidInvokeHandler[FileConsentInvokeActivity],
         ) -> VoidInvokeHandler[FileConsentInvokeActivity]:
-            validate_handler_type(
-                self.logger, func, FileConsentInvokeActivity, "on_file_consent", "FileConsentInvokeActivity"
-            )
+            validate_handler_type(func, FileConsentInvokeActivity, "on_file_consent", "FileConsentInvokeActivity")
             config = ACTIVITY_ROUTES["file.consent"]
             self.router.add_handler(config.selector, func)
             return func
@@ -929,7 +878,7 @@ def decorator(
             func: VoidInvokeHandler[ExecuteActionInvokeActivity],
         ) -> VoidInvokeHandler[ExecuteActionInvokeActivity]:
             validate_handler_type(
-                self.logger, func, ExecuteActionInvokeActivity, "on_message_execute", "ExecuteActionInvokeActivity"
+                func, ExecuteActionInvokeActivity, "on_message_execute", "ExecuteActionInvokeActivity"
             )
             config = ACTIVITY_ROUTES["message.execute"]
             self.router.add_handler(config.selector, func)
@@ -964,7 +913,6 @@ def decorator(
             func: InvokeHandler[MessageExtensionQueryLinkInvokeActivity, MessagingExtensionInvokeResponse],
         ) -> InvokeHandler[MessageExtensionQueryLinkInvokeActivity, MessagingExtensionInvokeResponse]:
             validate_handler_type(
-                self.logger,
                 func,
                 MessageExtensionQueryLinkInvokeActivity,
                 "on_message_ext_query_link",
@@ -1003,7 +951,6 @@ def decorator(
             func: InvokeHandler[MessageExtensionAnonQueryLinkInvokeActivity, MessagingExtensionInvokeResponse],
         ) -> InvokeHandler[MessageExtensionAnonQueryLinkInvokeActivity, MessagingExtensionInvokeResponse]:
             validate_handler_type(
-                self.logger,
                 func,
                 MessageExtensionAnonQueryLinkInvokeActivity,
                 "on_message_ext_anon_query_link",
@@ -1040,11 +987,7 @@ def decorator(
             func: InvokeHandler[MessageExtensionQueryInvokeActivity, MessagingExtensionInvokeResponse],
         ) -> InvokeHandler[MessageExtensionQueryInvokeActivity, MessagingExtensionInvokeResponse]:
             validate_handler_type(
-                self.logger,
-                func,
-                MessageExtensionQueryInvokeActivity,
-                "on_message_ext_query",
-                "MessageExtensionQueryInvokeActivity",
+                func, MessageExtensionQueryInvokeActivity, "on_message_ext_query", "MessageExtensionQueryInvokeActivity"
             )
             config = ACTIVITY_ROUTES["message.ext.query"]
             self.router.add_handler(config.selector, func)
@@ -1079,7 +1022,6 @@ def decorator(
             func: InvokeHandler[MessageExtensionSelectItemInvokeActivity, MessagingExtensionInvokeResponse],
         ) -> InvokeHandler[MessageExtensionSelectItemInvokeActivity, MessagingExtensionInvokeResponse]:
             validate_handler_type(
-                self.logger,
                 func,
                 MessageExtensionSelectItemInvokeActivity,
                 "on_message_ext_select_item",
@@ -1118,7 +1060,6 @@ def decorator(
             func: InvokeHandler[MessageExtensionSubmitActionInvokeActivity, MessagingExtensionActionInvokeResponse],
         ) -> InvokeHandler[MessageExtensionSubmitActionInvokeActivity, MessagingExtensionActionInvokeResponse]:
             validate_handler_type(
-                self.logger,
                 func,
                 MessageExtensionSubmitActionInvokeActivity,
                 "on_message_ext_submit",
@@ -1157,7 +1098,6 @@ def decorator(
             func: InvokeHandler[MessageExtensionFetchTaskInvokeActivity, MessagingExtensionActionInvokeResponse],
         ) -> InvokeHandler[MessageExtensionFetchTaskInvokeActivity, MessagingExtensionActionInvokeResponse]:
             validate_handler_type(
-                self.logger,
                 func,
                 MessageExtensionFetchTaskInvokeActivity,
                 "on_message_ext_open",
@@ -1196,7 +1136,6 @@ def decorator(
             func: InvokeHandler[MessageExtensionQuerySettingUrlInvokeActivity, MessagingExtensionInvokeResponse],
         ) -> InvokeHandler[MessageExtensionQuerySettingUrlInvokeActivity, MessagingExtensionInvokeResponse]:
             validate_handler_type(
-                self.logger,
                 func,
                 MessageExtensionQuerySettingUrlInvokeActivity,
                 "on_message_ext_query_settings_url",
@@ -1235,7 +1174,6 @@ def decorator(
             func: InvokeHandler[MessageExtensionSettingInvokeActivity, MessagingExtensionInvokeResponse],
         ) -> InvokeHandler[MessageExtensionSettingInvokeActivity, MessagingExtensionInvokeResponse]:
             validate_handler_type(
-                self.logger,
                 func,
                 MessageExtensionSettingInvokeActivity,
                 "on_message_ext_setting",
@@ -1271,7 +1209,6 @@ def decorator(
             func: VoidInvokeHandler[MessageExtensionCardButtonClickedInvokeActivity],
         ) -> VoidInvokeHandler[MessageExtensionCardButtonClickedInvokeActivity]:
             validate_handler_type(
-                self.logger,
                 func,
                 MessageExtensionCardButtonClickedInvokeActivity,
                 "on_message_ext_card_button_clicked",
@@ -1306,9 +1243,7 @@ def on_dialog_open(
         def decorator(
             func: InvokeHandler[TaskFetchInvokeActivity, TaskModuleInvokeResponse],
         ) -> InvokeHandler[TaskFetchInvokeActivity, TaskModuleInvokeResponse]:
-            validate_handler_type(
-                self.logger, func, TaskFetchInvokeActivity, "on_dialog_open", "TaskFetchInvokeActivity"
-            )
+            validate_handler_type(func, TaskFetchInvokeActivity, "on_dialog_open", "TaskFetchInvokeActivity")
             config = ACTIVITY_ROUTES["dialog.open"]
             self.router.add_handler(config.selector, func)
             return func
@@ -1338,9 +1273,7 @@ def on_dialog_submit(
         def decorator(
             func: InvokeHandler[TaskSubmitInvokeActivity, TaskModuleInvokeResponse],
         ) -> InvokeHandler[TaskSubmitInvokeActivity, TaskModuleInvokeResponse]:
-            validate_handler_type(
-                self.logger, func, TaskSubmitInvokeActivity, "on_dialog_submit", "TaskSubmitInvokeActivity"
-            )
+            validate_handler_type(func, TaskSubmitInvokeActivity, "on_dialog_submit", "TaskSubmitInvokeActivity")
             config = ACTIVITY_ROUTES["dialog.submit"]
             self.router.add_handler(config.selector, func)
             return func
@@ -1370,7 +1303,7 @@ def on_tab_open(
         def decorator(
             func: InvokeHandler[TabFetchInvokeActivity, TabInvokeResponse],
         ) -> InvokeHandler[TabFetchInvokeActivity, TabInvokeResponse]:
-            validate_handler_type(self.logger, func, TabFetchInvokeActivity, "on_tab_open", "TabFetchInvokeActivity")
+            validate_handler_type(func, TabFetchInvokeActivity, "on_tab_open", "TabFetchInvokeActivity")
             config = ACTIVITY_ROUTES["tab.open"]
             self.router.add_handler(config.selector, func)
             return func
@@ -1400,9 +1333,7 @@ def on_tab_submit(
         def decorator(
             func: InvokeHandler[TabSubmitInvokeActivity, TabInvokeResponse],
         ) -> InvokeHandler[TabSubmitInvokeActivity, TabInvokeResponse]:
-            validate_handler_type(
-                self.logger, func, TabSubmitInvokeActivity, "on_tab_submit", "TabSubmitInvokeActivity"
-            )
+            validate_handler_type(func, TabSubmitInvokeActivity, "on_tab_submit", "TabSubmitInvokeActivity")
             config = ACTIVITY_ROUTES["tab.submit"]
             self.router.add_handler(config.selector, func)
             return func
@@ -1432,11 +1363,7 @@ def decorator(
             func: VoidInvokeHandler[MessageSubmitActionInvokeActivity],
         ) -> VoidInvokeHandler[MessageSubmitActionInvokeActivity]:
             validate_handler_type(
-                self.logger,
-                func,
-                MessageSubmitActionInvokeActivity,
-                "on_message_submit",
-                "MessageSubmitActionInvokeActivity",
+                func, MessageSubmitActionInvokeActivity, "on_message_submit", "MessageSubmitActionInvokeActivity"
             )
             config = ACTIVITY_ROUTES["message.submit"]
             self.router.add_handler(config.selector, func)
@@ -1467,7 +1394,6 @@ def decorator(
             func: VoidInvokeHandler[MessageSubmitActionInvokeActivity],
         ) -> VoidInvokeHandler[MessageSubmitActionInvokeActivity]:
             validate_handler_type(
-                self.logger,
                 func,
                 MessageSubmitActionInvokeActivity,
                 "on_message_submit_feedback",
@@ -1499,9 +1425,7 @@ def on_handoff_action(
         def decorator(
             func: VoidInvokeHandler[HandoffActionInvokeActivity],
         ) -> VoidInvokeHandler[HandoffActionInvokeActivity]:
-            validate_handler_type(
-                self.logger, func, HandoffActionInvokeActivity, "on_handoff_action", "HandoffActionInvokeActivity"
-            )
+            validate_handler_type(func, HandoffActionInvokeActivity, "on_handoff_action", "HandoffActionInvokeActivity")
             config = ACTIVITY_ROUTES["handoff.action"]
             self.router.add_handler(config.selector, func)
             return func
@@ -1533,11 +1457,7 @@ def decorator(
             func: InvokeHandler[SignInTokenExchangeInvokeActivity, TokenExchangeInvokeResponseType],
         ) -> InvokeHandler[SignInTokenExchangeInvokeActivity, TokenExchangeInvokeResponseType]:
             validate_handler_type(
-                self.logger,
-                func,
-                SignInTokenExchangeInvokeActivity,
-                "on_signin_token_exchange",
-                "SignInTokenExchangeInvokeActivity",
+                func, SignInTokenExchangeInvokeActivity, "on_signin_token_exchange", "SignInTokenExchangeInvokeActivity"
             )
             config = ACTIVITY_ROUTES["signin.token-exchange"]
             self.router.add_handler(config.selector, func)
@@ -1568,11 +1488,7 @@ def decorator(
             func: VoidInvokeHandler[SignInVerifyStateInvokeActivity],
         ) -> VoidInvokeHandler[SignInVerifyStateInvokeActivity]:
             validate_handler_type(
-                self.logger,
-                func,
-                SignInVerifyStateInvokeActivity,
-                "on_signin_verify_state",
-                "SignInVerifyStateInvokeActivity",
+                func, SignInVerifyStateInvokeActivity, "on_signin_verify_state", "SignInVerifyStateInvokeActivity"
             )
             config = ACTIVITY_ROUTES["signin.verify-state"]
             self.router.add_handler(config.selector, func)
@@ -1595,22 +1511,12 @@ def on_signin_failure(
     def on_signin_failure(
         self, handler: Optional[VoidInvokeHandler[SignInFailureInvokeActivity]] = None
     ) -> VoidInvokeHandlerUnion[SignInFailureInvokeActivity]:
-        """Register a signin.failure activity handler.
-
-        Handles signin/failure invoke activities sent by Teams when a sign-in
-        operation fails (e.g., SSO token exchange resource mismatch).
-        """
+        """Register a signin.failure activity handler."""
 
         def decorator(
             func: VoidInvokeHandler[SignInFailureInvokeActivity],
         ) -> VoidInvokeHandler[SignInFailureInvokeActivity]:
-            validate_handler_type(
-                self.logger,
-                func,
-                SignInFailureInvokeActivity,
-                "on_signin_failure",
-                "SignInFailureInvokeActivity",
-            )
+            validate_handler_type(func, SignInFailureInvokeActivity, "on_signin_failure", "SignInFailureInvokeActivity")
             config = ACTIVITY_ROUTES["signin.failure"]
             self.router.add_handler(config.selector, func)
             return func
@@ -1640,9 +1546,7 @@ def on_card_action(
         def decorator(
             func: InvokeHandler[AdaptiveCardInvokeActivity, AdaptiveCardInvokeResponse],
         ) -> InvokeHandler[AdaptiveCardInvokeActivity, AdaptiveCardInvokeResponse]:
-            validate_handler_type(
-                self.logger, func, AdaptiveCardInvokeActivity, "on_card_action", "AdaptiveCardInvokeActivity"
-            )
+            validate_handler_type(func, AdaptiveCardInvokeActivity, "on_card_action", "AdaptiveCardInvokeActivity")
             config = ACTIVITY_ROUTES["card.action"]
             self.router.add_handler(config.selector, func)
             return func
@@ -1661,7 +1565,7 @@ def on_invoke(self, handler: Optional[BasicHandler[InvokeActivity]] = None) -> B
         """Register a invoke activity handler."""
 
         def decorator(func: BasicHandler[InvokeActivity]) -> BasicHandler[InvokeActivity]:
-            validate_handler_type(self.logger, func, InvokeActivity, "on_invoke", "InvokeActivity")
+            validate_handler_type(func, InvokeActivity, "on_invoke", "InvokeActivity")
             config = ACTIVITY_ROUTES["invoke"]
             self.router.add_handler(config.selector, func)
             return func
@@ -1686,9 +1590,7 @@ def on_installation_update(
         """Register a installation_update activity handler."""
 
         def decorator(func: BasicHandler[InstallUpdateActivity]) -> BasicHandler[InstallUpdateActivity]:
-            validate_handler_type(
-                self.logger, func, InstallUpdateActivity, "on_installation_update", "InstallUpdateActivity"
-            )
+            validate_handler_type(func, InstallUpdateActivity, "on_installation_update", "InstallUpdateActivity")
             config = ACTIVITY_ROUTES["installation_update"]
             self.router.add_handler(config.selector, func)
             return func
@@ -1709,7 +1611,7 @@ def on_install_add(
         """Register a install.add activity handler."""
 
         def decorator(func: BasicHandler[InstalledActivity]) -> BasicHandler[InstalledActivity]:
-            validate_handler_type(self.logger, func, InstalledActivity, "on_install_add", "InstalledActivity")
+            validate_handler_type(func, InstalledActivity, "on_install_add", "InstalledActivity")
             config = ACTIVITY_ROUTES["install.add"]
             self.router.add_handler(config.selector, func)
             return func
@@ -1730,7 +1632,7 @@ def on_install_remove(
         """Register a install.remove activity handler."""
 
         def decorator(func: BasicHandler[UninstalledActivity]) -> BasicHandler[UninstalledActivity]:
-            validate_handler_type(self.logger, func, UninstalledActivity, "on_install_remove", "UninstalledActivity")
+            validate_handler_type(func, UninstalledActivity, "on_install_remove", "UninstalledActivity")
             config = ACTIVITY_ROUTES["install.remove"]
             self.router.add_handler(config.selector, func)
             return func
@@ -1749,7 +1651,7 @@ def on_typing(self, handler: Optional[BasicHandler[TypingActivity]] = None) -> B
         """Register a typing activity handler."""
 
         def decorator(func: BasicHandler[TypingActivity]) -> BasicHandler[TypingActivity]:
-            validate_handler_type(self.logger, func, TypingActivity, "on_typing", "TypingActivity")
+            validate_handler_type(func, TypingActivity, "on_typing", "TypingActivity")
             config = ACTIVITY_ROUTES["typing"]
             self.router.add_handler(config.selector, func)
             return func
@@ -1768,7 +1670,7 @@ def on_trace(self, handler: Optional[BasicHandler[TraceActivity]] = None) -> Bas
         """Register a trace activity handler."""
 
         def decorator(func: BasicHandler[TraceActivity]) -> BasicHandler[TraceActivity]:
-            validate_handler_type(self.logger, func, TraceActivity, "on_trace", "TraceActivity")
+            validate_handler_type(func, TraceActivity, "on_trace", "TraceActivity")
             config = ACTIVITY_ROUTES["trace"]
             self.router.add_handler(config.selector, func)
             return func
@@ -1787,7 +1689,7 @@ def on_handoff(self, handler: Optional[BasicHandler[HandoffActivity]] = None) ->
         """Register a handoff activity handler."""
 
         def decorator(func: BasicHandler[HandoffActivity]) -> BasicHandler[HandoffActivity]:
-            validate_handler_type(self.logger, func, HandoffActivity, "on_handoff", "HandoffActivity")
+            validate_handler_type(func, HandoffActivity, "on_handoff", "HandoffActivity")
             config = ACTIVITY_ROUTES["handoff"]
             self.router.add_handler(config.selector, func)
             return func
@@ -1806,7 +1708,7 @@ def on_activity(self, handler: Optional[BasicHandler[Activity]] = None) -> Basic
         """Register a activity activity handler."""
 
         def decorator(func: BasicHandler[Activity]) -> BasicHandler[Activity]:
-            validate_handler_type(self.logger, func, Activity, "on_activity", "Activity")
+            validate_handler_type(func, Activity, "on_activity", "Activity")
             config = ACTIVITY_ROUTES["activity"]
             self.router.add_handler(config.selector, func)
             return func
diff --git a/packages/apps/src/microsoft_teams/apps/routing/type_validation.py b/packages/apps/src/microsoft_teams/apps/routing/type_validation.py
index ccc92c33..26cc9a80 100644
--- a/packages/apps/src/microsoft_teams/apps/routing/type_validation.py
+++ b/packages/apps/src/microsoft_teams/apps/routing/type_validation.py
@@ -4,14 +4,15 @@
 """
 
 import inspect
-from logging import Logger
+import logging
 from typing import Any, Callable, Optional
 
 from .activity_context import ActivityContext
 
+logger = logging.getLogger(__name__)
+
 
 def validate_handler_type(
-    logger: Logger,
     func: Callable[[Any], Any],
     expected_activity_type: Any,
     method_name: str,
diff --git a/packages/apps/src/microsoft_teams/apps/token_manager.py b/packages/apps/src/microsoft_teams/apps/token_manager.py
index 6053f776..9dc84718 100644
--- a/packages/apps/src/microsoft_teams/apps/token_manager.py
+++ b/packages/apps/src/microsoft_teams/apps/token_manager.py
@@ -20,7 +20,6 @@
     ManagedIdentityCredentials,
     TokenCredentials,
 )
-from microsoft_teams.common import ConsoleLogger
 from msal import (
     ConfidentialClientApplication,
     ManagedIdentityClient,
@@ -34,6 +33,8 @@
 DEFAULT_TENANT_FOR_GRAPH_TOKEN = "common"
 DEFAULT_TOKEN_AUTHORITY = "https://login.microsoftonline.com/{tenant_id}"
 
+logger = logging.getLogger(__name__)
+
 
 class TokenManager:
     """Manages authentication tokens for the Teams application."""
@@ -41,15 +42,8 @@ class TokenManager:
     def __init__(
         self,
         credentials: Optional[Credentials],
-        logger: Optional[logging.Logger] = None,
     ):
         self._credentials = credentials
-
-        if not logger:
-            self._logger = ConsoleLogger().create_logger("TokenManager")
-        else:
-            self._logger = logger.getChild("TokenManager")
-
         self._confidential_clients_by_tenant: dict[str, ConfidentialClientApplication] = {}
         self._managed_identity_client: Optional[ManagedIdentityClient] = None
 
@@ -80,7 +74,7 @@ async def _get_token(
         credentials = self._credentials
         if self._credentials is None:
             if caller_name:
-                self._logger.debug(f"No credentials provided for {caller_name}")
+                logger.debug(f"No credentials provided for {caller_name}")
             return None
         if isinstance(credentials, ClientCredentials):
             return await self._get_token_with_client_credentials(credentials, scope, tenant_id)
@@ -159,7 +153,7 @@ async def _acquire_managed_identity_token(self, credentials: FederatedIdentityCr
         )
 
         if not mi_token_res.get("access_token"):
-            self._logger.error("FIC Step 1 failed: Could not acquire MI token")
+            logger.error("FIC Step 1 failed: Could not acquire MI token")
             error = mi_token_res.get("error", ValueError("Error retrieving MI token"))
             if not isinstance(error, BaseException):
                 error = ValueError(error)
@@ -190,15 +184,15 @@ def _handle_token_response(self, token_res: dict[str, Any], error_prefix: str =
             return JsonWebToken(access_token)
         else:
             error_msg = f"{error_prefix}: " if error_prefix else ""
-            self._logger.error(f"{error_msg}Could not acquire access token")
-            self._logger.debug(f"TokenRes: {token_res}")
+            logger.error(f"{error_msg}Could not acquire access token")
+            logger.debug(f"TokenRes: {token_res}")
 
             error = token_res.get("error", "Error retrieving token")
             if not isinstance(error, BaseException):
                 error = ValueError(error)
 
             error_description = token_res.get("error_description", "Error retrieving token from MSAL")
-            self._logger.error(error_description)
+            logger.error(error_description)
             raise error
 
     def _get_confidential_client(self, credentials: ClientCredentials, tenant_id: str) -> ConfidentialClientApplication:
diff --git a/packages/apps/src/microsoft_teams/apps/utils/retry.py b/packages/apps/src/microsoft_teams/apps/utils/retry.py
index dc7ebb76..99c0e25b 100644
--- a/packages/apps/src/microsoft_teams/apps/utils/retry.py
+++ b/packages/apps/src/microsoft_teams/apps/utils/retry.py
@@ -4,14 +4,14 @@
 """
 
 import asyncio
+import logging
 import random
-from logging import Logger
 from typing import Awaitable, Callable, Literal, Optional, TypeVar
 
-from microsoft_teams.common import ConsoleLogger
-
 T = TypeVar("T")
 
+logger = logging.getLogger(__name__)
+
 # Type alias for jitter types using string literals
 JitterType = Literal["none", "full", "equal", "decorrelated"]
 
@@ -23,21 +23,13 @@ def __init__(
         delay: float = 0.5,  # in seconds
         max_delay: float = 30.0,  # maximum delay cap
         jitter_type: JitterType = "full",
-        logger: Optional[Logger] = None,
         previous_delay: Optional[float] = None,  # Internal use for decorrelated jitter
         attempt_number: int = 1,  # Internal use to track current attempt number
-        _internal_logger: Optional[Logger] = None,  # Internal use to pass existing child logger
     ):
         self.max_attempts = max_attempts
         self.delay = delay
         self.max_delay = max_delay
         self.jitter_type: JitterType = jitter_type
-        # Use existing internal logger if provided, otherwise create child logger
-        self.logger = (
-            _internal_logger
-            if _internal_logger
-            else (logger.getChild("@teams/retry") if logger else ConsoleLogger().create_logger("@teams/retry"))
-        )
         self.previous_delay = previous_delay
         self.attempt_number = attempt_number
 
@@ -68,7 +60,6 @@ async def retry(factory: Callable[[], Awaitable[T]], options: Optional[RetryOpti
     base_delay = options.delay
     max_delay = options.max_delay
     jitter_type: JitterType = options.jitter_type
-    logger = options.logger
     previous_delay = options.previous_delay
     attempt_number = options.attempt_number
 
@@ -102,7 +93,6 @@ async def retry(factory: Callable[[], Awaitable[T]], options: Optional[RetryOpti
                     jitter_type=jitter_type,
                     previous_delay=jittered_delay,  # Pass current delay for decorrelated jitter
                     attempt_number=attempt_number + 1,  # Increment attempt number
-                    _internal_logger=logger,  # Pass the existing logger to avoid nested children
                 ),
             )
         logger.error("Final attempt failed.", exc_info=err)
diff --git a/packages/apps/tests/conftest.py b/packages/apps/tests/conftest.py
index 13e206a4..435b83d5 100644
--- a/packages/apps/tests/conftest.py
+++ b/packages/apps/tests/conftest.py
@@ -3,6 +3,8 @@
 Licensed under the MIT License.
 """
 
+import logging
+
 import pytest
 from microsoft_teams.api import (
     Account,
@@ -32,6 +34,18 @@ def reset_environment():
     os.environ.update(original_env)
 
 
+@pytest.fixture(autouse=True)
+def configure_logging():
+    """Configure logging for tests to ensure DEBUG logs are captured."""
+    # Set the microsoft_teams logger to DEBUG level so caplog can capture DEBUG logs
+    logger = logging.getLogger("microsoft_teams")
+    original_level = logger.level
+    logger.setLevel(logging.DEBUG)
+    yield
+    # Restore original level after test
+    logger.setLevel(original_level)
+
+
 @pytest.fixture
 def mock_account():
     """Create a mock account for testing."""
diff --git a/packages/apps/tests/test_activity_context.py b/packages/apps/tests/test_activity_context.py
index 9cb6048b..ab1346b6 100644
--- a/packages/apps/tests/test_activity_context.py
+++ b/packages/apps/tests/test_activity_context.py
@@ -3,49 +3,55 @@
 Licensed under the MIT License.
 """
 
+# pyright: basic
+
 from typing import Any
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 from microsoft_teams.api import Account, MessageActivityInput, SentActivity
 from microsoft_teams.apps.routing.activity_context import ActivityContext
 
 
+def _create_activity_context(
+    is_signed_in: bool = False,
+    user_token: str | None = None,
+    activity: Any = None,
+) -> tuple[ActivityContext[Any], MagicMock]:
+    mock_activity = activity if activity is not None else MagicMock()
+
+    mock_activity_sender = MagicMock()
+    mock_activity_sender.send = AsyncMock(
+        return_value=SentActivity(
+            id="sent-activity-id",
+            activity_params=MessageActivityInput(text="sent"),
+        )
+    )
+    mock_activity_sender.create_stream = MagicMock(return_value=MagicMock())
+
+    ctx = ActivityContext(
+        activity=mock_activity,
+        app_id="test-app-id",
+        storage=MagicMock(),
+        api=MagicMock(),
+        user_token=user_token,
+        conversation_ref=MagicMock(),
+        is_signed_in=is_signed_in,
+        connection_name="test-connection",
+        activity_sender=mock_activity_sender,
+        app_token=MagicMock(),
+    )
+    return ctx, mock_activity_sender
+
+
 class TestActivityContextSendTargeted:
     """Tests for ActivityContext.send() with targeted message recipient inference."""
 
-    def _create_activity_context(
-        self,
-        from_account: Account,
-    ) -> ActivityContext[Any]:
-        """Create an ActivityContext for testing with a mock sender."""
+    def _create_activity_context(self, from_account: Account) -> tuple[ActivityContext[Any], MagicMock]:
+        """Create an ActivityContext for testing with a mock activity sender."""
         mock_activity = MagicMock()
         mock_activity.from_ = from_account
-
-        mock_sender = MagicMock()
-        mock_sender.send = AsyncMock(
-            return_value=SentActivity(
-                id="sent-activity-id",
-                activity_params=MessageActivityInput(text="sent"),
-            )
-        )
-        mock_sender.create_stream = MagicMock(return_value=MagicMock())
-
-        mock_conversation_ref = MagicMock()
-
-        return ActivityContext(
-            activity=mock_activity,
-            app_id="test-app-id",
-            logger=MagicMock(),
-            storage=MagicMock(),
-            api=MagicMock(),
-            user_token=None,
-            conversation_ref=mock_conversation_ref,
-            is_signed_in=False,
-            connection_name="test-connection",
-            sender=mock_sender,
-            app_token=MagicMock(),
-        )
+        return _create_activity_context(activity=mock_activity)
 
     @pytest.mark.asyncio
     async def test_targeted_message_with_explicit_recipient(self) -> None:
@@ -54,7 +60,7 @@ async def test_targeted_message_with_explicit_recipient(self) -> None:
         the recipient should be passed through correctly.
         """
         incoming_sender = Account(id="user-123", name="Test User")
-        ctx = self._create_activity_context(from_account=incoming_sender)
+        ctx, mock_sender = self._create_activity_context(from_account=incoming_sender)
 
         # Create a targeted message with recipient explicitly set
         activity = MessageActivityInput(text="Hello").with_recipient(incoming_sender, is_targeted=True)
@@ -64,13 +70,16 @@ async def test_targeted_message_with_explicit_recipient(self) -> None:
         await ctx.send(activity)
 
         # Verify send was called
-        ctx._plugin.send.assert_called_once()
+        mock_sender.send.assert_called_once()
 
         # Get the activity that was passed to send
-        sent_activity = ctx._plugin.send.call_args[0][0]
+        sent_activity = mock_sender.send.call_args[0][0]
 
         # Verify recipient was preserved
-        assert sent_activity.recipient == incoming_sender
+        assert sent_activity.recipient is not None
+        assert sent_activity.recipient.id == incoming_sender.id
+        assert sent_activity.recipient.name == incoming_sender.name
+        assert sent_activity.recipient.is_targeted is True
 
     @pytest.mark.asyncio
     async def test_targeted_update_preserves_recipient(self) -> None:
@@ -78,7 +87,7 @@ async def test_targeted_update_preserves_recipient(self) -> None:
         When updating a targeted message, the recipient should be preserved.
         """
         incoming_sender = Account(id="user-123", name="Test User")
-        ctx = self._create_activity_context(from_account=incoming_sender)
+        ctx, mock_sender = self._create_activity_context(from_account=incoming_sender)
 
         # Create a targeted message update (has id set)
         activity = MessageActivityInput(text="Updated text").with_recipient(incoming_sender, is_targeted=True)
@@ -87,13 +96,16 @@ async def test_targeted_update_preserves_recipient(self) -> None:
         await ctx.send(activity)
 
         # Verify send was called
-        ctx._plugin.send.assert_called_once()
+        mock_sender.send.assert_called_once()
 
         # Get the activity that was passed to send
-        sent_activity = ctx._plugin.send.call_args[0][0]
+        sent_activity = mock_sender.send.call_args[0][0]
 
         # Verify recipient was preserved
-        assert sent_activity.recipient == incoming_sender
+        assert sent_activity.recipient is not None
+        assert sent_activity.recipient.id == incoming_sender.id
+        assert sent_activity.recipient.name == incoming_sender.name
+        assert sent_activity.recipient.is_targeted is True
 
     @pytest.mark.asyncio
     async def test_targeted_with_different_recipient(self) -> None:
@@ -103,7 +115,7 @@ async def test_targeted_with_different_recipient(self) -> None:
         """
         incoming_sender = Account(id="user-123", name="Test User")
         explicit_recipient = Account(id="other-user-456", name="Other User", role="user")
-        ctx = self._create_activity_context(from_account=incoming_sender)
+        ctx, mock_sender = self._create_activity_context(from_account=incoming_sender)
 
         # Create a targeted message with explicit recipient
         activity = MessageActivityInput(text="Hello").with_recipient(explicit_recipient, is_targeted=True)
@@ -112,10 +124,10 @@ async def test_targeted_with_different_recipient(self) -> None:
         await ctx.send(activity)
 
         # Verify send was called
-        ctx._plugin.send.assert_called_once()
+        mock_sender.send.assert_called_once()
 
         # Get the activity that was passed to send
-        sent_activity = ctx._plugin.send.call_args[0][0]
+        sent_activity = mock_sender.send.call_args[0][0]
 
         # Verify recipient was preserved
         assert sent_activity.recipient is not None
@@ -127,20 +139,252 @@ async def test_non_targeted_message_does_not_set_recipient(self) -> None:
         When sending a non-targeted message, the recipient should not be set.
         """
         incoming_sender = Account(id="user-123", name="Test User")
-        ctx = self._create_activity_context(from_account=incoming_sender)
+        ctx, mock_sender = self._create_activity_context(from_account=incoming_sender)
 
         # Create a regular (non-targeted) message
         activity = MessageActivityInput(text="Hello")
-        assert activity.is_targeted is None
         assert activity.recipient is None
 
         await ctx.send(activity)
 
         # Verify send was called
-        ctx._plugin.send.assert_called_once()
+        mock_sender.send.assert_called_once()
 
         # Get the activity that was passed to send
-        sent_activity = ctx._plugin.send.call_args[0][0]
+        sent_activity = mock_sender.send.call_args[0][0]
 
         # Verify recipient was NOT set for non-targeted messages
         assert sent_activity.recipient is None
+
+
+class TestActivityContextSend:
+    """Tests for ActivityContext.send() with string and AdaptiveCard inputs."""
+
+    @pytest.mark.asyncio
+    async def test_send_with_string_message(self) -> None:
+        """Sending a plain string wraps it in a MessageActivityInput."""
+        ctx, mock_sender = _create_activity_context()
+
+        result = await ctx.send("Hello, world!")
+
+        mock_sender.send.assert_called_once()
+        sent_activity = mock_sender.send.call_args[0][0]
+        assert isinstance(sent_activity, MessageActivityInput)
+        assert sent_activity.text == "Hello, world!"
+        assert isinstance(result, SentActivity)
+
+    @pytest.mark.asyncio
+    async def test_send_with_adaptive_card(self) -> None:
+        """Sending an AdaptiveCard wraps it via add_card."""
+        from microsoft_teams.cards import AdaptiveCard
+
+        ctx, mock_sender = _create_activity_context()
+        card = AdaptiveCard()
+
+        result = await ctx.send(card)
+
+        mock_sender.send.assert_called_once()
+        sent_activity = mock_sender.send.call_args[0][0]
+        assert isinstance(sent_activity, MessageActivityInput)
+        # The card should have been attached
+        assert sent_activity.attachments is not None
+        assert len(sent_activity.attachments) > 0
+        assert isinstance(result, SentActivity)
+
+
+class TestActivityContextReply:
+    """Tests for ActivityContext.reply()."""
+
+    @pytest.mark.asyncio
+    async def test_reply_with_string(self) -> None:
+        """reply() with a plain string sends a message with reply_to_id set."""
+        mock_activity = MagicMock()
+        mock_activity.type = "message"
+        mock_activity.id = "original-id"
+        mock_activity.text = "Original message"
+        mock_activity.from_ = MagicMock()
+        mock_activity.from_.id = "user-1"
+        mock_activity.from_.name = "User One"
+
+        ctx, mock_sender = _create_activity_context(activity=mock_activity)
+
+        await ctx.reply("My reply")
+
+        mock_sender.send.assert_called_once()
+        sent_activity = mock_sender.send.call_args[0][0]
+        assert isinstance(sent_activity, MessageActivityInput)
+        assert sent_activity.reply_to_id == "original-id"
+        assert "My reply" in (sent_activity.text or "")
+
+    @pytest.mark.asyncio
+    async def test_reply_with_activity_params(self) -> None:
+        """reply() with an ActivityParams instance sets reply_to_id and delegates to send."""
+        mock_activity = MagicMock()
+        mock_activity.type = "event"
+        mock_activity.id = "evt-id-999"
+
+        ctx, mock_sender = _create_activity_context(activity=mock_activity)
+
+        params = MessageActivityInput(text="Params reply")
+        await ctx.reply(params)
+
+        mock_sender.send.assert_called_once()
+        sent_activity = mock_sender.send.call_args[0][0]
+        assert sent_activity.reply_to_id == "evt-id-999"
+
+
+class TestActivityContextBuildBlockQuote:
+    """Tests for ActivityContext._build_block_quote_for_activity()."""
+
+    def _make_message_activity(self, text: str, activity_id: str = "act-1") -> MagicMock:
+        mock_activity = MagicMock()
+        mock_activity.type = "message"
+        mock_activity.id = activity_id
+        mock_activity.text = text
+        mock_activity.from_ = MagicMock()
+        mock_activity.from_.id = "user-xyz"
+        mock_activity.from_.name = "Test User"
+        return mock_activity
+
+    def test_message_activity_returns_html_blockquote(self) -> None:
+        """Activity type 'message' with text produces a blockquote HTML string."""
+        activity = self._make_message_activity("Hello blockquote")
+        ctx, _ = _create_activity_context(activity=activity)
+
+        result = ctx._build_block_quote_for_activity()
+
+        assert result is not None
+        assert "<blockquote" in result
+        assert "Hello blockquote" in result
+        assert "Test User" in result
+        assert "act-1" in result
+
+    def test_long_text_is_truncated(self) -> None:
+        """Text longer than 120 characters is truncated with an ellipsis."""
+        long_text = "A" * 130
+        activity = self._make_message_activity(long_text)
+        ctx, _ = _create_activity_context(activity=activity)
+
+        result = ctx._build_block_quote_for_activity()
+
+        assert result is not None
+        # Truncated text should be 120 chars + "..."
+        assert "A" * 120 + "..." in result
+        # The full text should not be present
+        assert long_text not in result
+
+    def test_non_message_activity_returns_none(self) -> None:
+        """Activity type other than 'message' returns None."""
+        mock_activity = MagicMock()
+        mock_activity.type = "event"
+        ctx, _ = _create_activity_context(activity=mock_activity)
+
+        result = ctx._build_block_quote_for_activity()
+
+        assert result is None
+
+
+class TestActivityContextUserGraph:
+    """Tests for ActivityContext.user_graph property."""
+
+    def test_user_graph_raises_when_not_signed_in(self) -> None:
+        """user_graph raises ValueError when is_signed_in is False."""
+        ctx, _ = _create_activity_context(is_signed_in=False, user_token="some.jwt.token")
+
+        with pytest.raises(ValueError, match="signed in"):
+            _ = ctx.user_graph
+
+    def test_user_graph_raises_when_no_user_token(self) -> None:
+        """user_graph raises ValueError when is_signed_in is True but user_token is None."""
+        ctx, _ = _create_activity_context(is_signed_in=True, user_token=None)
+
+        with pytest.raises(ValueError, match="No user token"):
+            _ = ctx.user_graph
+
+    def test_user_graph_raises_runtime_error_when_graph_import_fails(self) -> None:
+        """user_graph raises RuntimeError when _get_graph_client raises ImportError."""
+        ctx, _ = _create_activity_context(is_signed_in=True, user_token="some.jwt.token")
+
+        with patch(
+            "microsoft_teams.apps.routing.activity_context._get_graph_client",
+            side_effect=ImportError("graph not installed"),
+        ):
+            with pytest.raises(RuntimeError, match="Failed to create user graph client"):
+                _ = ctx.user_graph
+
+
+class TestActivityContextAppGraph:
+    """Tests for ActivityContext.app_graph property."""
+
+    def test_app_graph_raises_runtime_error_when_graph_import_fails(self) -> None:
+        """app_graph raises RuntimeError when _get_graph_client raises ImportError."""
+        ctx, _ = _create_activity_context()
+
+        with patch(
+            "microsoft_teams.apps.routing.activity_context._get_graph_client",
+            side_effect=ImportError("graph not installed"),
+        ):
+            with pytest.raises(RuntimeError, match="Failed to create app graph client"):
+                _ = ctx.app_graph
+
+    def test_app_graph_returns_cached_client_on_second_access(self) -> None:
+        """app_graph returns the same instance on repeated access (lazy-cached)."""
+        mock_graph_client = MagicMock()
+        ctx, _ = _create_activity_context()
+
+        with patch(
+            "microsoft_teams.apps.routing.activity_context._get_graph_client",
+            return_value=mock_graph_client,
+        ):
+            first = ctx.app_graph
+            second = ctx.app_graph
+
+        assert first is second
+        # _get_graph_client should only have been called once (caching)
+        assert ctx._app_graph is mock_graph_client
+
+
+class TestActivityContextSignIn:
+    """Tests for ActivityContext.sign_in()."""
+
+    @pytest.mark.asyncio
+    async def test_sign_in_returns_token_when_already_available(self) -> None:
+        """sign_in returns the existing token when the API call succeeds."""
+        mock_activity = MagicMock()
+        mock_activity.channel_id = "msteams"
+        mock_activity.from_.id = "user-001"
+        mock_activity.relates_to = None
+        mock_activity.conversation.is_group = False
+
+        ctx, _ = _create_activity_context(activity=mock_activity)
+
+        token_response = MagicMock()
+        token_response.token = "existing-token-value"
+        ctx.api.users.token.get = AsyncMock(return_value=token_response)
+
+        result = await ctx.sign_in()
+
+        assert result == "existing-token-value"
+        ctx.api.users.token.get.assert_called_once()
+
+
+class TestActivityContextSignOut:
+    """Tests for ActivityContext.sign_out()."""
+
+    @pytest.mark.asyncio
+    async def test_sign_out_logs_error_and_does_not_raise_on_failure(self) -> None:
+        """sign_out logs the error but does not propagate exceptions."""
+        mock_activity = MagicMock()
+        mock_activity.channel_id = "msteams"
+        mock_activity.from_.id = "user-003"
+
+        ctx, _ = _create_activity_context(activity=mock_activity)
+        ctx.api.users.token.sign_out = AsyncMock(side_effect=Exception("API failure"))
+
+        with patch.object(ctx.logger, "error") as mock_log_error:
+            # Should not raise
+            await ctx.sign_out()
+
+            mock_log_error.assert_called_once()
+            logged_message = mock_log_error.call_args[0][0]
+            assert "Failed to sign out user" in logged_message
diff --git a/packages/apps/tests/test_activity_sender.py b/packages/apps/tests/test_activity_sender.py
new file mode 100644
index 00000000..384edbb9
--- /dev/null
+++ b/packages/apps/tests/test_activity_sender.py
@@ -0,0 +1,172 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+# pyright: basic
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from microsoft_teams.api import (
+    Account,
+    ConversationAccount,
+    ConversationReference,
+    MessageActivityInput,
+    SentActivity,
+)
+from microsoft_teams.apps.activity_sender import ActivitySender
+
+
+class TestActivitySender:
+    """Test cases for ActivitySender."""
+
+    @pytest.fixture
+    def sender(self):
+        """Create an ActivitySender for testing."""
+        mock_client = MagicMock()
+        return ActivitySender(client=mock_client)
+
+    @pytest.fixture
+    def conversation_ref(self):
+        """Create a conversation reference for testing."""
+        return ConversationReference(
+            bot=Account(id="bot-123", name="Test Bot", role="bot"),
+            conversation=ConversationAccount(id="conv-456", conversation_type="personal"),
+            channel_id="msteams",
+            service_url="https://test.service.url",
+        )
+
+    def _create_sent_activity(self, activity, activity_id="msg-123"):
+        """Helper to create a proper SentActivity mock."""
+        return SentActivity(id=activity_id, activity_params=activity)
+
+    @pytest.mark.asyncio
+    async def test_send_new_message_calls_create(self, sender, conversation_ref):
+        """Test that new messages (no id) use the create method."""
+        activity = MessageActivityInput(text="Hello")
+
+        mock_activities = MagicMock()
+        mock_activities.create = AsyncMock(return_value=self._create_sent_activity(activity))
+
+        with patch("microsoft_teams.apps.activity_sender.ApiClient") as mock_api_client:
+            mock_api = MagicMock()
+            mock_api.conversations.activities.return_value = mock_activities
+            mock_api_client.return_value = mock_api
+
+            await sender.send(activity, conversation_ref)
+
+            mock_activities.create.assert_called_once_with(activity)
+
+    @pytest.mark.asyncio
+    async def test_send_existing_message_calls_update(self, sender, conversation_ref):
+        """Test that messages with an id use the update method."""
+        activity = MessageActivityInput(text="Updated message")
+        activity.id = "existing-msg-id"
+
+        mock_activities = MagicMock()
+        mock_activities.update = AsyncMock(return_value=self._create_sent_activity(activity, "existing-msg-id"))
+
+        with patch("microsoft_teams.apps.activity_sender.ApiClient") as mock_api_client:
+            mock_api = MagicMock()
+            mock_api.conversations.activities.return_value = mock_activities
+            mock_api_client.return_value = mock_api
+
+            await sender.send(activity, conversation_ref)
+
+            mock_activities.update.assert_called_once_with("existing-msg-id", activity)
+
+    @pytest.mark.asyncio
+    async def test_send_sets_from_and_conversation(self, sender, conversation_ref):
+        """Test that send merges activity with conversation reference."""
+        activity = MessageActivityInput(text="Hello")
+
+        mock_activities = MagicMock()
+        mock_activities.create = AsyncMock(return_value=self._create_sent_activity(activity))
+
+        with patch("microsoft_teams.apps.activity_sender.ApiClient") as mock_api_client:
+            mock_api = MagicMock()
+            mock_api.conversations.activities.return_value = mock_activities
+            mock_api_client.return_value = mock_api
+
+            await sender.send(activity, conversation_ref)
+
+            assert activity.from_ == conversation_ref.bot
+            assert activity.conversation == conversation_ref.conversation
+
+    @pytest.mark.asyncio
+    async def test_send_targeted_message_calls_create_targeted(self, sender, conversation_ref):
+        """Test that targeted messages use the create_targeted method."""
+        recipient = Account(id="user-123", name="Test User", role="user")
+        activity = MessageActivityInput(text="Hello").with_recipient(recipient, is_targeted=True)
+
+        mock_activities = MagicMock()
+        mock_activities.create_targeted = AsyncMock(return_value=self._create_sent_activity(activity))
+
+        with patch("microsoft_teams.apps.activity_sender.ApiClient") as mock_api_client:
+            mock_api = MagicMock()
+            mock_api.conversations.activities.return_value = mock_activities
+            mock_api_client.return_value = mock_api
+
+            await sender.send(activity, conversation_ref)
+
+            mock_activities.create_targeted.assert_called_once_with(activity)
+            mock_activities.create.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_send_non_targeted_message_does_not_call_create_targeted(self, sender, conversation_ref):
+        """Test that non-targeted messages use the regular create method."""
+        activity = MessageActivityInput(text="Hello")
+
+        mock_activities = MagicMock()
+        mock_activities.create = AsyncMock(return_value=self._create_sent_activity(activity))
+
+        with patch("microsoft_teams.apps.activity_sender.ApiClient") as mock_api_client:
+            mock_api = MagicMock()
+            mock_api.conversations.activities.return_value = mock_activities
+            mock_api_client.return_value = mock_api
+
+            await sender.send(activity, conversation_ref)
+
+            mock_activities.create.assert_called_once_with(activity)
+            mock_activities.create_targeted.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_update_targeted_message_calls_update_targeted(self, sender, conversation_ref):
+        """Test that targeted message updates use the update_targeted method."""
+        activity = MessageActivityInput(text="Updated targeted message")
+        activity.recipient = Account(id="user-123", name="Test User", role="user", is_targeted=True)
+        activity.id = "existing-msg-id"
+
+        mock_activities = MagicMock()
+        mock_activities.update_targeted = AsyncMock(
+            return_value=self._create_sent_activity(activity, "existing-msg-id")
+        )
+
+        with patch("microsoft_teams.apps.activity_sender.ApiClient") as mock_api_client:
+            mock_api = MagicMock()
+            mock_api.conversations.activities.return_value = mock_activities
+            mock_api_client.return_value = mock_api
+
+            await sender.send(activity, conversation_ref)
+
+            mock_activities.update_targeted.assert_called_once_with("existing-msg-id", activity)
+            mock_activities.update.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_update_non_targeted_message_calls_update(self, sender, conversation_ref):
+        """Test that non-targeted message updates use the regular update method."""
+        activity = MessageActivityInput(text="Updated message")
+        activity.id = "existing-msg-id"
+
+        mock_activities = MagicMock()
+        mock_activities.update = AsyncMock(return_value=self._create_sent_activity(activity, "existing-msg-id"))
+
+        with patch("microsoft_teams.apps.activity_sender.ApiClient") as mock_api_client:
+            mock_api = MagicMock()
+            mock_api.conversations.activities.return_value = mock_activities
+            mock_api_client.return_value = mock_api
+
+            await sender.send(activity, conversation_ref)
+
+            mock_activities.update.assert_called_once_with("existing-msg-id", activity)
+            mock_activities.update_targeted.assert_not_called()
diff --git a/packages/apps/tests/test_app.py b/packages/apps/tests/test_app.py
index a27f4188..e1072918 100644
--- a/packages/apps/tests/test_app.py
+++ b/packages/apps/tests/test_app.py
@@ -5,7 +5,9 @@
 # pyright: basic
 
 import asyncio
+import importlib.metadata
 import os
+import re
 from typing import Optional
 from unittest.mock import AsyncMock, MagicMock, patch
 
@@ -17,11 +19,14 @@
     InvokeActivity,
     ManagedIdentityCredentials,
     MessageActivity,
+    MessageActivityInput,
+    SentActivity,
     TokenCredentials,
     TokenProtocol,
     TypingActivity,
 )
-from microsoft_teams.apps import ActivityContext, ActivityEvent, App, AppOptions
+from microsoft_teams.apps import ActivityContext, ActivityEvent, App, AppOptions, Plugin, PluginBase, PluginStartEvent
+from microsoft_teams.apps.events import CoreActivity
 
 
 class FakeToken(TokenProtocol):
@@ -65,11 +70,6 @@ def __str__(self) -> str:
 class TestApp:
     """Test cases for App class public interface."""
 
-    @pytest.fixture
-    def mock_logger(self):
-        """Create a mock logger."""
-        return MagicMock()
-
     @pytest.fixture
     def mock_storage(self):
         """Create a mock storage."""
@@ -85,35 +85,30 @@ async def handler(ctx) -> None:
         return handler
 
     @pytest.fixture(scope="function")
-    def basic_options(self, mock_logger, mock_storage):
+    def basic_options(self, mock_storage):
         """Create basic app options."""
         return AppOptions(
-            logger=mock_logger,
             storage=mock_storage,
             client_id="test-client-id",
             client_secret="test-secret",
         )
 
-    def _mock_http_plugin(self, app: App) -> App:
-        """Helper to mock the HTTP plugin's create_stream and close methods."""
-        mock_stream = MagicMock()
-        mock_stream.events = MagicMock()
-        mock_stream.events.on = MagicMock()
-        mock_stream.close = AsyncMock()
-        app.http.create_stream = MagicMock(return_value=mock_stream)
+    def _mock_http_server(self, app: App) -> App:
+        """Helper to mock the HTTP server methods."""
+        app.server.adapter.start = AsyncMock()  # type: ignore[method-assign]
+        app.server.adapter.stop = AsyncMock()  # type: ignore[method-assign]
         return app
 
     @pytest.fixture(scope="function")
     def app_with_options(self, basic_options):
         """Create App with basic options."""
         app = App(**basic_options)
-        return self._mock_http_plugin(app)
+        return self._mock_http_server(app)
 
     @pytest.fixture(scope="function")
-    def app_with_activity_handler(self, mock_logger, mock_storage, mock_activity_handler):
+    def app_with_activity_handler(self, mock_storage, mock_activity_handler):
         """Create App with activity handler."""
         options = AppOptions(
-            logger=mock_logger,
             storage=mock_storage,
             client_id="test-client-id",
             client_secret="test-secret",
@@ -121,51 +116,77 @@ def app_with_activity_handler(self, mock_logger, mock_storage, mock_activity_han
         )
         app = App(**options)
         app.on_activity(mock_activity_handler)
-        return self._mock_http_plugin(app)
+        return self._mock_http_server(app)
 
     def test_app_starts_successfully(self, basic_options):
         """Test that app can be created and initialized."""
         app = App(**basic_options)
 
-        # Basic functional test - app should be created and not running
-        assert not app.is_running
+        # Basic functional test - app should be created
         assert app.port is None
 
     @pytest.mark.asyncio
     async def test_app_lifecycle_start_stop(self, app_with_options):
         """Test basic app lifecycle: start and stop."""
 
-        # Mock the underlying HTTP server to avoid actual server startup
-        async def mock_on_start(event):
-            # Simulate the HTTP plugin calling the ready callback
-            if app_with_options.http.on_ready_callback:
-                await app_with_options.http.on_ready_callback()
-
-        with patch.object(app_with_options.http, "on_start", new_callable=AsyncMock, side_effect=mock_on_start):
-            # Test start
-            start_task = asyncio.create_task(app_with_options.start(3978))
-            await asyncio.sleep(0.1)
-
-            # App should be running and have correct port
-            assert app_with_options.is_running
-            assert app_with_options.port == 3978
-
-            start_task.cancel()
-            try:
-                await start_task
-            except asyncio.CancelledError:
-                pass
+        # Test start — server.adapter.start is already mocked by _mock_http_server
+        start_task = asyncio.create_task(app_with_options.start(3978))
+        await asyncio.sleep(0.1)
+
+        assert app_with_options.port == 3978
+
+        start_task.cancel()
+        try:
+            await start_task
+        except asyncio.CancelledError:
+            pass
 
         # Test stop
-        app_with_options._running = True
+        await app_with_options.stop()
+
+    @pytest.mark.asyncio
+    async def test_app_start_with_multiple_plugins_cancelled(self, mock_storage):
+        @Plugin(name="PluginTwo", version="1.0", description="plugin")
+        class PluginTwo(PluginBase):
+            def __init__(self):
+                super().__init__()
+                self.stop_called = False
+
+            async def on_start(self, event: PluginStartEvent) -> None:  # noqa: D102
+                pass
+
+            async def on_stop(self) -> None:  # noqa: D102
+                self.stop_called = True
+
+        plugin_two = PluginTwo()
+
+        options = AppOptions(
+            storage=mock_storage,
+            client_id="test-client-id",
+            client_secret="test-secret",
+            plugins=[plugin_two],
+        )
+        app = App(**options)
 
-        async def mock_on_stop():
-            if app_with_options.http.on_stopped_callback:
-                await app_with_options.http.on_stopped_callback()
+        # Mock server.start to block until cancelled
+        block = asyncio.Event()
 
-        with patch.object(app_with_options.http, "on_stop", new_callable=AsyncMock, side_effect=mock_on_stop):
-            await app_with_options.stop()
-            assert not app_with_options.is_running
+        async def blocking_start(port):
+            await block.wait()
+
+        app.server.adapter.start = AsyncMock(side_effect=blocking_start)  # type: ignore[method-assign]
+        app.server.adapter.stop = AsyncMock()  # type: ignore[method-assign]
+
+        start_task = asyncio.create_task(app.start(3978))
+        await asyncio.sleep(0.1)
+
+        start_task.cancel()
+        try:
+            await start_task
+        except asyncio.CancelledError:
+            pass
+
+        assert plugin_two.stop_called, "plugin two on_stop was called."
 
     # Event Testing - Focus on functional behavior
 
@@ -180,25 +201,12 @@ async def handle_activity(event: ActivityEvent) -> None:
             activity_events.append(event)
             event_received.set()
 
-        from_account = Account(id="bot-123", name="Test Bot", role="bot")
-        recipient = Account(id="user-456", name="Test User", role="user")
-        conversation = ConversationAccount(id="conv-789", conversation_type="personal")
-
-        activity = MessageActivity(
+        core_activity = CoreActivity(
             type="message",
             id="test-activity-id",
-            text="Hello, world!",
-            from_=from_account,
-            recipient=recipient,
-            conversation=conversation,
-            channel_id="msteams",
         )
 
-        plugin = app_with_activity_handler.http
-
-        await app_with_activity_handler.event_manager.on_activity(
-            ActivityEvent(activity=activity, sender=plugin, token=FakeToken())
-        )
+        await app_with_activity_handler.event_manager.on_activity(ActivityEvent(body=core_activity, token=FakeToken()))
 
         # Wait for the async event handler to complete
         await asyncio.wait_for(event_received.wait(), timeout=1.0)
@@ -206,12 +214,9 @@ async def handle_activity(event: ActivityEvent) -> None:
         # Verify event was emitted
         assert len(activity_events) == 1
         assert isinstance(activity_events[0], ActivityEvent)
-        # The event contains the parsed output model, not the input model
-        assert activity_events[0].activity.id == activity.id
-        assert activity_events[0].activity.type == activity.type
-        # Check text only if it's a MessageActivity
-        if hasattr(activity_events[0].activity, "text"):
-            assert activity_events[0].activity.text == activity.text
+        # The event contains the core activity
+        assert activity_events[0].body.id == core_activity.id
+        assert activity_events[0].body.type == core_activity.type
 
     @pytest.mark.asyncio
     async def test_multiple_event_handlers(self, app_with_options: App) -> None:
@@ -237,23 +242,12 @@ async def handle_activity_2(event: ActivityEvent) -> None:
             if received_count == 2:
                 both_received.set()
 
-        from_account = Account(id="bot-123", name="Test Bot", role="bot")
-        recipient = Account(id="user-456", name="Test User", role="user")
-        conversation = ConversationAccount(id="conv-789", conversation_type="personal")
-
-        activity = MessageActivity(
+        core_activity = CoreActivity(
             type="message",
             id="test-activity-id",
-            text="Hello, world!",
-            from_=from_account,
-            recipient=recipient,
-            conversation=conversation,
-            channel_id="msteams",
         )
 
-        await app_with_options.event_manager.on_activity(
-            ActivityEvent(activity=activity, sender=app_with_options.http, token=FakeToken())
-        )
+        await app_with_options.event_manager.on_activity(ActivityEvent(body=core_activity, token=FakeToken()))
 
         # Wait for both async event handlers to complete
         await asyncio.wait_for(both_received.wait(), timeout=1.0)
@@ -261,8 +255,8 @@ async def handle_activity_2(event: ActivityEvent) -> None:
         # Both handlers should have received the event
         assert len(activity_events_1) == 1
         assert len(activity_events_2) == 1
-        assert activity_events_1[0].activity == activity
-        assert activity_events_2[0].activity == activity
+        assert activity_events_1[0].body == core_activity
+        assert activity_events_2[0].body == core_activity
 
     # Generated Handler Tests
 
@@ -424,7 +418,6 @@ async def handle_hello(ctx: ActivityContext[MessageActivity]) -> None:
 
     def test_on_message_pattern_regex_match(self, app_with_options: App) -> None:
         """Test on_message_pattern with regex pattern matching."""
-        import re
 
         @app_with_options.on_message_pattern(re.compile(r"hello \w+"))
         async def handle_hello_pattern(ctx: ActivityContext[MessageActivity]) -> None:
@@ -519,9 +512,9 @@ async def logging_middleware(ctx: ActivityContext) -> None:
     @pytest.mark.asyncio
     async def test_func_decorator_registration(self, app_with_options: App):
         """Simple test that @app.func registers a function."""
-        app_with_options.http.post = MagicMock()
+        mock_register = MagicMock()
+        app_with_options.server.adapter.register_route = mock_register  # type: ignore[method-assign]
 
-        # Dummy request to simulate a call
         async def dummy_func(ctx):
             return "called"
 
@@ -529,13 +522,13 @@ async def dummy_func(ctx):
         assert decorated == dummy_func
 
         # Extract the endpoint path it was registered to
-        endpoint_path = app_with_options.http.post.call_args[0][0]
-        assert endpoint_path == f"/api/functions/{dummy_func.__name__.replace('_', '-')}"
+        mock_register.assert_called_once()
+        method, path, handler = mock_register.call_args[0]
+        assert method == "POST"
+        assert path == f"/api/functions/{dummy_func.__name__.replace('_', '-')}"
 
     def test_user_agent_format(self, app_with_options: App):
         """Test that USER_AGENT follows the expected format teams.py[apps]/{version}."""
-        import importlib.metadata
-
         version = importlib.metadata.version("microsoft-teams-apps")
         expected_user_agent = f"teams.py[apps]/{version}"
 
@@ -586,7 +579,6 @@ def test_user_agent_format(self, app_with_options: App):
     )
     def test_app_init_with_managed_identity(
         self,
-        mock_logger,
         mock_storage,
         options_dict: dict,
         env_vars: dict,
@@ -595,7 +587,7 @@ def test_app_init_with_managed_identity(
         description: str,
     ):
         """Test app initialization with managed identity credentials."""
-        options = AppOptions(logger=mock_logger, storage=mock_storage, **options_dict)
+        options = AppOptions(storage=mock_storage, **options_dict)
 
         with patch.dict("os.environ", env_vars, clear=False):
             app = App(**options)
@@ -621,7 +613,6 @@ def test_app_init_with_managed_identity(
     )
     def test_app_init_with_federated_identity(
         self,
-        mock_logger,
         mock_storage,
         managed_identity_client_id: str,
         expected_mi_type: str,
@@ -630,7 +621,6 @@ def test_app_init_with_federated_identity(
     ):
         """Test app initialization with FederatedIdentityCredentials."""
         options = AppOptions(
-            logger=mock_logger,
             storage=mock_storage,
             client_id="app-client-id",
             managed_identity_client_id=managed_identity_client_id,
@@ -646,11 +636,10 @@ def test_app_init_with_federated_identity(
             assert app.credentials.managed_identity_client_id == expected_mi_client_id, f"Failed for: {description}"
             assert app.credentials.tenant_id == "test-tenant-id", f"Failed for: {description}"
 
-    def test_app_init_with_client_secret_takes_precedence(self, mock_logger, mock_storage):
+    def test_app_init_with_client_secret_takes_precedence(self, mock_storage):
         """Test that ClientCredentials is used when both client_secret and managed_identity_client_id are provided."""
         # When client_secret is provided, it should take precedence over managed identity
         options = AppOptions(
-            logger=mock_logger,
             storage=mock_storage,
             client_id="test-client-id",
             client_secret="test-client-secret",
@@ -665,10 +654,9 @@ def test_app_init_with_client_secret_takes_precedence(self, mock_logger, mock_st
         assert type(app.credentials).__name__ == "ClientCredentials"
         assert app.credentials.client_id == "test-client-id"
 
-    def test_service_url_default(self, mock_logger, mock_storage):
+    def test_service_url_default(self, mock_storage):
         """Test that app uses default service URL when no configuration provided."""
         options = AppOptions(
-            logger=mock_logger,
             storage=mock_storage,
             client_id="test-client-id",
             client_secret="test-client-secret",
@@ -682,10 +670,9 @@ def test_service_url_default(self, mock_logger, mock_storage):
             app = App(**options)
             assert app.api.service_url == "https://smba.trafficmanager.net/teams"
 
-    def test_service_url_from_environment(self, mock_logger, mock_storage):
+    def test_service_url_from_environment(self, mock_storage):
         """Test that app uses service URL from environment variable."""
         options = AppOptions(
-            logger=mock_logger,
             storage=mock_storage,
             client_id="test-client-id",
             client_secret="test-client-secret",
@@ -695,10 +682,9 @@ def test_service_url_from_environment(self, mock_logger, mock_storage):
             app = App(**options)
             assert app.api.service_url == "https://custom.service.url/teams"
 
-    def test_service_url_from_options(self, mock_logger, mock_storage):
+    def test_service_url_from_options(self, mock_storage):
         """Test that app uses service URL from options when provided."""
         options = AppOptions(
-            logger=mock_logger,
             storage=mock_storage,
             client_id="test-client-id",
             client_secret="test-client-secret",
@@ -710,11 +696,10 @@ def test_service_url_from_options(self, mock_logger, mock_storage):
             # Options should take precedence over environment
             assert app.api.service_url == "https://options.service.url/teams"
 
-    def test_service_url_priority(self, mock_logger, mock_storage):
+    def test_service_url_priority(self, mock_storage):
         """Test that service URL prioritizes options > env > default."""
         # Test 1: Default when neither option nor env provided
         options1 = AppOptions(
-            logger=mock_logger,
             storage=mock_storage,
             client_id="test-client-id",
             client_secret="test-client-secret",
@@ -728,7 +713,6 @@ def test_service_url_priority(self, mock_logger, mock_storage):
 
         # Test 2: Environment when provided but option not set
         options2 = AppOptions(
-            logger=mock_logger,
             storage=mock_storage,
             client_id="test-client-id",
             client_secret="test-client-secret",
@@ -740,7 +724,6 @@ def test_service_url_priority(self, mock_logger, mock_storage):
 
         # Test 3: Options when both option and env provided
         options3 = AppOptions(
-            logger=mock_logger,
             storage=mock_storage,
             client_id="test-client-id",
             client_secret="test-client-secret",
@@ -754,51 +737,19 @@ def test_service_url_priority(self, mock_logger, mock_storage):
     # Tests for App.send() proactive targeted message validation
 
     @pytest.mark.asyncio
-    async def test_proactive_targeted_without_recipient_raises_error(self, mock_logger, mock_storage) -> None:
-        """
-        Test that sending a targeted message proactively without an explicit
-        recipient raises a ValueError.
-        """
-        from microsoft_teams.api import MessageActivityInput, SentActivity
-
-        options = AppOptions(
-            logger=mock_logger,
-            storage=mock_storage,
-            client_id="test-client-id",
-            client_secret="test-secret",
-        )
-        app = App(**options)
-        app._running = True
-        app.http.send = AsyncMock(
-            return_value=SentActivity(id="sent-activity-id", activity_params=MessageActivityInput(text="sent"))
-        )
-
-        # Create a targeted message without explicit recipient
-        activity = MessageActivityInput(text="Hello")
-        activity.is_targeted = True  # Set is_targeted without recipient
-
-        with pytest.raises(
-            ValueError, match="Targeted messages sent proactively must specify an explicit recipient account"
-        ):
-            await app.send("conv-123", activity)
-
-    @pytest.mark.asyncio
-    async def test_proactive_targeted_with_explicit_recipient_succeeds(self, mock_logger, mock_storage) -> None:
+    async def test_proactive_targeted_with_explicit_recipient_succeeds(self, mock_storage) -> None:
         """
         Test that sending a targeted message proactively with an explicit
         recipient account succeeds.
         """
-        from microsoft_teams.api import Account, MessageActivityInput, SentActivity
-
         options = AppOptions(
-            logger=mock_logger,
             storage=mock_storage,
             client_id="test-client-id",
             client_secret="test-secret",
         )
         app = App(**options)
-        app._running = True
-        app.http.send = AsyncMock(
+        app._initialized = True
+        app.activity_sender.send = AsyncMock(
             return_value=SentActivity(id="sent-activity-id", activity_params=MessageActivityInput(text="sent"))
         )
 
@@ -809,5 +760,5 @@ async def test_proactive_targeted_with_explicit_recipient_succeeds(self, mock_lo
         # Should not raise - explicit recipient provided
         result = await app.send("conv-123", activity)
 
-        app.http.send.assert_called_once()
+        app.activity_sender.send.assert_called_once()
         assert result.id == "sent-activity-id"
diff --git a/packages/apps/tests/test_app_events.py b/packages/apps/tests/test_app_events.py
index 7b5ea232..5beafb3d 100644
--- a/packages/apps/tests/test_app_events.py
+++ b/packages/apps/tests/test_app_events.py
@@ -4,19 +4,20 @@
 """
 # pyright: basic
 
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
-from microsoft_teams.api import Activity, ConversationReference, TokenProtocol
+from microsoft_teams.api import Activity, ConversationReference, SentActivity, TokenProtocol
 from microsoft_teams.apps import (
     ActivityEvent,
     ActivityResponseEvent,
     ActivitySentEvent,
     ErrorEvent,
-    HttpPlugin,
-    Sender,
+    PluginBase,
 )
 from microsoft_teams.apps.app_events import EventManager
+from microsoft_teams.apps.events import CoreActivity
+from microsoft_teams.apps.events.registry import get_event_name_from_type, get_event_type_from_signature
 from microsoft_teams.common import EventEmitter
 
 
@@ -35,12 +36,12 @@ def event_manager(self, mock_event_emitter):
 
     @pytest.fixture
     def mock_plugins(self):
-        plugin = MagicMock(spec=HttpPlugin)
+        plugin = MagicMock(spec=PluginBase)
         plugin.on_error_event = AsyncMock()
         plugin.on_error = AsyncMock()
         plugin.on_activity_sent = AsyncMock()
         plugin.on_activity_response = AsyncMock()
-        plugin_two = MagicMock(spec=HttpPlugin)
+        plugin_two = MagicMock(spec=PluginBase)
         return [plugin, plugin_two]
 
     @pytest.mark.asyncio
@@ -57,9 +58,7 @@ async def test_on_error(self, event_manager, mock_event_emitter, mock_plugins):
     @pytest.mark.asyncio
     async def test_on_activity(self, event_manager, mock_event_emitter):
         """Test the on_activity method."""
-        activity_event = ActivityEvent(
-            sender=Sender(), activity=MagicMock(spec=Activity), token=MagicMock(spec=TokenProtocol)
-        )
+        activity_event = ActivityEvent(body=CoreActivity(), token=MagicMock(spec=TokenProtocol))
 
         await event_manager.on_activity(activity_event)
 
@@ -68,33 +67,133 @@ async def test_on_activity(self, event_manager, mock_event_emitter):
     @pytest.mark.asyncio
     async def test_on_activity_sent(self, event_manager, mock_event_emitter, mock_plugins):
         """Test the on_activity_sent method."""
-        sender = Sender()
         activity_sent_event = ActivitySentEvent(
-            sender=sender, activity=MagicMock(spec=Activity), conversation_ref=MagicMock(spec=ConversationReference)
+            activity=MagicMock(spec=SentActivity), conversation_ref=MagicMock(spec=ConversationReference)
         )
 
-        await event_manager.on_activity_sent(sender, activity_sent_event, mock_plugins)
+        await event_manager.on_activity_sent(activity_sent_event, mock_plugins)
 
         for plugin in mock_plugins:
             if callable(plugin.on_activity_sent):
                 plugin.on_activity_sent.assert_called()
-        mock_event_emitter.emit.assert_called_once_with(
-            "activity_sent", {"event": activity_sent_event, "sender": sender}
-        )
+        mock_event_emitter.emit.assert_called_once_with("activity_sent", activity_sent_event)
 
     @pytest.mark.asyncio
     async def test_on_activity_response(self, event_manager, mock_event_emitter, mock_plugins):
         """Test the on_activity_response method."""
-        sender = Sender()
         activity_response_event = ActivityResponseEvent(
             activity=MagicMock(spec=Activity), response=MagicMock(), conversation_ref=MagicMock()
         )
 
-        await event_manager.on_activity_response(sender, activity_response_event, mock_plugins)
+        await event_manager.on_activity_response(activity_response_event, mock_plugins)
 
         for plugin in mock_plugins:
             if callable(plugin.on_activity_response):
                 plugin.on_activity_response.assert_called()
-        mock_event_emitter.emit.assert_called_once_with(
-            "activity_response", {"event": activity_response_event, "sender": sender}
-        )
+        mock_event_emitter.emit.assert_called_once_with("activity_response", activity_response_event)
+
+
+class TestGetEventNameFromType:
+    """Test cases for the get_event_name_from_type function."""
+
+    def test_registered_class_returns_event_name(self):
+        """Test that a registered event class returns the correct event name."""
+        assert get_event_name_from_type(ActivityEvent) == "activity"
+        assert get_event_name_from_type(ErrorEvent) == "error"
+        assert get_event_name_from_type(ActivityResponseEvent) == "activity_response"
+        assert get_event_name_from_type(ActivitySentEvent) == "activity_sent"
+
+    def test_unregistered_class_raises_value_error(self):
+        """Test that an unregistered class raises ValueError."""
+
+        class UnregisteredEvent:
+            pass
+
+        with pytest.raises(ValueError, match="UnregisteredEvent"):
+            get_event_name_from_type(UnregisteredEvent)
+
+
+class TestGetEventTypeFromSignature:
+    """Test cases for the get_event_type_from_signature function."""
+
+    def test_function_with_no_parameters_returns_none(self):
+        """Test that a function with no parameters returns None."""
+
+        def no_params():
+            pass
+
+        result = get_event_type_from_signature(no_params)
+        assert result is None
+
+    def test_function_with_no_annotation_returns_none(self):
+        """Test that a function where the first param has no annotation returns None."""
+
+        def no_annotation(event):
+            pass
+
+        result = get_event_type_from_signature(no_annotation)
+        assert result is None
+
+    def test_function_with_registered_type_returns_event_name(self):
+        """Test that a function typed with a registered event class returns the event name."""
+
+        def handler(event: ActivityEvent):
+            pass
+
+        result = get_event_type_from_signature(handler)
+        assert result == "activity"
+
+    def test_function_with_string_annotation_matching_event_name(self):
+        """Test that a string annotation matching a registered event name returns it."""
+
+        # Build a function whose annotation is already a bare string equal to an event name.
+        # We create the parameter manually to guarantee a string annotation.
+        def handler(event):
+            pass
+
+        # Patch the annotation directly so it is the string "activity"
+        handler.__annotations__["event"] = "activity"
+
+        result = get_event_type_from_signature(handler)
+        assert result == "activity"
+
+    def test_function_with_string_annotation_matching_class_name(self):
+        """Test that a string annotation matching a registered class name resolves correctly."""
+
+        def handler(event):
+            pass
+
+        # "ActivityEvent" is the class name — triggers the class-name fallback path
+        handler.__annotations__["event"] = "ActivityEvent"
+
+        result = get_event_type_from_signature(handler)
+        assert result == "activity"
+
+    def test_function_with_unregistered_string_annotation_returns_none(self):
+        """Test that a string annotation that doesn't match anything returns None."""
+
+        def handler(event):
+            pass
+
+        handler.__annotations__["event"] = "UnknownEventType"
+
+        result = get_event_type_from_signature(handler)
+        assert result is None
+
+    def test_function_with_unregistered_type_returns_none(self):
+        """Test that a function typed with an unregistered type returns None."""
+
+        class SomeRandomClass:
+            pass
+
+        def handler(event: SomeRandomClass):
+            pass
+
+        result = get_event_type_from_signature(handler)
+        assert result is None
+
+    def test_function_raising_type_error_returns_none(self):
+        """Test that when inspect.signature raises TypeError, get_event_type_from_signature returns None."""
+        with patch("inspect.signature", side_effect=TypeError):
+            result = get_event_type_from_signature(lambda x: x)
+        assert result is None
diff --git a/packages/apps/tests/test_app_oauth.py b/packages/apps/tests/test_app_oauth.py
index 62ef79e5..2cabb44b 100644
--- a/packages/apps/tests/test_app_oauth.py
+++ b/packages/apps/tests/test_app_oauth.py
@@ -25,9 +25,12 @@
     TokenResponse,
 )
 from microsoft_teams.apps.app_oauth import OauthHandlers
+from microsoft_teams.apps.app_process import ActivityProcessor
 from microsoft_teams.apps.events import ErrorEvent, SignInEvent
 from microsoft_teams.apps.routing import ActivityContext
-from microsoft_teams.common import EventEmitter
+from microsoft_teams.apps.routing.activity_route_configs import ACTIVITY_ROUTES
+from microsoft_teams.apps.routing.router import ActivityRouter
+from microsoft_teams.common import EventEmitter, LocalStorage
 
 # pyright: basic
 
@@ -137,18 +140,15 @@ async def test_sign_in_token_exchange_success(
     async def test_sign_in_token_exchange_connection_name_warning(
         self, oauth_handlers, mock_context, token_exchange_activity, mock_token_response
     ):
-        """Test token exchange with different connection name logs warning."""
+        """Test token exchange with different connection name."""
         token_exchange_activity.value.connection_name = "different-connection"
         mock_context.activity = token_exchange_activity
         mock_context.api.users.token.exchange.return_value = mock_token_response
 
         await oauth_handlers.sign_in_token_exchange(mock_context)
 
-        # Verify warning was logged
-        mock_context.logger.warning.assert_called_once()
-        warning_msg = mock_context.logger.warning.call_args[0][0]
-        assert "different-connection" in warning_msg
-        assert "test-connection" in warning_msg
+        # Exchange still succeeds despite connection name mismatch
+        mock_context.api.users.token.exchange.assert_called_once()
 
     @pytest.mark.asyncio
     async def test_sign_in_token_exchange_http_error_404(self, oauth_handlers, mock_context, token_exchange_activity):
@@ -194,9 +194,6 @@ async def test_sign_in_token_exchange_http_error_500(self, oauth_handlers, mock_
             "error", ErrorEvent(error=http_error, context={"activity": token_exchange_activity})
         )
 
-        # Verify error logged
-        mock_context.logger.error.assert_called_once()
-
         # Verify error response
         assert isinstance(result, InvokeResponse)
         assert result.status == 500
@@ -246,9 +243,6 @@ async def test_sign_in_verify_state_success(
             "sign_in", SignInEvent(activity_ctx=mock_context, token_response=mock_token_response)
         )
 
-        # Verify debug logs
-        assert mock_context.logger.debug.call_count == 2
-
         # Verify response
         assert result is None
 
@@ -263,11 +257,6 @@ async def test_sign_in_verify_state_no_state(self, oauth_handlers, mock_context,
 
         result = await oauth_handlers.sign_in_verify_state(mock_context)
 
-        # Verify warning logged
-        mock_context.logger.warning.assert_called_once()
-        warning_msg = mock_context.logger.warning.call_args[0][0]
-        assert "Auth state not present" in warning_msg
-
         # Verify no API call
         mock_context.api.users.token.get.assert_not_called()
 
@@ -298,9 +287,6 @@ async def test_sign_in_verify_state_http_error_500(self, oauth_handlers, mock_co
             "error", ErrorEvent(error=http_error, context={"activity": verify_state_activity})
         )
 
-        # Verify error logged
-        mock_context.logger.error.assert_called_once()
-
         # Verify error response
         assert isinstance(result, InvokeResponse) and result.body is None
         assert result.status == 500
@@ -320,9 +306,6 @@ async def test_sign_in_verify_state_http_error_404(self, oauth_handlers, mock_co
 
         result = await oauth_handlers.sign_in_verify_state(mock_context)
 
-        # Verify error logged
-        mock_context.logger.error.assert_called_once()
-
         # Verify 412 response
         assert isinstance(result, InvokeResponse) and result.body is None
         assert result.status == 412
@@ -336,9 +319,6 @@ async def test_sign_in_verify_state_generic_exception(self, oauth_handlers, mock
 
         result = await oauth_handlers.sign_in_verify_state(mock_context)
 
-        # Verify error logged
-        mock_context.logger.error.assert_called_once()
-
         # Verify 412 response
         assert isinstance(result, InvokeResponse) and result.body is None
         assert result.status == 412
@@ -452,25 +432,20 @@ def failure_activity(self):
     @pytest.fixture
     def router(self):
         """Create a real ActivityRouter."""
-        from microsoft_teams.apps.routing.router import ActivityRouter
-
         return ActivityRouter()
 
     @pytest.fixture
     def processor(self, router):
         """Create an ActivityProcessor for middleware chain execution."""
-        from microsoft_teams.apps.app_process import ActivityProcessor
-        from microsoft_teams.common import LocalStorage
-
         return ActivityProcessor(
             router=router,
-            logger=MagicMock(),
             id="bot-456",
             storage=LocalStorage(),
             default_connection_name="graph",
             http_client=MagicMock(),
             token_manager=MagicMock(),
             api_client_settings=None,
+            activity_sender=MagicMock(),
         )
 
     @staticmethod
@@ -479,22 +454,19 @@ def _make_ctx(activity):
         return ActivityContext(
             activity=activity,
             app_id="bot-456",
-            logger=MagicMock(),
             storage=MagicMock(),
             api=MagicMock(),
             user_token=None,
             conversation_ref=MagicMock(),
             is_signed_in=False,
             connection_name="graph",
-            sender=MagicMock(),
+            activity_sender=MagicMock(),
             app_token=MagicMock(),
         )
 
     @pytest.mark.asyncio
     async def test_system_default_handler_fires_alone(self, router, processor, failure_activity):
         """System default fires when no developer handler is registered."""
-        from microsoft_teams.apps.routing.activity_route_configs import ACTIVITY_ROUTES
-
         called = []
 
         async def system_handler(ctx):
@@ -515,8 +487,6 @@ async def system_handler(ctx):
     @pytest.mark.asyncio
     async def test_developer_handler_fires_with_system_handler(self, router, processor, failure_activity):
         """Developer on_signin_failure handler fires alongside the system default."""
-        from microsoft_teams.apps.routing.activity_route_configs import ACTIVITY_ROUTES
-
         called = []
 
         async def system_handler(ctx):
@@ -542,8 +512,6 @@ async def developer_handler(ctx):
     @pytest.mark.asyncio
     async def test_catchall_on_invoke_without_next_blocks_developer_handler(self, router, processor, failure_activity):
         """A catch-all on_invoke that omits ctx.next() blocks later handlers."""
-        from microsoft_teams.apps.routing.activity_route_configs import ACTIVITY_ROUTES
-
         called = []
 
         async def system_handler(ctx):
@@ -575,8 +543,6 @@ async def developer_handler(ctx):
     @pytest.mark.asyncio
     async def test_catchall_on_invoke_with_next_allows_developer_handler(self, router, processor, failure_activity):
         """A catch-all on_invoke that calls ctx.next() allows later handlers to fire."""
-        from microsoft_teams.apps.routing.activity_route_configs import ACTIVITY_ROUTES
-
         called = []
 
         async def system_handler(ctx):
@@ -608,8 +574,6 @@ async def developer_handler(ctx):
     @pytest.mark.asyncio
     async def test_developer_handler_return_value_does_not_override_system(self, router, processor, failure_activity):
         """The first handler's return value wins (system handler returns first on unwind)."""
-        from microsoft_teams.apps.routing.activity_route_configs import ACTIVITY_ROUTES
-
         config = ACTIVITY_ROUTES["signin.failure"]
 
         async def system_handler(ctx):
diff --git a/packages/apps/tests/test_app_plugins.py b/packages/apps/tests/test_app_plugins.py
index 5fc33123..2ac9b951 100644
--- a/packages/apps/tests/test_app_plugins.py
+++ b/packages/apps/tests/test_app_plugins.py
@@ -4,7 +4,6 @@
 """
 # pyright: basic
 
-from logging import Logger
 from typing import Annotated, Callable
 from unittest.mock import AsyncMock, MagicMock
 
@@ -15,7 +14,6 @@
     DependencyMetadata,
     ErrorEvent,
     EventMetadata,
-    LoggerDependencyOptions,
     Plugin,
     PluginBase,
 )
@@ -31,10 +29,6 @@
 class TestPluginProcessor:
     """Test cases for PluginProcessor class."""
 
-    @pytest.fixture
-    def mock_logger(self):
-        return MagicMock(spec=Logger)
-
     @pytest.fixture
     def container(self):
         return Container()
@@ -56,13 +50,12 @@ def mock_activity_processor(self):
         return MagicMock(spec=ActivityProcessor)
 
     @pytest.fixture
-    def plugin_processor(self, container, mock_event_emitter, mock_logger, mock_event_manager, mock_activity_processor):
+    def plugin_processor(self, container, mock_event_emitter, mock_event_manager, mock_activity_processor):
         """Create a PluginProcessor instance."""
         return PluginProcessor(
             container=container,
             event_manager=mock_event_manager,
             event_emitter=mock_event_emitter,
-            logger=mock_logger,
             activity_processor=mock_activity_processor,
         )
 
@@ -72,7 +65,6 @@ def mock_plugin(self):
 
         @Plugin(name="MockPlugin", version="1.0", description="A mock plugin for testing")
         class MockPlugin(PluginBase):
-            logger: Annotated[Logger, LoggerDependencyOptions()]
             on_error_event: Annotated[Callable[[ErrorEvent], None], EventMetadata(name="error")]
             client: Annotated[Client, DependencyMetadata()]
             on_activity_event: Annotated[Callable[[ActivityEvent], InvokeResponse[Any]], EventMetadata(name="activity")]
@@ -114,10 +106,9 @@ async def test_get_plugin(self, plugin_processor, mock_plugin):
         assert plugin_none is None
 
     @pytest.mark.asyncio
-    async def test_inject(self, plugin_processor, mock_plugin, mock_logger, mock_client):
+    async def test_inject(self, plugin_processor, mock_plugin, mock_client):
         """Test the inject method."""
 
-        plugin_processor.container.set_provider("logger", mock_logger)
         plugin_processor.container.set_provider("client", mock_client)
 
         invoke_response = InvokeResponse[Any](status=200, body=None)
@@ -128,7 +119,6 @@ async def test_inject(self, plugin_processor, mock_plugin, mock_logger, mock_cli
 
         result = await mock_plugin.on_activity_event(MagicMock(spec=PluginActivityEvent))
 
-        assert mock_plugin.logger._extract_mock_name() == "mock().getChild()"
         assert hasattr(mock_plugin, "on_error_event")
         assert mock_plugin.client._extract_mock_name() == "mock()"
 
diff --git a/packages/apps/tests/test_app_process.py b/packages/apps/tests/test_app_process.py
index eab61cb8..ad2534ae 100644
--- a/packages/apps/tests/test_app_process.py
+++ b/packages/apps/tests/test_app_process.py
@@ -9,18 +9,17 @@
 
 import pytest
 from microsoft_teams.api import (
-    Account,
     Activity,
     ActivityBase,
-    ConversationAccount,
     ConversationReference,
     InvokeResponse,
-    MessageActivity,
     TokenProtocol,
 )
-from microsoft_teams.apps import ActivityContext, ActivityEvent, Sender
+from microsoft_teams.apps import ActivityContext, ActivityEvent
+from microsoft_teams.apps.activity_sender import ActivitySender
 from microsoft_teams.apps.app_events import EventManager
 from microsoft_teams.apps.app_process import ActivityProcessor
+from microsoft_teams.apps.events import CoreActivity
 from microsoft_teams.apps.routing.router import ActivityHandler, ActivityRouter
 from microsoft_teams.apps.token_manager import TokenManager
 from microsoft_teams.common import Client, LocalStorage
@@ -38,20 +37,25 @@ def mock_http_client(self):
         return http_client
 
     @pytest.fixture
-    def activity_processor(self, mock_logger, mock_http_client):
+    def activity_processor(self, mock_http_client):
         """Create an ActivityProcessor instance."""
         mock_storage = MagicMock(spec=LocalStorage)
         mock_activity_router = MagicMock(spec=ActivityRouter)
         mock_token_manager = MagicMock(spec=TokenManager)
+        mock_activity_sender = MagicMock(spec=ActivitySender)
+        # Mock the stream object with async close
+        mock_stream = MagicMock()
+        mock_stream.close = AsyncMock()
+        mock_activity_sender.create_stream.return_value = mock_stream
         return ActivityProcessor(
             mock_activity_router,
-            mock_logger,
             "id",
             mock_storage,
             "default_connection",
             mock_http_client,
             mock_token_manager,
             None,
+            mock_activity_sender,
         )
 
     @pytest.mark.asyncio
@@ -64,20 +68,21 @@ async def test_execute_middleware_chain_with_no_handlers(self, activity_processo
         assert response is None
 
     @pytest.mark.asyncio
-    async def test_execute_middleware_chain_with_two_handlers(self, activity_processor, mock_http_client, mock_logger):
+    async def test_execute_middleware_chain_with_two_handlers(self, activity_processor, mock_http_client):
         """Test the execute_middleware_chain method with two handlers."""
+        mock_activity_sender = MagicMock(spec=ActivitySender)
+        mock_activity_sender.create_stream.return_value = MagicMock()
         context = ActivityContext(
             activity=MagicMock(spec=ActivityBase),
             app_id="app_id",
-            logger=mock_logger,
             storage=MagicMock(spec=LocalStorage),
             api=mock_http_client,
             user_token=None,
             conversation_ref=MagicMock(spec=ConversationReference),
             is_signed_in=True,
             connection_name="default_connection",
-            sender=MagicMock(spec=Sender),
-            app_token=None,
+            activity_sender=mock_activity_sender,
+            app_token=lambda: None,
         )
 
         handler_one = AsyncMock(spec=ActivityHandler)
@@ -118,35 +123,32 @@ async def test_process_activity_middleware_results(self, activity_processor, mid
         """Test process_activity with different middleware return values."""
         # Setup mocks
         mock_plugins = []
-        mock_sender = MagicMock()
-        stream = MagicMock()
-        stream.close = AsyncMock()
-        mock_sender.create_stream.return_value = stream
-
-        # Create real activity and event
-        mock_account = Account(id="user-123", name="Test User")
-        mock_conversation = ConversationAccount(id="conv-789")
-        mock_bot = Account(id="bot-456", name="Test Bot")
-        activity = MessageActivity(
+
+        # Create core activity with required fields for MessageActivity
+        core_activity = CoreActivity(
             type="message",
-            text="Test message",
-            from_=mock_account,
-            conversation=mock_conversation,
-            recipient=mock_bot,
             id="activity-123",
             service_url="https://service.url",
+            **{
+                "from": {"id": "user-123", "name": "Test User"},
+                "conversation": {"id": "conv-789"},
+                "recipient": {"id": "bot-456", "name": "Test Bot"},
+                "channelId": "msteams",
+            },
         )
         mock_token = MagicMock(spec=TokenProtocol)
-        mock_activity_event = ActivityEvent(activity=activity, sender=mock_sender, token=mock_token)
+        mock_token.service_url = "https://service.url"
+        mock_activity_event = ActivityEvent(body=core_activity, token=mock_token)
 
         # Setup processor mocks
         activity_processor.router.select_handlers = MagicMock(return_value=[])
         activity_processor.execute_middleware_chain = AsyncMock(return_value=middleware_result)
         activity_processor.event_manager = MagicMock()
         activity_processor.event_manager.on_activity_response = AsyncMock()
+        activity_processor.event_manager.on_error = AsyncMock()
 
         # Act
-        result = await activity_processor.process_activity(mock_plugins, mock_sender, mock_activity_event)
+        result = await activity_processor.process_activity(mock_plugins, mock_activity_event)
 
         # Assert
         assert result.status == expected_result.status
@@ -157,26 +159,22 @@ async def test_process_activity_raises_exception(self, activity_processor):
         """Test process_activity raises exception when middleware chain fails."""
         # Setup mocks
         mock_plugins = []
-        mock_sender = MagicMock()
-        stream = MagicMock()
-        stream.close = AsyncMock()
-        mock_sender.create_stream.return_value = stream
-
-        # Create real activity and event
-        mock_account = Account(id="user-123", name="Test User")
-        mock_conversation = ConversationAccount(id="conv-789")
-        mock_bot = Account(id="bot-456", name="Test Bot")
-        activity = MessageActivity(
+
+        # Create core activity with required fields for MessageActivity
+        core_activity = CoreActivity(
             type="message",
-            text="Test message",
-            from_=mock_account,
-            conversation=mock_conversation,
-            recipient=mock_bot,
             id="activity-123",
             service_url="https://service.url",
+            **{
+                "from": {"id": "user-123", "name": "Test User"},
+                "conversation": {"id": "conv-789"},
+                "recipient": {"id": "bot-456", "name": "Test Bot"},
+                "channelId": "msteams",
+            },
         )
         mock_token = MagicMock(spec=TokenProtocol)
-        mock_activity_event = ActivityEvent(activity=activity, sender=mock_sender, token=mock_token)
+        mock_token.service_url = "https://service.url"
+        mock_activity_event = ActivityEvent(body=core_activity, token=mock_token)
 
         # Setup processor mocks
         activity_processor.router.select_handlers = MagicMock(return_value=[])
@@ -188,7 +186,7 @@ async def test_process_activity_raises_exception(self, activity_processor):
 
         # Act & Assert - expect exception to be raised
         with pytest.raises(Exception, match="Test exception"):
-            await activity_processor.process_activity(mock_plugins, mock_sender, mock_activity_event)
+            await activity_processor.process_activity(mock_plugins, mock_activity_event)
 
         # Assert error event was called
         assert activity_processor.event_manager.on_error.called
diff --git a/packages/apps/tests/test_function_context.py b/packages/apps/tests/test_function_context.py
index 93ed9bd9..8b67d3ce 100644
--- a/packages/apps/tests/test_function_context.py
+++ b/packages/apps/tests/test_function_context.py
@@ -44,13 +44,12 @@ def mock_logger(self):
         return MagicMock()
 
     @pytest.fixture
-    def function_context(self, mock_api: ApiClient, mock_http: Any, mock_logger: Any) -> FunctionContext[Any]:
+    def function_context(self, mock_api: ApiClient, mock_http: Any) -> FunctionContext[Any]:
         ctx: FunctionContext[Any] = FunctionContext(
             id="bot-123",
             name="Test Bot",
             api=mock_api,
-            http=mock_http,
-            log=mock_logger,
+            activity_sender=mock_http,
             data={"some": "payload"},
             app_session_id="dummy-session",
             tenant_id="tenant-789",
diff --git a/packages/apps/tests/test_http_plugin.py b/packages/apps/tests/test_http_plugin.py
deleted file mode 100644
index 1371587f..00000000
--- a/packages/apps/tests/test_http_plugin.py
+++ /dev/null
@@ -1,365 +0,0 @@
-"""
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the MIT License.
-"""
-# pyright: basic
-
-from typing import cast
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-from fastapi import Request, Response
-from microsoft_teams.api import (
-    Account,
-    ConfigResponse,
-    ConversationAccount,
-    ConversationReference,
-    InvokeResponse,
-    MessageActivity,
-    MessageActivityInput,
-)
-from microsoft_teams.apps import HttpPlugin, PluginActivityResponseEvent, PluginErrorEvent, PluginStartEvent
-from microsoft_teams.apps.events import ActivityEvent
-
-
-class TestHttpPlugin:
-    """Test cases for HttpPlugin public interface."""
-
-    @pytest.fixture
-    def mock_logger(self):
-        """Create a mock logger."""
-        return MagicMock()
-
-    @pytest.fixture
-    def plugin_with_validator(self, mock_logger):
-        """Create HttpPlugin with token validator."""
-        return HttpPlugin(logger=mock_logger)
-
-    @pytest.fixture
-    def plugin_without_validator(self, mock_logger):
-        """Create HttpPlugin without token validator."""
-        return HttpPlugin(logger=mock_logger)
-
-    def test_init_with_default_logger(self):
-        """Test HttpPlugin initialization with default logger."""
-        plugin = HttpPlugin()
-
-        assert plugin.logger is not None
-
-    def test_fastapi_methods_exposed(self, plugin_with_validator):
-        """Test that FastAPI methods are properly exposed."""
-        assert hasattr(plugin_with_validator, "get")
-        assert hasattr(plugin_with_validator, "post")
-        assert hasattr(plugin_with_validator, "put")
-        assert hasattr(plugin_with_validator, "patch")
-        assert hasattr(plugin_with_validator, "delete")
-        assert hasattr(plugin_with_validator, "middleware")
-
-        # These should be bound to the FastAPI app methods
-        assert plugin_with_validator.get == plugin_with_validator.app.get
-        assert plugin_with_validator.post == plugin_with_validator.app.post
-
-    @pytest.mark.asyncio
-    async def test_on_activity_response(self, plugin_without_validator, mock_account, mock_logger):
-        """Test successful activity response completion."""
-        mock_activity = cast(
-            MessageActivity,
-            MessageActivityInput(type="message", text="Mock activity text", from_=mock_account, id="test-id"),
-        )
-
-        mock_reference = ConversationReference(
-            bot=Account(id="1", name="test-bot", role="bot"),
-            conversation=ConversationAccount(id="conv-789", conversation_type="personal"),
-            channel_id="msteams",
-            service_url="https://test.service.url",
-        )
-
-        response_data = InvokeResponse(body=cast(ConfigResponse, {"status": "success"}), status=200)
-        await plugin_without_validator.on_activity_response(
-            PluginActivityResponseEvent(
-                sender=plugin_without_validator,
-                activity=mock_activity,
-                response=response_data,
-                conversation_ref=mock_reference,
-            )
-        )
-
-        mock_logger.debug.assert_called_once()
-        mock_logger.debug.assert_called_with(f"Completing activity response for {mock_activity.id}")
-
-    @pytest.mark.asyncio
-    async def test_on_error(self, plugin_with_validator, mock_account, mock_logger):
-        """Test error handling with activity ID."""
-        mock_activity = cast(
-            MessageActivity,
-            MessageActivityInput(type="message", text="Mock activity text", from_=mock_account, id="test-id"),
-        )
-
-        error = ValueError("Test error")
-        await plugin_with_validator.on_error(
-            PluginErrorEvent(sender=plugin_with_validator, activity=mock_activity, error=error)
-        )
-
-    @pytest.mark.asyncio
-    async def test_on_start_success(self, plugin_with_validator):
-        """Test successful server startup."""
-        mock_server = MagicMock()
-        mock_server.serve = AsyncMock()
-
-        with (
-            patch("uvicorn.Config") as mock_config,
-            patch("uvicorn.Server", return_value=mock_server) as mock_server_class,
-        ):
-            mock_config.return_value = MagicMock()
-
-            # Mock the serve method to not actually start server
-            mock_server.serve.return_value = None
-            event = PluginStartEvent(port=3978)
-            await plugin_with_validator.on_start(event)
-
-            # Verify server was configured and started
-            mock_config.assert_called_once()
-            mock_server_class.assert_called_once()
-            mock_server.serve.assert_called_once()
-
-            assert plugin_with_validator._port == 3978
-            assert plugin_with_validator._server == mock_server
-
-    @pytest.mark.asyncio
-    async def test_on_start_port_in_use(self, plugin_with_validator):
-        """Test server startup when port is in use."""
-        with patch("uvicorn.Server") as mock_server_class:
-            mock_server = MagicMock()
-            mock_server.serve = AsyncMock(side_effect=OSError("Port already in use"))
-            mock_server_class.return_value = mock_server
-
-            with pytest.raises(OSError, match="Port already in use"):
-                event = PluginStartEvent(port=3978)
-                await plugin_with_validator.on_start(event)
-
-    @pytest.mark.asyncio
-    async def test_on_stop(self, plugin_with_validator):
-        """Test server shutdown."""
-        # Set up a mock server
-        mock_server = MagicMock()
-        plugin_with_validator._server = mock_server
-
-        await plugin_with_validator.on_stop()
-
-        assert mock_server.should_exit is True
-
-    @pytest.mark.asyncio
-    async def test_on_stop_no_server(self, plugin_with_validator):
-        """Test server shutdown when no server is running."""
-        plugin_with_validator._server = None
-
-        # Should not raise exception
-        await plugin_with_validator.on_stop()
-
-    def test_activity_handler_assignment(self, plugin_with_validator):
-        """Test activity handler assignment and retrieval."""
-
-        async def new_handler(activity):
-            return {"custom": "response"}
-
-        plugin_with_validator.activity_handler = new_handler
-        assert plugin_with_validator.activity_handler == new_handler
-
-    def test_middleware_setup(self, plugin_with_validator, plugin_without_validator):
-        """Test that JWT middleware is properly configured."""
-        # With app_id, middleware should be added
-        assert plugin_with_validator.app is not None
-        # Without app_id, no middleware but app still exists
-        assert plugin_without_validator.app is not None
-
-    def test_logger_property(self, mock_logger):
-        """Test logger property assignment."""
-        plugin = HttpPlugin(logger=mock_logger)
-        assert plugin.logger == mock_logger
-
-    def test_app_property(self, plugin_with_validator):
-        """Test FastAPI app property."""
-        from fastapi import FastAPI
-
-        assert isinstance(plugin_with_validator.app, FastAPI)
-
-    @pytest.mark.asyncio
-    @pytest.mark.parametrize("is_handler_async", [True, False])
-    async def test_on_activity_request_success(self, plugin_without_validator, mock_account, is_handler_async):
-        """Test on_activity_request with successful async/sync on_activity_event handler."""
-        expected_body = {"status": "success"}
-        expected_response = InvokeResponse(body=cast(ConfigResponse, expected_body), status=200)
-        mock_handler = (
-            AsyncMock(return_value=expected_response) if is_handler_async else MagicMock(return_value=expected_response)
-        )
-        plugin_without_validator.on_activity_event = mock_handler
-
-        mock_request = AsyncMock(spec=Request)
-        activity = cast(
-            MessageActivity,
-            MessageActivityInput(
-                type="message",
-                text="Test message",
-                from_=mock_account,
-                id="test-123",
-                channel_id="msteams",
-                conversation=ConversationAccount(id="conv-456", conversation_type="personal"),
-                recipient=mock_account,
-            ),
-        )
-        mock_request.json.return_value = activity.model_dump()
-        mock_request.state = MagicMock()
-        mock_request.state.validated_token = None
-
-        mock_response = MagicMock(spec=Response)
-
-        result = await plugin_without_validator.on_activity_request(mock_request, mock_response)
-
-        mock_handler.assert_called_once()
-        call_args = mock_handler.call_args[0][0]
-        assert isinstance(call_args, ActivityEvent)
-        assert call_args.sender == plugin_without_validator
-
-        assert result == expected_body
-
-    @pytest.mark.asyncio
-    @pytest.mark.parametrize("is_handler_async", [True, False])
-    async def test_on_activity_request_exception(self, plugin_without_validator, mock_account, is_handler_async):
-        """Test on_activity_request when handler raises exception."""
-        test_error = ValueError("Handler failed")
-        mock_handler = AsyncMock(side_effect=test_error) if is_handler_async else MagicMock(side_effect=test_error)
-        plugin_without_validator.on_activity_event = mock_handler
-
-        mock_request = AsyncMock(spec=Request)
-        activity = cast(
-            MessageActivity,
-            MessageActivityInput(
-                type="message",
-                text="Test message",
-                from_=mock_account,
-                id="test-123",
-                channel_id="msteams",
-                conversation=ConversationAccount(id="conv-456", conversation_type="personal"),
-                recipient=mock_account,
-            ),
-        )
-        mock_request.json.return_value = activity.model_dump()
-        mock_request.state = MagicMock()
-        mock_request.state.validated_token = None
-
-        mock_response = MagicMock(spec=Response)
-
-        result = await plugin_without_validator.on_activity_request(mock_request, mock_response)
-
-        mock_handler.assert_called_once()
-        # Exception is logged directly at exception site
-        plugin_without_validator.logger.exception.assert_called_once_with(str(test_error))
-
-        assert isinstance(result, Response)
-        assert result.status_code == 500
-
-    # Tests for HttpPlugin.send() with targeted messages
-
-    @pytest.fixture
-    def plugin_for_send(self):
-        """Create HttpPlugin for send testing."""
-        plugin = HttpPlugin(logger=MagicMock())
-        plugin.client = MagicMock()
-        plugin.client.clone = MagicMock(return_value=MagicMock())
-        plugin.bot_token = MagicMock()
-        return plugin
-
-    @pytest.fixture
-    def conversation_ref(self):
-        """Create a conversation reference for testing."""
-        return ConversationReference(
-            bot=Account(id="bot-123", name="Test Bot", role="bot"),
-            conversation=ConversationAccount(id="conv-456", conversation_type="personal"),
-            channel_id="msteams",
-            service_url="https://test.service.url",
-        )
-
-    def _create_sent_activity(self, activity, activity_id="msg-123"):
-        """Helper to create a proper SentActivity mock."""
-        from microsoft_teams.api import SentActivity
-
-        return SentActivity(id=activity_id, activity_params=activity)
-
-    @pytest.mark.asyncio
-    async def test_send_non_targeted_message_calls_create(self, plugin_for_send, conversation_ref):
-        """Test that non-targeted messages use the regular create method."""
-        activity = MessageActivityInput(text="Hello")
-
-        mock_activities = MagicMock()
-        mock_activities.create = AsyncMock(return_value=self._create_sent_activity(activity))
-
-        with patch("microsoft_teams.apps.http_plugin.ApiClient") as mock_api_client:
-            mock_api = MagicMock()
-            mock_api.conversations.activities.return_value = mock_activities
-            mock_api_client.return_value = mock_api
-
-            await plugin_for_send.send(activity, conversation_ref)
-
-            mock_activities.create.assert_called_once_with(activity)
-            mock_activities.create_targeted.assert_not_called()
-
-    @pytest.mark.asyncio
-    async def test_send_targeted_message_calls_create_targeted(self, plugin_for_send, conversation_ref):
-        """Test that targeted messages use the create_targeted method."""
-
-        recipient = Account(id="user-123", name="Test User", role="user")
-        activity = MessageActivityInput(text="Hello").with_recipient(recipient, is_targeted=True)
-
-        mock_activities = MagicMock()
-        mock_activities.create_targeted = AsyncMock(return_value=self._create_sent_activity(activity))
-
-        with patch("microsoft_teams.apps.http_plugin.ApiClient") as mock_api_client:
-            mock_api = MagicMock()
-            mock_api.conversations.activities.return_value = mock_activities
-            mock_api_client.return_value = mock_api
-
-            await plugin_for_send.send(activity, conversation_ref)
-
-            mock_activities.create_targeted.assert_called_once_with(activity)
-            mock_activities.create.assert_not_called()
-
-    @pytest.mark.asyncio
-    async def test_update_non_targeted_message_calls_update(self, plugin_for_send, conversation_ref):
-        """Test that non-targeted message updates use the regular update method."""
-        activity = MessageActivityInput(text="Updated message")
-        activity.id = "existing-msg-id"
-
-        mock_activities = MagicMock()
-        mock_activities.update = AsyncMock(return_value=self._create_sent_activity(activity, "existing-msg-id"))
-
-        with patch("microsoft_teams.apps.http_plugin.ApiClient") as mock_api_client:
-            mock_api = MagicMock()
-            mock_api.conversations.activities.return_value = mock_activities
-            mock_api_client.return_value = mock_api
-
-            await plugin_for_send.send(activity, conversation_ref)
-
-            mock_activities.update.assert_called_once_with("existing-msg-id", activity)
-            mock_activities.update_targeted.assert_not_called()
-
-    @pytest.mark.asyncio
-    async def test_update_targeted_message_calls_update_targeted(self, plugin_for_send, conversation_ref):
-        """Test that targeted message updates use the update_targeted method."""
-        activity = MessageActivityInput(text="Updated targeted message")
-        activity.id = "existing-msg-id"
-        activity.is_targeted = True
-
-        mock_activities = MagicMock()
-        mock_activities.update_targeted = AsyncMock(
-            return_value=self._create_sent_activity(activity, "existing-msg-id")
-        )
-
-        with patch("microsoft_teams.apps.http_plugin.ApiClient") as mock_api_client:
-            mock_api = MagicMock()
-            mock_api.conversations.activities.return_value = mock_activities
-            mock_api_client.return_value = mock_api
-
-            await plugin_for_send.send(activity, conversation_ref)
-
-            mock_activities.update_targeted.assert_called_once_with("existing-msg-id", activity)
-            mock_activities.update.assert_not_called()
diff --git a/packages/apps/tests/test_http_server.py b/packages/apps/tests/test_http_server.py
new file mode 100644
index 00000000..bba4bcd8
--- /dev/null
+++ b/packages/apps/tests/test_http_server.py
@@ -0,0 +1,223 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+# pyright: basic
+
+from typing import cast
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from microsoft_teams.api import (
+    ConfigResponse,
+    InvokeResponse,
+)
+from microsoft_teams.apps.http import FastAPIAdapter, HttpServer
+from microsoft_teams.apps.http.adapter import HttpRequest, HttpResponse
+
+
+class TestHttpServer:
+    """Test cases for HttpServer public interface."""
+
+    @pytest.fixture
+    def mock_adapter(self):
+        """Create a mock adapter."""
+        adapter = MagicMock()
+        adapter.register_route = MagicMock()
+        adapter.serve_static = MagicMock()
+        adapter.start = AsyncMock()
+        adapter.stop = AsyncMock()
+        return adapter
+
+    @pytest.fixture
+    def server(self, mock_adapter):
+        """Create HttpServer with mock adapter."""
+        return HttpServer(mock_adapter)
+
+    def test_init(self, server, mock_adapter):
+        """Test HttpServer initialization."""
+        assert server.adapter is mock_adapter
+        assert server.on_request is None
+
+    def test_messaging_endpoint_default(self, server):
+        """Test default messaging endpoint."""
+        assert server.messaging_endpoint == "/api/messages"
+
+    def test_initialize_registers_route(self, server, mock_adapter):
+        """Test that initialize registers the /api/messages route."""
+        server.initialize()
+        mock_adapter.register_route.assert_called_once()
+        call_args = mock_adapter.register_route.call_args
+        assert call_args[0][0] == "POST"
+        assert call_args[0][1] == "/api/messages"
+
+    def test_initialize_registers_custom_messaging_endpoint(self, mock_adapter):
+        """Test that initialize registers a custom messaging endpoint."""
+        custom_server = HttpServer(mock_adapter, messaging_endpoint="/bot/incoming")
+        assert custom_server.messaging_endpoint == "/bot/incoming"
+
+        custom_server.initialize()
+        mock_adapter.register_route.assert_called_once()
+        call_args = mock_adapter.register_route.call_args
+        assert call_args[0][0] == "POST"
+        assert call_args[0][1] == "/bot/incoming"
+
+    def test_on_request_setter(self, server):
+        """Test on_request callback setter."""
+
+        async def handler(event):
+            return InvokeResponse(status=200)
+
+        server.on_request = handler
+        assert server.on_request is handler
+
+    @pytest.mark.asyncio
+    async def test_handle_activity_success(self, server):
+        """Test successful activity handling."""
+        expected_body = {"status": "success"}
+        expected_response = InvokeResponse(body=cast(ConfigResponse, expected_body), status=200)
+
+        async def mock_handler(event):
+            return expected_response
+
+        server.on_request = mock_handler
+        server.initialize(skip_auth=True)
+
+        request = HttpRequest(
+            body={
+                "type": "message",
+                "id": "test-123",
+                "text": "Test message",
+            },
+            headers={},
+        )
+
+        result = await server.handle_request(request)
+
+        assert result["status"] == 200
+        assert result["body"] == expected_body
+
+    @pytest.mark.asyncio
+    async def test_handle_activity_exception(self, server):
+        """Test activity handling when handler raises exception."""
+
+        async def failing_handler(event):
+            raise ValueError("Handler failed")
+
+        server.on_request = failing_handler
+        server.initialize(skip_auth=True)
+
+        request = HttpRequest(
+            body={"type": "message", "id": "test-123"},
+            headers={},
+        )
+
+        result = await server.handle_request(request)
+
+        assert result["status"] == 500
+
+    @pytest.mark.asyncio
+    async def test_handle_activity_no_handler(self, server):
+        """Test activity handling when no on_request handler is set."""
+        server.initialize(skip_auth=True)
+
+        request = HttpRequest(
+            body={"type": "message", "id": "test-123"},
+            headers={},
+        )
+
+        result = await server.handle_request(request)
+
+        assert result["status"] == 500
+
+
+class TestFastAPIAdapter:
+    """Test cases for FastAPIAdapter."""
+
+    def test_init_creates_fastapi_app(self):
+        """Test FastAPIAdapter creates a FastAPI app."""
+        from fastapi import FastAPI
+
+        adapter = FastAPIAdapter()
+        assert isinstance(adapter.app, FastAPI)
+
+    def test_register_route(self):
+        """Test route registration on FastAPI app."""
+        adapter = FastAPIAdapter()
+
+        async def handler(req: HttpRequest) -> HttpResponse:
+            return HttpResponse(status=200, body=None)
+
+        adapter.register_route("POST", "/test", handler)
+
+        # Verify a route was registered on the FastAPI app
+        routes = [r for r in adapter.app.routes if hasattr(r, "path") and r.path == "/test"]
+        assert len(routes) == 1
+
+    def test_serve_static(self, tmp_path):
+        """Test static file mounting."""
+        adapter = FastAPIAdapter()
+        adapter.serve_static("/static", str(tmp_path))
+
+        # Verify a mount was registered
+        mounts = [r for r in adapter.app.routes if hasattr(r, "path") and r.path == "/static"]
+        assert len(mounts) == 1
+
+    @pytest.mark.asyncio
+    async def test_start_creates_uvicorn_server(self):
+        """Test that start creates and starts a uvicorn server."""
+        adapter = FastAPIAdapter()
+
+        mock_server = MagicMock()
+        mock_server.serve = AsyncMock()
+
+        with (
+            patch("microsoft_teams.apps.http.fastapi_adapter.uvicorn.Config") as mock_config,
+            patch("microsoft_teams.apps.http.fastapi_adapter.uvicorn.Server", return_value=mock_server),
+        ):
+            mock_config.return_value = MagicMock()
+            await adapter.start(3978)
+
+            mock_config.assert_called_once()
+            mock_server.serve.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_stop(self):
+        """Test stop signals the server."""
+        adapter = FastAPIAdapter()
+        mock_server = MagicMock()
+        adapter._server = mock_server
+
+        await adapter.stop()
+
+        assert mock_server.should_exit is True
+
+    @pytest.mark.asyncio
+    async def test_stop_no_server(self):
+        """Test stop when no server is running."""
+        adapter = FastAPIAdapter()
+        # Should not raise
+        await adapter.stop()
+
+    def test_server_factory(self):
+        """Test custom server factory."""
+        mock_server = MagicMock()
+
+        def factory(app):
+            mock_server.config = MagicMock()
+            mock_server.config.app = app
+            return mock_server
+
+        adapter = FastAPIAdapter(server_factory=factory)
+        assert adapter._server is mock_server
+
+    def test_server_factory_wrong_app_raises(self):
+        """Test that server factory with wrong app raises."""
+        mock_server = MagicMock()
+        mock_server.config.app = MagicMock()  # Different app instance
+
+        def factory(app):
+            return mock_server
+
+        with pytest.raises(ValueError, match="server_factory must return"):
+            FastAPIAdapter(server_factory=factory)
diff --git a/packages/apps/tests/test_http_stream.py b/packages/apps/tests/test_http_stream.py
index d1826d78..f6c9905a 100644
--- a/packages/apps/tests/test_http_stream.py
+++ b/packages/apps/tests/test_http_stream.py
@@ -56,8 +56,8 @@ def conversation_reference(self):
         )
 
     @pytest.fixture
-    def http_stream(self, mock_api_client, conversation_reference, mock_logger):
-        return HttpStream(mock_api_client, conversation_reference, mock_logger)
+    def http_stream(self, mock_api_client, conversation_reference):
+        return HttpStream(mock_api_client, conversation_reference)
 
     @pytest.fixture
     def patch_loop_call_later(self):
@@ -96,7 +96,7 @@ async def test_stream_multiple_emits_with_timer(self, http_stream, patch_loop_ca
 
     @pytest.mark.asyncio
     async def test_stream_error_handled_gracefully(
-        self, mock_api_client, conversation_reference, mock_logger, patch_loop_call_later
+        self, mock_api_client, conversation_reference, patch_loop_call_later
     ):
         call_count = 0
         loop = asyncio.get_running_loop()
@@ -111,7 +111,7 @@ async def mock_send_with_timeout(activity):
                 return SentActivity(id=f"success-after-timeout-{call_count}", activity_params=activity)
 
             mock_api_client.conversations.activities().create = mock_send_with_timeout
-            stream = HttpStream(mock_api_client, conversation_reference, mock_logger)
+            stream = HttpStream(mock_api_client, conversation_reference)
 
             stream.emit("Test message with timeout")
             await asyncio.sleep(0)
@@ -123,7 +123,7 @@ async def mock_send_with_timeout(activity):
 
     @pytest.mark.asyncio
     async def test_stream_all_timeouts_fail_handled_gracefully(
-        self, mock_api_client, conversation_reference, mock_logger, patch_loop_call_later
+        self, mock_api_client, conversation_reference, patch_loop_call_later
     ):
         call_count = 0
         loop = asyncio.get_running_loop()
@@ -136,7 +136,7 @@ async def mock_send_all_timeout(activity):
                 raise TimeoutError("All operations timed out")
 
             mock_api_client.conversations.activities().create = mock_send_all_timeout
-            stream = HttpStream(mock_api_client, conversation_reference, mock_logger)
+            stream = HttpStream(mock_api_client, conversation_reference)
 
             stream.emit("Test message with all timeouts")
             await asyncio.sleep(0)
@@ -146,12 +146,12 @@ async def mock_send_all_timeout(activity):
 
     @pytest.mark.asyncio
     async def test_stream_update_status_sends_typing_activity(
-        self, mock_api_client, conversation_reference, mock_logger, patch_loop_call_later
+        self, mock_api_client, conversation_reference, patch_loop_call_later
     ):
         loop = asyncio.get_running_loop()
         patcher, scheduled = patch_loop_call_later(loop)
         with patcher:
-            stream = HttpStream(mock_api_client, conversation_reference, mock_logger)
+            stream = HttpStream(mock_api_client, conversation_reference)
             stream.update("Thinking...")
             await asyncio.sleep(0)
             await self._run_scheduled_flushes(scheduled)
@@ -166,12 +166,12 @@ async def test_stream_update_status_sends_typing_activity(
 
     @pytest.mark.asyncio
     async def test_stream_sequence_of_update_and_emit(
-        self, mock_api_client, conversation_reference, mock_logger, patch_loop_call_later
+        self, mock_api_client, conversation_reference, patch_loop_call_later
     ):
         loop = asyncio.get_running_loop()
         patcher, scheduled = patch_loop_call_later(loop)
         with patcher:
-            stream = HttpStream(mock_api_client, conversation_reference, mock_logger)
+            stream = HttpStream(mock_api_client, conversation_reference)
             stream.update("Preparing response...")
             stream.emit("Final response message")
             await asyncio.sleep(0)
@@ -188,7 +188,7 @@ async def test_stream_sequence_of_update_and_emit(
 
     @pytest.mark.asyncio
     async def test_stream_concurrent_emits_do_not_flush_simultaneously(
-        self, mock_api_client, conversation_reference, mock_logger, patch_loop_call_later
+        self, mock_api_client, conversation_reference, patch_loop_call_later
     ):
         concurrent_entries = 0
         max_concurrent_entries = 0
@@ -209,7 +209,7 @@ async def mock_send(activity):
         mock_api_client.conversations.activities().create = mock_send
 
         with patcher:
-            stream = HttpStream(mock_api_client, conversation_reference, mock_logger)
+            stream = HttpStream(mock_api_client, conversation_reference)
 
             async def emit_task():
                 stream.emit("Concurrent message")
diff --git a/packages/apps/tests/test_jwt_middleware.py b/packages/apps/tests/test_jwt_middleware.py
new file mode 100644
index 00000000..1f4b548f
--- /dev/null
+++ b/packages/apps/tests/test_jwt_middleware.py
@@ -0,0 +1,154 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+# pyright: basic
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import jwt
+import pytest
+from fastapi import HTTPException
+from microsoft_teams.apps.auth.jwt_middleware import create_jwt_validation_middleware
+
+
+class TestCreateJwtValidationMiddleware:
+    """Test suite for create_jwt_validation_middleware."""
+
+    VALIDATED_PATHS = ["/api/messages"]
+    APP_ID = "test-app-id"
+
+    @pytest.fixture
+    def mock_call_next(self):
+        """Create a mock call_next coroutine."""
+        mock_response = MagicMock()
+        call_next = AsyncMock(return_value=mock_response)
+        return call_next
+
+    def _make_request(self, path: str, auth_header: str | None = None, body: dict | None = None) -> MagicMock:
+        """Build a mock FastAPI Request with the given path and auth header."""
+        mock_request = MagicMock()
+        mock_request.url.path = path
+        mock_request.headers.get = MagicMock(return_value=auth_header)
+        if body is None:
+            body = {"serviceUrl": "https://test.service.url", "id": "activity-123"}
+        mock_request.json = AsyncMock(return_value=body)
+        mock_request.state = MagicMock()
+        return mock_request
+
+    @pytest.mark.asyncio
+    async def test_path_not_in_validated_paths(self, mock_call_next):
+        """Requests whose path is not in the validated paths list bypass auth and call call_next directly."""
+        with patch("microsoft_teams.apps.auth.jwt_middleware.TokenValidator") as mock_validator_class:
+            mock_validator = AsyncMock()
+            mock_validator_class.for_service.return_value = mock_validator
+
+            middleware = create_jwt_validation_middleware(self.APP_ID, self.VALIDATED_PATHS)
+
+            mock_request = self._make_request("/health")
+            response = await middleware(mock_request, mock_call_next)
+
+        mock_call_next.assert_awaited_once_with(mock_request)
+        assert response is mock_call_next.return_value
+
+    @pytest.mark.asyncio
+    async def test_missing_authorization_header(self, mock_call_next):
+        """A request to a validated path with no authorization header raises HTTP 401."""
+        with patch("microsoft_teams.apps.auth.jwt_middleware.TokenValidator") as mock_validator_class:
+            mock_validator = AsyncMock()
+            mock_validator_class.for_service.return_value = mock_validator
+
+            middleware = create_jwt_validation_middleware(self.APP_ID, self.VALIDATED_PATHS)
+
+            mock_request = self._make_request("/api/messages", auth_header=None)
+
+            with pytest.raises(HTTPException) as exc_info:
+                await middleware(mock_request, mock_call_next)
+
+        assert exc_info.value.status_code == 401
+        mock_call_next.assert_not_awaited()
+
+    @pytest.mark.asyncio
+    async def test_invalid_authorization_format(self, mock_call_next):
+        """An authorization header that does not start with 'Bearer ' raises HTTP 401."""
+        with patch("microsoft_teams.apps.auth.jwt_middleware.TokenValidator") as mock_validator_class:
+            mock_validator = AsyncMock()
+            mock_validator_class.for_service.return_value = mock_validator
+
+            middleware = create_jwt_validation_middleware(self.APP_ID, self.VALIDATED_PATHS)
+
+            mock_request = self._make_request("/api/messages", auth_header="Basic dXNlcjpwYXNz")
+
+            with pytest.raises(HTTPException) as exc_info:
+                await middleware(mock_request, mock_call_next)
+
+        assert exc_info.value.status_code == 401
+        mock_call_next.assert_not_awaited()
+
+    @pytest.mark.asyncio
+    async def test_valid_token_success(self, mock_call_next):
+        """A valid Bearer token is validated, stored in request.state, and call_next is called."""
+        mock_jwt_token = MagicMock()
+
+        with (
+            patch("microsoft_teams.apps.auth.jwt_middleware.TokenValidator") as mock_validator_class,
+            patch("microsoft_teams.apps.auth.jwt_middleware.JsonWebToken", return_value=mock_jwt_token) as mock_jwt_cls,
+        ):
+            mock_validator = AsyncMock()
+            mock_validator_class.for_service.return_value = mock_validator
+            mock_validator.validate_token = AsyncMock(return_value=None)
+
+            middleware = create_jwt_validation_middleware(self.APP_ID, self.VALIDATED_PATHS)
+
+            mock_request = self._make_request("/api/messages", auth_header="Bearer my.jwt.token")
+            response = await middleware(mock_request, mock_call_next)
+
+        # validate_token was called with the raw token and service URL from the body
+        mock_validator.validate_token.assert_awaited_once_with("my.jwt.token", "https://test.service.url")
+
+        # JsonWebToken was constructed with the raw token
+        mock_jwt_cls.assert_called_once_with(value="my.jwt.token")
+
+        # The validated token is stored in request state
+        assert mock_request.state.validated_token is mock_jwt_token
+
+        # call_next was invoked and its response was returned
+        mock_call_next.assert_awaited_once_with(mock_request)
+        assert response is mock_call_next.return_value
+
+    @pytest.mark.asyncio
+    async def test_jwt_invalid_token_error(self, mock_call_next):
+        """When the validator raises jwt.InvalidTokenError the middleware raises HTTP 401."""
+        with patch("microsoft_teams.apps.auth.jwt_middleware.TokenValidator") as mock_validator_class:
+            mock_validator = AsyncMock()
+            mock_validator_class.for_service.return_value = mock_validator
+            mock_validator.validate_token = AsyncMock(side_effect=jwt.InvalidTokenError("bad token"))
+
+            middleware = create_jwt_validation_middleware(self.APP_ID, self.VALIDATED_PATHS)
+
+            mock_request = self._make_request("/api/messages", auth_header="Bearer bad.jwt.token")
+
+            with pytest.raises(HTTPException) as exc_info:
+                await middleware(mock_request, mock_call_next)
+
+        assert exc_info.value.status_code == 401
+        mock_call_next.assert_not_awaited()
+
+    @pytest.mark.asyncio
+    async def test_unexpected_exception(self, mock_call_next):
+        """When the validator raises a generic Exception the middleware raises HTTP 500."""
+        with patch("microsoft_teams.apps.auth.jwt_middleware.TokenValidator") as mock_validator_class:
+            mock_validator = AsyncMock()
+            mock_validator_class.for_service.return_value = mock_validator
+            mock_validator.validate_token = AsyncMock(side_effect=RuntimeError("network error"))
+
+            middleware = create_jwt_validation_middleware(self.APP_ID, self.VALIDATED_PATHS)
+
+            mock_request = self._make_request("/api/messages", auth_header="Bearer some.jwt.token")
+
+            with pytest.raises(HTTPException) as exc_info:
+                await middleware(mock_request, mock_call_next)
+
+        assert exc_info.value.status_code == 500
+        mock_call_next.assert_not_awaited()
diff --git a/packages/apps/tests/test_optional_graph_dependencies.py b/packages/apps/tests/test_optional_graph_dependencies.py
index aa52e33c..e646df62 100644
--- a/packages/apps/tests/test_optional_graph_dependencies.py
+++ b/packages/apps/tests/test_optional_graph_dependencies.py
@@ -18,24 +18,23 @@ def _create_activity_context(self) -> ActivityContext[Any]:
         """Create a minimal ActivityContext for testing."""
         # Create mock objects for all required parameters
         mock_activity = MagicMock()
-        mock_logger = MagicMock()
         mock_storage = MagicMock()
         mock_api = MagicMock()
         mock_conversation_ref = MagicMock()
-        mock_sender = MagicMock()
+        mock_activity_sender = MagicMock()
+        mock_activity_sender.create_stream.return_value = MagicMock()
         mock_app_token = MagicMock()  # Provide an app token for graph access
 
         return ActivityContext(
             activity=mock_activity,
             app_id="test-app-id",
-            logger=mock_logger,
             storage=mock_storage,
             api=mock_api,
             user_token=None,
             conversation_ref=mock_conversation_ref,
             is_signed_in=False,
             connection_name="test-connection",
-            sender=mock_sender,
+            activity_sender=mock_activity_sender,
             app_token=mock_app_token,  # This is needed for app_graph to work
         )
 
@@ -76,14 +75,13 @@ def test_user_graph_property_not_signed_in(self) -> None:
         activity_context = ActivityContext(
             activity=MagicMock(),
             app_id="test-app-id",
-            logger=MagicMock(),
             storage=MagicMock(),
             api=MagicMock(),
             user_token=MagicMock(),  # Has token but not signed in
             conversation_ref=MagicMock(),
             is_signed_in=False,  # Not signed in
             connection_name="test-connection",
-            sender=MagicMock(),
+            activity_sender=MagicMock(),
             app_token=None,
         )
 
@@ -96,14 +94,13 @@ def test_user_graph_property_no_token(self) -> None:
         activity_context = ActivityContext(
             activity=MagicMock(),
             app_id="test-app-id",
-            logger=MagicMock(),
             storage=MagicMock(),
             api=MagicMock(),
             user_token=None,  # No token
             conversation_ref=MagicMock(),
             is_signed_in=True,  # Signed in but no token
             connection_name="test-connection",
-            sender=MagicMock(),
+            activity_sender=MagicMock(),
             app_token=None,
         )
 
@@ -116,14 +113,13 @@ def test_app_graph_property_no_token(self) -> None:
         activity_context = ActivityContext(
             activity=MagicMock(),
             app_id="test-app-id",
-            logger=MagicMock(),
             storage=MagicMock(),
             api=MagicMock(),
             user_token=None,
             conversation_ref=MagicMock(),
             is_signed_in=False,
             connection_name="test-connection",
-            sender=MagicMock(),
+            activity_sender=MagicMock(),
             app_token=None,  # No app token
         )
 
diff --git a/packages/apps/tests/test_remote_function_jwt_middleware.py b/packages/apps/tests/test_remote_function_jwt_middleware.py
new file mode 100644
index 00000000..dbef1a71
--- /dev/null
+++ b/packages/apps/tests/test_remote_function_jwt_middleware.py
@@ -0,0 +1,109 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+# pyright: basic
+
+from unittest.mock import AsyncMock
+
+import pytest
+from microsoft_teams.apps.auth.remote_function_jwt_middleware import (
+    validate_remote_function_request,
+)
+from microsoft_teams.apps.contexts import ClientContext
+
+
+class TestValidateRemoteFunctionRequest:
+    """Tests for validate_remote_function_request."""
+
+    def _base_headers(self) -> dict[str, str]:
+        """Return a complete, valid set of request headers."""
+        return {
+            "Authorization": "Bearer test.jwt.token",
+            "X-Teams-App-Session-Id": "session-123",
+            "X-Teams-Page-Id": "page-456",
+        }
+
+    def _make_validator(self, payload: dict | None = None) -> AsyncMock:
+        """Return a mock TokenValidator whose validate_token returns *payload*."""
+        if payload is None:
+            payload = {"oid": "user-123", "tid": "tenant-456", "name": "Test User"}
+        mock_validator = AsyncMock()
+        mock_validator.validate_token = AsyncMock(return_value=payload)
+        return mock_validator
+
+    @pytest.mark.asyncio
+    async def test_validate_request_missing_header(self):
+        """When a required header is missing the function returns (None, error_message)."""
+        headers = {
+            # Missing Authorization and X-Teams-App-Session-Id
+            "X-Teams-Page-Id": "page-456",
+        }
+        context, error = await validate_remote_function_request(headers, self._make_validator())
+
+        assert context is None
+        assert error is not None
+        assert len(error) > 0
+
+    @pytest.mark.asyncio
+    async def test_validate_request_no_token_validator(self):
+        """When entra_token_validator is None the function returns (None, 'Token validator not configured')."""
+        headers = self._base_headers()
+        context, error = await validate_remote_function_request(headers, None)
+
+        assert context is None
+        assert error == "Token validator not configured"
+
+    @pytest.mark.asyncio
+    async def test_validate_request_valid(self):
+        """All valid inputs → returns (ClientContext, None) with correct field values."""
+        headers = self._base_headers()
+        validator = self._make_validator()
+
+        context, error = await validate_remote_function_request(headers, validator)
+
+        assert error is None
+        assert isinstance(context, ClientContext)
+        assert context.user_id == "user-123"
+        assert context.tenant_id == "tenant-456"
+        assert context.user_name == "Test User"
+        assert context.app_session_id == "session-123"
+        assert context.page_id == "page-456"
+        assert context.auth_token == "test.jwt.token"
+
+        validator.validate_token.assert_awaited_once_with("test.jwt.token")
+
+    @pytest.mark.asyncio
+    async def test_validate_request_missing_token_fields(self):
+        """When the token payload is missing oid/tid/name the function returns (None, error_message)."""
+        headers = self._base_headers()
+        # Payload deliberately omits required fields
+        validator = self._make_validator(payload={"scp": "user.read"})
+
+        context, error = await validate_remote_function_request(headers, validator)
+
+        assert context is None
+        assert error is not None
+        # All three missing fields should be named in the message
+        assert "oid" in error
+        assert "tid" in error
+        assert "name" in error
+
+    @pytest.mark.asyncio
+    async def test_validate_request_case_insensitive_headers(self):
+        """Lowercase header names are treated the same as the canonical casing."""
+        headers = {
+            "authorization": "Bearer test.jwt.token",
+            "x-teams-app-session-id": "session-123",
+            "x-teams-page-id": "page-456",
+        }
+        validator = self._make_validator()
+
+        context, error = await validate_remote_function_request(headers, validator)
+
+        assert error is None
+        assert isinstance(context, ClientContext)
+        assert context.app_session_id == "session-123"
+        assert context.page_id == "page-456"
+        assert context.auth_token == "test.jwt.token"
diff --git a/packages/apps/tests/test_retry.py b/packages/apps/tests/test_retry.py
index 15d45ba6..6ea5b4e3 100644
--- a/packages/apps/tests/test_retry.py
+++ b/packages/apps/tests/test_retry.py
@@ -3,8 +3,6 @@
 Licensed under the MIT License.
 """
 
-from unittest.mock import MagicMock
-
 import pytest
 from microsoft_teams.apps.utils import RetryOptions, retry
 
@@ -22,17 +20,14 @@ def test_default_initialization(self):
         assert options.max_delay == 30.0
         assert options.jitter_type == "full"
         assert options.attempt_number == 1
-        assert options.logger is not None
 
     def test_custom_initialization(self):
         """Test that RetryOptions can be initialized with custom values."""
-        mock_logger = MagicMock()
         options = RetryOptions(
             max_attempts=3,
             delay=1.0,
             max_delay=60.0,
             jitter_type="none",
-            logger=mock_logger,
             attempt_number=2,
         )
         assert options.max_attempts == 3
@@ -40,8 +35,6 @@ def test_custom_initialization(self):
         assert options.max_delay == 60.0
         assert options.jitter_type == "none"
         assert options.attempt_number == 2
-        # Logger should be a child of the provided logger
-        mock_logger.getChild.assert_called_once_with("@teams/retry")
 
 
 class TestRetry:
@@ -62,18 +55,9 @@ async def success_factory():
         assert call_count == 1
 
     @pytest.mark.asyncio
-    async def test_attempt_number_increments_correctly(self):
+    async def test_attempt_number_increments_correctly(self, caplog):
         """Test that attempt numbers increment correctly in log messages."""
         call_count = 0
-        mock_logger = MagicMock()
-        logged_messages = []
-
-        def capture_debug(msg):
-            logged_messages.append(msg)
-
-        mock_child_logger = MagicMock()
-        mock_child_logger.debug.side_effect = capture_debug
-        mock_logger.getChild.return_value = mock_child_logger
 
         async def failing_factory():
             nonlocal call_count
@@ -82,34 +66,24 @@ async def failing_factory():
                 raise ValueError(f"Attempt {call_count} failed")
             return "success"
 
-        options = RetryOptions(max_attempts=3, delay=0.01, jitter_type="none", logger=mock_logger)
-        result = await retry(failing_factory, options)
+        options = RetryOptions(max_attempts=3, delay=0.01, jitter_type="none")
+
+        with caplog.at_level("DEBUG"):
+            result = await retry(failing_factory, options)
 
         assert result == "success"
         assert call_count == 3
 
         # Check that attempt numbers are logged correctly
-        delay_messages = [msg for msg in logged_messages if "before retry (attempt" in msg]
+        delay_messages = [rec.message for rec in caplog.records if "before retry (attempt" in rec.message]
         assert len(delay_messages) == 2  # Two retries (attempts 1 and 2 failed)
         assert "(attempt 1)" in delay_messages[0]  # First retry shows attempt 1 (which failed)
         assert "(attempt 2)" in delay_messages[1]  # Second retry shows attempt 2 (which failed)
 
     @pytest.mark.asyncio
-    async def test_exponential_backoff_increases(self):
+    async def test_exponential_backoff_increases(self, caplog):
         """Test that exponential backoff delays increase exponentially."""
         call_count = 0
-        mock_logger = MagicMock()
-        logged_delays = []
-
-        def capture_debug(msg):
-            if "Delaying" in msg and "before retry" in msg:
-                # Extract delay value from message like "Delaying 1.00s before retry..."
-                delay_str = msg.split("Delaying ")[1].split("s")[0]
-                logged_delays.append(float(delay_str))
-
-        mock_child_logger = MagicMock()
-        mock_child_logger.debug.side_effect = capture_debug
-        mock_logger.getChild.return_value = mock_child_logger
 
         async def failing_factory():
             nonlocal call_count
@@ -119,11 +93,23 @@ async def failing_factory():
             return "success"
 
         # Use no jitter to test pure exponential backoff
-        options = RetryOptions(max_attempts=4, delay=1.0, jitter_type="none", logger=mock_logger)
-        result = await retry(failing_factory, options)
+        options = RetryOptions(max_attempts=4, delay=1.0, jitter_type="none")
+
+        with caplog.at_level("DEBUG"):
+            result = await retry(failing_factory, options)
 
         assert result == "success"
         assert call_count == 4
+
+        # Extract delay values from log messages
+        logged_delays = []
+        for rec in caplog.records:
+            msg = rec.message
+            if "Delaying" in msg and "before retry" in msg:
+                # Extract delay value from message like "Delaying 1.00s before retry..."
+                delay_str = msg.split("Delaying ")[1].split("s")[0]
+                logged_delays.append(float(delay_str))
+
         assert len(logged_delays) == 3  # Three retries
 
         # Check exponential increase: base_delay * (2^(attempt_number - 1))
@@ -135,23 +121,9 @@ async def failing_factory():
         assert logged_delays[2] == 4.0  # Third retry (after attempt 3 failed)
 
     @pytest.mark.asyncio
-    async def test_logger_name_consistent(self):
-        """Test that logger name doesn't keep growing with recursive calls."""
+    async def test_logger_name_consistent(self, caplog):
+        """Test that logger uses consistent name across retry attempts."""
         call_count = 0
-        mock_logger = MagicMock()
-        mock_logger.name = "test_logger"
-
-        # Track how many times getChild is called
-        child_call_count = 0
-
-        def track_get_child(child_name):
-            nonlocal child_call_count
-            child_call_count += 1
-            child_mock = MagicMock()
-            child_mock.name = f"{mock_logger.name}.{child_name}"
-            return child_mock
-
-        mock_logger.getChild.side_effect = track_get_child
 
         async def failing_factory():
             nonlocal call_count
@@ -160,16 +132,20 @@ async def failing_factory():
                 raise ValueError(f"Attempt {call_count} failed")
             return "success"
 
-        options = RetryOptions(max_attempts=3, delay=0.01, logger=mock_logger)
-        result = await retry(failing_factory, options)
+        options = RetryOptions(max_attempts=3, delay=0.01)
+
+        with caplog.at_level("DEBUG"):
+            result = await retry(failing_factory, options)
 
         assert result == "success"
         assert call_count == 3
 
-        # getChild should only be called once (for the initial RetryOptions)
-        # Recursive calls should reuse the existing child logger
-        assert child_call_count == 1
-        mock_logger.getChild.assert_called_once_with("@teams/retry")
+        # Check that all retry log messages use the same logger name
+        logger_names = [rec.name for rec in caplog.records]
+        # All messages should come from the same logger
+        assert len(set(logger_names)) == 1
+        # Logger name should be the module name
+        assert logger_names[0] == "microsoft_teams.apps.utils.retry"
 
     @pytest.mark.asyncio
     async def test_final_attempt_failure_raises(self):
diff --git a/packages/apps/tests/test_token_manager.py b/packages/apps/tests/test_token_manager.py
index 81cf2575..b83366f1 100644
--- a/packages/apps/tests/test_token_manager.py
+++ b/packages/apps/tests/test_token_manager.py
@@ -3,6 +3,8 @@
 Licensed under the MIT License.
 """
 
+# pyright: basic
+
 from typing import Literal, cast
 from unittest.mock import MagicMock, create_autospec, patch
 
@@ -13,6 +15,7 @@
     JsonWebToken,
     ManagedIdentityCredentials,
 )
+from microsoft_teams.api.auth.credentials import TokenCredentials
 from microsoft_teams.apps.token_manager import TokenManager
 from msal import ManagedIdentityClient  # pyright: ignore[reportMissingTypeStubs]
 
@@ -338,3 +341,201 @@ async def test_get_token_with_federated_identity_step2_failure(self):
                     await manager.get_bot_token()
 
                 assert "invalid_grant" in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_get_token_caller_name_logged_when_no_credentials(self):
+        """Test that caller_name is logged when credentials is None (covers line 77)."""
+        manager = TokenManager(credentials=None)
+
+        # Call _get_token directly with caller_name set and credentials=None
+        result = await manager._get_token(
+            "https://api.botframework.com/.default", "botframework.com", caller_name="test_caller"
+        )
+
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_get_token_with_token_credentials_sync(self):
+        """Test _get_token with a synchronous TokenCredentials token provider."""
+        credentials = TokenCredentials(
+            client_id="test-client-id",
+            token=lambda scope, tenant: VALID_TEST_TOKEN,
+            tenant_id="tenant",
+        )
+        manager = TokenManager(credentials=credentials)
+
+        result = await manager._get_token("https://api.botframework.com/.default", "botframework.com")
+        assert result is not None
+        assert isinstance(result, JsonWebToken)
+        assert str(result) == VALID_TEST_TOKEN
+
+    @pytest.mark.asyncio
+    async def test_get_token_with_token_credentials_async(self):
+        """Test _get_token with an async TokenCredentials token provider."""
+
+        async def async_token_provider(scope: str | list[str], _tenant: str | None) -> str:
+            return VALID_TEST_TOKEN
+
+        credentials = TokenCredentials(
+            client_id="test-client-id",
+            token=async_token_provider,
+            tenant_id="tenant",
+        )
+        manager = TokenManager(credentials=credentials)
+
+        result = await manager._get_token("https://api.botframework.com/.default", "botframework.com")
+        assert result is not None
+        assert isinstance(result, JsonWebToken)
+        assert str(result) == VALID_TEST_TOKEN
+
+    @pytest.mark.asyncio
+    async def test_acquire_managed_identity_token_success(self):
+        """Test _acquire_managed_identity_token returns token string on success."""
+        mock_credentials = FederatedIdentityCredentials(
+            client_id="test-app-client-id",
+            managed_identity_type="user",
+            managed_identity_client_id="test-mi-client-id",
+            tenant_id="test-tenant-id",
+        )
+
+        mock_mi_client = create_autospec(ManagedIdentityClient, instance=True)
+        mock_mi_client.acquire_token_for_client.return_value = {"access_token": "mi-token"}
+
+        manager = TokenManager(credentials=mock_credentials)
+
+        with patch.object(manager, "_get_managed_identity_client", return_value=mock_mi_client):
+            result = await manager._acquire_managed_identity_token(mock_credentials)
+
+        assert result == "mi-token"
+        mock_mi_client.acquire_token_for_client.assert_called_once_with(resource="api://AzureADTokenExchange")
+
+    @pytest.mark.asyncio
+    async def test_acquire_managed_identity_token_failure(self):
+        """Test _acquire_managed_identity_token raises ValueError when no access_token returned."""
+        mock_credentials = FederatedIdentityCredentials(
+            client_id="test-app-client-id",
+            managed_identity_type="user",
+            managed_identity_client_id="test-mi-client-id",
+            tenant_id="test-tenant-id",
+        )
+
+        mock_mi_client = create_autospec(ManagedIdentityClient, instance=True)
+        mock_mi_client.acquire_token_for_client.return_value = {"error": "some_error"}
+
+        manager = TokenManager(credentials=mock_credentials)
+
+        with patch.object(manager, "_get_managed_identity_client", return_value=mock_mi_client):
+            with pytest.raises(ValueError) as exc_info:
+                await manager._acquire_managed_identity_token(mock_credentials)
+
+        assert "some_error" in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_get_confidential_client_uses_cache(self):
+        """Test that _get_confidential_client returns cached client on second call."""
+        mock_credentials = ClientCredentials(
+            client_id="test-client-id",
+            client_secret="test-client-secret",
+            tenant_id="test-tenant-id",
+        )
+
+        manager = TokenManager(credentials=mock_credentials)
+
+        with patch("microsoft_teams.apps.token_manager.ConfidentialClientApplication") as mock_msal_class:
+            mock_msal_class.return_value = MagicMock()
+
+            client_first = manager._get_confidential_client(mock_credentials, "test-tenant-id")
+            client_second = manager._get_confidential_client(mock_credentials, "test-tenant-id")
+
+        # ConfidentialClientApplication should only be constructed once
+        mock_msal_class.assert_called_once()
+        assert client_first is client_second
+
+    @pytest.mark.asyncio
+    async def test_get_managed_identity_client_uses_cache(self):
+        """Test that _get_managed_identity_client returns cached client on second call."""
+        mock_credentials = ManagedIdentityCredentials(
+            client_id="test-managed-identity-client-id",
+            tenant_id="test-tenant-id",
+        )
+
+        manager = TokenManager(credentials=mock_credentials)
+
+        with patch("microsoft_teams.apps.token_manager.ManagedIdentityClient") as mock_mi_client_class:
+            with patch("microsoft_teams.apps.token_manager.requests") as mock_requests:
+                mock_requests.Session.return_value = MagicMock()
+                mock_mi_client_class.return_value = MagicMock()
+
+                client_first = manager._get_managed_identity_client(mock_credentials)
+                client_second = manager._get_managed_identity_client(mock_credentials)
+
+        # ManagedIdentityClient should only be constructed once
+        mock_mi_client_class.assert_called_once()
+        assert client_first is client_second
+
+    @pytest.mark.asyncio
+    async def test_get_managed_identity_client_with_managed_identity_credentials(self):
+        """Test _get_managed_identity_client creates UserAssignedManagedIdentity for ManagedIdentityCredentials."""
+        mock_credentials = ManagedIdentityCredentials(
+            client_id="test-managed-identity-client-id",
+            tenant_id="test-tenant-id",
+        )
+
+        manager = TokenManager(credentials=mock_credentials)
+
+        with patch("microsoft_teams.apps.token_manager.ManagedIdentityClient") as mock_mi_client_class:
+            with patch("microsoft_teams.apps.token_manager.requests") as mock_requests:
+                mock_requests.Session.return_value = MagicMock()
+                mock_mi_client_class.return_value = MagicMock()
+                with patch("microsoft_teams.apps.token_manager.UserAssignedManagedIdentity") as mock_user_mi:
+                    mock_user_mi.return_value = MagicMock()
+
+                    manager._get_managed_identity_client(mock_credentials)
+
+                    mock_user_mi.assert_called_once_with(client_id="test-managed-identity-client-id")
+
+    @pytest.mark.asyncio
+    async def test_get_managed_identity_client_with_federated_system(self):
+        """Test _get_managed_identity_client uses SystemAssignedManagedIdentity for system managed_identity_type."""
+        mock_credentials = FederatedIdentityCredentials(
+            client_id="test-app-client-id",
+            managed_identity_type="system",
+            managed_identity_client_id=None,
+            tenant_id="test-tenant-id",
+        )
+
+        manager = TokenManager(credentials=mock_credentials)
+
+        with patch("microsoft_teams.apps.token_manager.ManagedIdentityClient") as mock_mi_client_class:
+            with patch("microsoft_teams.apps.token_manager.requests") as mock_requests:
+                mock_requests.Session.return_value = MagicMock()
+                mock_mi_client_class.return_value = MagicMock()
+                with patch("microsoft_teams.apps.token_manager.SystemAssignedManagedIdentity") as mock_system_mi:
+                    mock_system_mi.return_value = MagicMock()
+
+                    manager._get_managed_identity_client(mock_credentials)
+
+                    mock_system_mi.assert_called_once_with()
+
+    @pytest.mark.asyncio
+    async def test_get_managed_identity_client_with_federated_user(self):
+        """Test _get_managed_identity_client uses UserAssignedManagedIdentity with mi_client_id for user type."""
+        mock_credentials = FederatedIdentityCredentials(
+            client_id="test-app-client-id",
+            managed_identity_type="user",
+            managed_identity_client_id="mi-client",
+            tenant_id="test-tenant-id",
+        )
+
+        manager = TokenManager(credentials=mock_credentials)
+
+        with patch("microsoft_teams.apps.token_manager.ManagedIdentityClient") as mock_mi_client_class:
+            with patch("microsoft_teams.apps.token_manager.requests") as mock_requests:
+                mock_requests.Session.return_value = MagicMock()
+                mock_mi_client_class.return_value = MagicMock()
+                with patch("microsoft_teams.apps.token_manager.UserAssignedManagedIdentity") as mock_user_mi:
+                    mock_user_mi.return_value = MagicMock()
+
+                    manager._get_managed_identity_client(mock_credentials)
+
+                    mock_user_mi.assert_called_once_with(client_id="mi-client")
diff --git a/packages/apps/tests/test_token_validator.py b/packages/apps/tests/test_token_validator.py
index 24101f15..54a84ad3 100644
--- a/packages/apps/tests/test_token_validator.py
+++ b/packages/apps/tests/test_token_validator.py
@@ -58,21 +58,10 @@ def test_init(self):
         """Test TokenValidator initialization."""
         validator = TokenValidator.for_service("test-app-id")
 
-        assert validator.logger is not None
         assert validator.options.valid_issuers == ["https://api.botframework.com"]
         assert validator.options.valid_audiences == ["test-app-id", "api://test-app-id"]
         assert validator.options.jwks_uri == "https://login.botframework.com/v1/.well-known/keys"
 
-    def test_init_with_custom_logger(self):
-        """Test TokenValidator initialization with custom logger."""
-        mock_logger = MagicMock()
-        validator = TokenValidator.for_service("test-app-id", mock_logger)
-
-        assert validator.options.valid_issuers == ["https://api.botframework.com"]
-        assert validator.options.valid_audiences == ["test-app-id", "api://test-app-id"]
-        assert validator.options.jwks_uri == "https://login.botframework.com/v1/.well-known/keys"
-        assert validator.logger == mock_logger
-
     @pytest.mark.asyncio
     async def test_validate_token_success(self, validator, mock_signing_key, valid_payload):
         """Test successful token validation."""
diff --git a/packages/botbuilder/src/microsoft_teams/botbuilder/__init__.py b/packages/botbuilder/src/microsoft_teams/botbuilder/__init__.py
index 73a28a2d..6702d6c6 100644
--- a/packages/botbuilder/src/microsoft_teams/botbuilder/__init__.py
+++ b/packages/botbuilder/src/microsoft_teams/botbuilder/__init__.py
@@ -3,6 +3,10 @@
 Licensed under the MIT License.
 """
 
+import logging
+
 from .botbuilder_plugin import BotBuilderPlugin, BotBuilderPluginOptions
 
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
 __all__ = ["BotBuilderPlugin", "BotBuilderPluginOptions"]
diff --git a/packages/botbuilder/src/microsoft_teams/botbuilder/botbuilder_plugin.py b/packages/botbuilder/src/microsoft_teams/botbuilder/botbuilder_plugin.py
index ddc79f1f..8bba026f 100644
--- a/packages/botbuilder/src/microsoft_teams/botbuilder/botbuilder_plugin.py
+++ b/packages/botbuilder/src/microsoft_teams/botbuilder/botbuilder_plugin.py
@@ -4,19 +4,18 @@
 """
 
 import importlib.metadata
-from logging import Logger
+import logging
 from types import SimpleNamespace
-from typing import Annotated, Any, Optional, Unpack, cast
+from typing import Annotated, Optional, TypedDict, Unpack, cast
 
-from fastapi import HTTPException, Request, Response
 from microsoft_teams.api import Credentials
 from microsoft_teams.apps import (
     DependencyMetadata,
-    HttpPlugin,
-    LoggerDependencyOptions,
+    HttpServer,
     Plugin,
+    PluginBase,
 )
-from microsoft_teams.apps.http_plugin import HttpPluginOptions
+from microsoft_teams.apps.http import HttpRequest, HttpResponse
 
 from botbuilder.core import (
     ActivityHandler,
@@ -30,27 +29,29 @@
 
 version = importlib.metadata.version("microsoft-teams-botbuilder")
 
+logger = logging.getLogger(__name__)
+
 # Constants for app types
 SINGLE_TENANT = "singletenant"
 MULTI_TENANT = "multitenant"
 
 
-class BotBuilderPluginOptions(HttpPluginOptions, total=False):
+class BotBuilderPluginOptions(TypedDict, total=False):
     """Options for configuring the BotBuilder plugin."""
 
     handler: ActivityHandler
     adapter: CloudAdapter
 
 
-@Plugin(name="http", version=version, description="BotBuilder plugin for Microsoft Bot Framework integration")
-class BotBuilderPlugin(HttpPlugin):
+@Plugin(name="botbuilder", version=version, description="BotBuilder plugin for Microsoft Bot Framework integration")
+class BotBuilderPlugin(PluginBase):
     """
     BotBuilder plugin that provides Microsoft Bot Framework integration.
     """
 
     # Dependency injections
-    logger: Annotated[Logger, LoggerDependencyOptions()]
     credentials: Annotated[Optional[Credentials], DependencyMetadata(optional=True)]
+    http_server: Annotated[HttpServer, DependencyMetadata()]
 
     def __init__(self, **options: Unpack[BotBuilderPluginOptions]):
         """
@@ -59,16 +60,12 @@ def __init__(self, **options: Unpack[BotBuilderPluginOptions]):
         Args:
             options: Configuration options for the plugin
         """
-
+        super().__init__()
         self.handler: Optional[ActivityHandler] = options.get("handler")
         self.adapter: Optional[CloudAdapter] = options.get("adapter")
 
-        super().__init__(**options)
-
     async def on_init(self) -> None:
         """Initialize the plugin when the app starts."""
-        await super().on_init()
-
         if not self.adapter:
             # Extract credentials for Bot Framework authentication
             client_id: Optional[str] = None
@@ -90,49 +87,45 @@ async def on_init(self) -> None:
             bot_framework_auth = ConfigurationBotFrameworkAuthentication(configuration=config)
             self.adapter = CloudAdapter(bot_framework_auth)
 
-            self.logger.debug("BotBuilder plugin initialized successfully")
+            logger.debug("BotBuilder plugin initialized successfully")
 
-    async def on_activity_request(self, request: Request, response: Response) -> Any:
-        """
-        Handles an incoming activity.
+        # Register the messaging endpoint route via adapter (bypasses HttpServer's default route)
+        self.http_server.adapter.register_route("POST", self.http_server.messaging_endpoint, self._handle_activity)
 
-        Overrides the base HTTP plugin behavior to:
-        1. Process the activity using the Bot Framework adapter/handler.
-        2. Then pass the request to the Teams plugin pipeline (_handle_activity_request).
+    async def _handle_activity(self, request: HttpRequest) -> HttpResponse:
+        """
+        Handler for the messaging endpoint.
 
-        Returns the final HTTP response.
+        Runs Bot Framework CloudAdapter auth + handler first,
+        then routes through HttpServer.handle_request for SDK-level JWT validation and pipeline.
         """
         if not self.adapter:
             raise RuntimeError("plugin not registered")
 
+        body = request["body"]
+        headers = request["headers"]
+
         try:
-            # Parse activity data
-            body = await request.json()
+            # Parse activity from body
             activity_bf = cast(Activity, Activity().deserialize(body))
 
-            # A POST request must contain an Activity
             if not activity_bf.type:
-                raise HTTPException(status_code=400, detail="Missing activity type")
+                return HttpResponse(status=400, body={"detail": "Missing activity type"})
 
-            async def logic(turn_context: TurnContext):
+            async def logic(turn_context: TurnContext) -> None:
                 if not turn_context.activity.id:
                     return
-
                 # Handle activity with botframework handler
                 if self.handler:
                     await self.handler.on_turn(turn_context)
 
             # Grab the auth header from the inbound request
-            auth_header = request.headers["Authorization"] if "Authorization" in request.headers else ""
+            auth_header = headers.get("authorization") or headers.get("Authorization") or ""
             await self.adapter.process_activity(auth_header, activity_bf, logic)
 
-            # Call HTTP plugin to handle activity request
-            result = await self._handle_activity_request(request)
-            return self._handle_activity_response(response, result)
+            # Route through HttpServer for SDK auth + Teams pipeline
+            return await self.http_server.handle_request(request)
 
-        except HTTPException as http_err:
-            self.logger.error(f"HTTP error processing activity: {http_err}", exc_info=True)
-            raise
         except Exception as err:
-            self.logger.error(f"Error processing activity: {err}", exc_info=True)
-            raise HTTPException(status_code=500, detail=str(err)) from err
+            logger.error(f"Error processing activity: {err}", exc_info=True)
+            return HttpResponse(status=500, body={"detail": str(err)})
diff --git a/packages/botbuilder/tests/test_botbuilder_plugin.py b/packages/botbuilder/tests/test_botbuilder_plugin.py
index 463a2600..c0e18574 100644
--- a/packages/botbuilder/tests/test_botbuilder_plugin.py
+++ b/packages/botbuilder/tests/test_botbuilder_plugin.py
@@ -10,8 +10,9 @@
 from botbuilder.core import ActivityHandler, TurnContext
 from botbuilder.integration.aiohttp import CloudAdapter
 from botbuilder.schema import Activity
-from fastapi import HTTPException, Request, Response
 from microsoft_teams.api import Credentials
+from microsoft_teams.apps.http import HttpRequest, HttpResponse
+from microsoft_teams.apps.http.http_server import HttpServer
 from microsoft_teams.botbuilder import BotBuilderPlugin
 
 
@@ -23,21 +24,32 @@ def mock_logger(self):
         return MagicMock()
 
     @pytest.fixture
-    def plugin_without_adapter(self):
-        plugin = BotBuilderPlugin(skip_auth=True)
+    def mock_http_server(self):
+        server = MagicMock(spec=HttpServer)
+        server.adapter = MagicMock()
+        server.messaging_endpoint = "/api/messages"
+        server.handle_request = AsyncMock(return_value=HttpResponse(status=200, body=None))
+        return server
+
+    @pytest.fixture
+    def plugin_without_adapter(self, mock_http_server):
+        plugin = BotBuilderPlugin()
         plugin.credentials = MagicMock(spec=Credentials)
         plugin.credentials.client_id = "abc"
         plugin.credentials.client_secret = "secret"
         plugin.credentials.tenant_id = "tenant-123"
+        plugin.http_server = mock_http_server
+        plugin.logger = MagicMock()
         return plugin
 
     @pytest.fixture
-    def plugin_with_adapter(self) -> BotBuilderPlugin:
+    def plugin_with_adapter(self, mock_http_server) -> BotBuilderPlugin:
         adapter = MagicMock(spec=CloudAdapter)
-        plugin = BotBuilderPlugin(adapter=adapter, skip_auth=True)
-        plugin._handle_activity_request = AsyncMock(return_value="fake_result")  # pyright: ignore[reportPrivateUsage]
+        plugin = BotBuilderPlugin(adapter=adapter)
         handler = AsyncMock(spec=ActivityHandler)
         plugin.handler = handler
+        plugin.http_server = mock_http_server
+        plugin.logger = MagicMock()
         return plugin
 
     @pytest.mark.asyncio
@@ -57,9 +69,15 @@ async def test_on_init_creates_adapter_when_missing(self, plugin_without_adapter
             mock_adapter_class.assert_called_once()
             assert plugin_without_adapter.adapter == "mock_adapter"
 
+        # Should have registered route via http_server.adapter
+        plugin_without_adapter.http_server.adapter.register_route.assert_called_once()
+        call_args = plugin_without_adapter.http_server.adapter.register_route.call_args
+        assert call_args[0][0] == "POST"
+        assert call_args[0][1] == "/api/messages"
+
     @pytest.mark.asyncio
-    async def test_on_activity_request_calls_adapter_and_handler(self, plugin_with_adapter: BotBuilderPlugin):
-        # Mock request and response
+    async def test_handle_activity_calls_adapter_and_handler(self, plugin_with_adapter: BotBuilderPlugin):
+        """Test that _handle_activity calls adapter and handler."""
         activity_data = {
             "type": "message",
             "id": "activity-id",
@@ -68,22 +86,20 @@ async def test_on_activity_request_calls_adapter_and_handler(self, plugin_with_a
             "conversation": {"id": "conv1"},
             "serviceUrl": "https://service.url",
         }
-        request = AsyncMock(spec=Request)
-        request.json.return_value = activity_data
-        request.headers = {"Authorization": "Bearer token"}
 
-        response = MagicMock(spec=Response)
+        request = HttpRequest(
+            body=activity_data,
+            headers={"Authorization": "Bearer token"},
+        )
 
         # Mock adapter.process_activity to call logic with a mock TurnContext
-        async def fake_process_activity(auth_header, activity, logic):  # type: ignore
-            print("Inside fake_process_activity")
+        async def fake_process_activity(auth_header, activity, logic):
             await logic(MagicMock(spec=TurnContext))
 
         assert plugin_with_adapter.adapter is not None
-
         plugin_with_adapter.adapter.process_activity = AsyncMock(side_effect=fake_process_activity)
 
-        await plugin_with_adapter.on_activity_request(request, response)
+        result = await plugin_with_adapter._handle_activity(request)
 
         # Ensure adapter.process_activity called with correct auth and activity
         plugin_with_adapter.adapter.process_activity.assert_called_once()
@@ -92,22 +108,28 @@ async def fake_process_activity(auth_header, activity, logic):  # type: ignore
         assert isinstance(called_activity, Activity)
 
         # Ensure handler called via TurnContext
-        plugin_with_adapter.handler.on_turn.assert_awaited()  # type: ignore
+        plugin_with_adapter.handler.on_turn.assert_awaited()
+
+        # Should have routed through HttpServer.handle_request
+        plugin_with_adapter.http_server.handle_request.assert_awaited_once_with(request)
+
+        # Should return a valid HttpResponse
+        assert result["status"] == 200
 
     @pytest.mark.asyncio
-    async def test_on_activity_request_raises_http_exception_on_adapter_error(
-        self, plugin_with_adapter: BotBuilderPlugin
-    ):
+    async def test_handle_activity_returns_error_on_adapter_error(self, plugin_with_adapter: BotBuilderPlugin):
+        """Test that _handle_activity returns 500 on adapter error."""
         activity_data = {"type": "message", "id": "activity-id"}
-        request = AsyncMock(spec=Request)
-        request.json.return_value = activity_data
-        request.headers = {}
 
-        response = MagicMock(spec=Response)
-        assert plugin_with_adapter.adapter is not None
+        request = HttpRequest(
+            body=activity_data,
+            headers={},
+        )
 
+        assert plugin_with_adapter.adapter is not None
         plugin_with_adapter.adapter.process_activity = AsyncMock(side_effect=Exception("fail"))
 
-        with pytest.raises(HTTPException) as exc:
-            await plugin_with_adapter.on_activity_request(request, response)
-        assert exc.value.status_code == 500
+        result = await plugin_with_adapter._handle_activity(request)
+
+        assert result["status"] == 500
+        assert result["body"]["detail"] == "fail"
diff --git a/packages/cards/src/microsoft_teams/cards/__init__.py b/packages/cards/src/microsoft_teams/cards/__init__.py
index c357ff22..98a1850b 100644
--- a/packages/cards/src/microsoft_teams/cards/__init__.py
+++ b/packages/cards/src/microsoft_teams/cards/__init__.py
@@ -3,10 +3,14 @@
 Licensed under the MIT License.
 """
 
+import logging
+
 from . import actions
 from .actions import *  # noqa: F403
 from .core import *
 
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
 # Combine all exports from submodules
 __all__: list[str] = []
 __all__.extend(actions.__all__)
diff --git a/packages/common/README.md b/packages/common/README.md
index 8bb26557..1f733782 100644
--- a/packages/common/README.md
+++ b/packages/common/README.md
@@ -85,9 +85,26 @@ items = list_storage.items()
 
 ## Logging
 
+The SDK uses Python's standard `logging` module. The library doesn't configure logging - your application should.
+
 ```python
-from microsoft_teams.common import ConsoleLogger
+import logging
+
+# Configure logging once at application startup
+logging.getLogger().setLevel(logging.DEBUG)
+stream_handler = logging.StreamHandler()
+stream_handler.setFormatter(ConsoleFormatter())
+logging.getLogger().addHandler(stream_handler)
 
-# Create console logger
-logger = ConsoleLogger().create_logger("my-app")
+# Use module-level loggers in your code
+logger = logging.getLogger(__name__)
+logger.info("Application started")
 ```
+
+**Custom Filtering**
+
+The SDK provides optional filtering as well:
+
+```python
+stream_handler.addFilter(ConsoleFilter("microsoft_teams.*"))
+```
\ No newline at end of file
diff --git a/packages/common/src/microsoft_teams/common/__init__.py b/packages/common/src/microsoft_teams/common/__init__.py
index 17d17ab9..b833f5b6 100644
--- a/packages/common/src/microsoft_teams/common/__init__.py
+++ b/packages/common/src/microsoft_teams/common/__init__.py
@@ -3,14 +3,19 @@
 Licensed under the MIT License.
 """
 
+import logging as _logging
+
 from . import events, http, logging, storage  # noqa: E402
 from .events import *  # noqa: F401, F402, F403
+from .experimental import ExperimentalWarning, experimental
 from .http import *  # noqa: F401, F402, F403
 from .logging import *  # noqa: F401, F402, F403
 from .storage import *  # noqa: F401, F402, F403
 
+_logging.getLogger(__name__).addHandler(_logging.NullHandler())
+
 # Combine all exports from submodules
-__all__: list[str] = []
+__all__: list[str] = ["ExperimentalWarning", "experimental"]
 __all__.extend(events.__all__)
 __all__.extend(http.__all__)
 __all__.extend(logging.__all__)
diff --git a/packages/common/src/microsoft_teams/common/events/__init__.py b/packages/common/src/microsoft_teams/common/events/__init__.py
index 4bbb2ea7..1e9c7fce 100644
--- a/packages/common/src/microsoft_teams/common/events/__init__.py
+++ b/packages/common/src/microsoft_teams/common/events/__init__.py
@@ -3,6 +3,6 @@
 Licensed under the MIT License.
 """
 
-from .event_emitter import EventEmitter, EventEmitterOptions, EventEmitterProtocol, EventHandler
+from .event_emitter import EventEmitter, EventEmitterProtocol, EventHandler
 
-__all__ = ["EventEmitter", "EventEmitterOptions", "EventHandler", "EventEmitterProtocol"]
+__all__ = ["EventEmitter", "EventHandler", "EventEmitterProtocol"]
diff --git a/packages/common/src/microsoft_teams/common/events/event_emitter.py b/packages/common/src/microsoft_teams/common/events/event_emitter.py
index f83234e6..36a92245 100644
--- a/packages/common/src/microsoft_teams/common/events/event_emitter.py
+++ b/packages/common/src/microsoft_teams/common/events/event_emitter.py
@@ -8,10 +8,10 @@
 import logging
 from typing import Any, Awaitable, Callable, Dict, Generic, List, Optional, Protocol, TypedDict, TypeVar, Union
 
-from ..logging import ConsoleLogger
-
 EventTypeT = TypeVar("EventTypeT", bound=str, contravariant=True)
 
+logger = logging.getLogger(__name__)
+
 EventHandler = Union[
     Callable[[Any], None],  # Sync handler
     Callable[[Any], Awaitable[Any]],  # Async handler
@@ -43,16 +43,6 @@ def emit(self, event: EventTypeT, value: Any = None) -> None:
         """Emit an event synchronously."""
 
 
-class EventEmitterOptions(TypedDict, total=False):
-    """
-    Options for EventEmitter configuration.
-
-    :param logger: Custom logger instance to use for logging events
-    """
-
-    logger: logging.Logger
-
-
 class EventEmitter(EventEmitterProtocol[EventTypeT]):
     """
     Event emitter implementation inspired by TypeScript/Node.js EventEmitter.
@@ -61,17 +51,10 @@ class EventEmitter(EventEmitterProtocol[EventTypeT]):
     Thread-safe for single-threaded use cases.
     """
 
-    def __init__(self, options: Optional[EventEmitterOptions] = None) -> None:
+    def __init__(self) -> None:
         self._index = -1
         self._subscriptions: Dict[str, List[Subscription]] = {}
 
-        # Use provided logger or create default console logger
-        logger = options.get("logger") if options else None
-        if logger:
-            self._logger = logger.getChild("microsoft_teams.common.events.EventEmitter")
-        else:
-            self._logger = ConsoleLogger().create_logger("microsoft_teams.common.events.EventEmitter")
-
     def on(self, event: EventTypeT, handler: EventHandler) -> int:
         """
         Register an event handler.
@@ -90,7 +73,7 @@ def on(self, event: EventTypeT, handler: EventHandler) -> int:
 
         self._subscriptions[event].append({"id": subscription_id, "handler": handler})
 
-        self._logger.debug("Registered handler for event '%s' with id %d", event, subscription_id)
+        logger.debug("Registered handler for event '%s' with id %d", event, subscription_id)
         return subscription_id
 
     def once(self, event: EventTypeT, handler: EventHandler) -> int:
@@ -123,7 +106,7 @@ def once_wrapper(value: Any) -> None:
 
         self._subscriptions[event].append({"id": subscription_id, "handler": once_wrapper})
 
-        self._logger.debug("Registered one-time handler for event '%s' with id %d", event, subscription_id)
+        logger.debug("Registered one-time handler for event '%s' with id %d", event, subscription_id)
         return subscription_id
 
     def off(self, subscription_id: int) -> None:
@@ -137,7 +120,7 @@ def off(self, subscription_id: int) -> None:
             for i, subscription in enumerate(subscriptions):
                 if subscription["id"] == subscription_id:
                     subscriptions.pop(i)
-                    self._logger.debug("Removed handler with id %d from event '%s'", subscription_id, event_name)
+                    logger.debug("Removed handler with id %d from event '%s'", subscription_id, event_name)
                     if not subscriptions:
                         del self._subscriptions[event_name]
                     return
@@ -156,7 +139,7 @@ def emit(self, event: EventTypeT, value: Any = None) -> None:
             return
 
         handler_count = len(self._subscriptions[event])
-        self._logger.debug("Emitting event '%s' to %d handler(s)", event, handler_count)
+        logger.debug("Emitting event '%s' to %d handler(s)", event, handler_count)
 
         awaitables: list[Awaitable[None]] = []
 
@@ -170,17 +153,17 @@ def emit(self, event: EventTypeT, value: Any = None) -> None:
                     handler(value)
             except Exception as e:
                 # Continue executing other handlers even if one fails
-                self._logger.error("Handler failed for event '%s': %s", event, e)
+                logger.error("Handler failed for event '%s': %s", event, e)
 
         # Handle awaitables if any exist
         if awaitables:
-            self._logger.debug("Running %d async handler(s) for event '%s'", len(awaitables), event)
+            logger.debug("Running %d async handler(s) for event '%s'", len(awaitables), event)
 
             async def run_async_handlers() -> None:
                 results = await asyncio.gather(*awaitables, return_exceptions=True)
                 for i, result in enumerate(results):
                     if isinstance(result, Exception):
-                        self._logger.error("Async handler %d failed for event '%s': %s", i, event, result)
+                        logger.error("Async handler %d failed for event '%s': %s", i, event, result)
 
             try:
                 # Try to get the current event loop
@@ -223,11 +206,11 @@ def remove_all_listeners(self, event: Optional[str] = None) -> None:
         if event is None:
             total_handlers = sum(len(handlers) for handlers in self._subscriptions.values())
             self._subscriptions.clear()
-            self._logger.debug("Removed all %d handler(s) from all events", total_handlers)
+            logger.debug("Removed all %d handler(s) from all events", total_handlers)
         elif event in self._subscriptions:
             handler_count = len(self._subscriptions[event])
             del self._subscriptions[event]
-            self._logger.debug("Removed all %d handler(s) from event '%s'", handler_count, event)
+            logger.debug("Removed all %d handler(s) from event '%s'", handler_count, event)
 
     def _get_next_id(self) -> int:
         """Get next unique subscription ID."""
diff --git a/packages/common/src/microsoft_teams/common/experimental.py b/packages/common/src/microsoft_teams/common/experimental.py
new file mode 100644
index 00000000..49002b05
--- /dev/null
+++ b/packages/common/src/microsoft_teams/common/experimental.py
@@ -0,0 +1,76 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+import functools
+import inspect
+import warnings
+from typing import Any, Callable, Optional, TypeVar
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+class ExperimentalWarning(FutureWarning):
+    """Warning category for Teams SDK preview APIs.
+
+    Preview APIs may change in the future.
+    """
+
+    pass
+
+
+def experimental(diagnostic: str, *, message: Optional[str] = None) -> Callable[[F], F]:
+    """Mark a class or function as a preview API.
+
+    Emits an ExperimentalWarning when the decorated class is instantiated
+    or the decorated function is called.
+
+    Args:
+        diagnostic: The diagnostic code (e.g., "ExperimentalTeamsReactions") for granular opt-in.
+        message: Optional custom warning message. If not provided, a default message is used.
+
+    Usage::
+
+        @experimental("ExperimentalTeamsReactions")
+        class ReactionClient:
+            ...
+
+        @experimental("ExperimentalTeamsTargeted", message="Targeted messages are in preview.")
+        async def create_targeted(...):
+            ...
+    """
+
+    def decorator(obj: F) -> F:
+        name = getattr(obj, "__qualname__", getattr(obj, "__name__", str(obj)))
+        warn_msg = message or (f"{name} is in preview and may change in the future. Diagnostic: {diagnostic}")
+
+        if isinstance(obj, type):
+            original_init = obj.__init__
+
+            @functools.wraps(original_init)
+            def new_init(self: Any, *args: Any, **kwargs: Any) -> None:
+                warnings.warn(warn_msg, ExperimentalWarning, stacklevel=2)
+                original_init(self, *args, **kwargs)
+
+            obj.__init__ = new_init  # type: ignore[misc]
+            return obj  # type: ignore[return-value]
+        else:
+            if inspect.iscoroutinefunction(obj):
+
+                @functools.wraps(obj)
+                async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+                    warnings.warn(warn_msg, ExperimentalWarning, stacklevel=2)
+                    return await obj(*args, **kwargs)
+
+                return async_wrapper  # type: ignore[return-value]
+            else:
+
+                @functools.wraps(obj)
+                def wrapper(*args: Any, **kwargs: Any) -> Any:
+                    warnings.warn(warn_msg, ExperimentalWarning, stacklevel=2)
+                    return obj(*args, **kwargs)
+
+                return wrapper  # type: ignore[return-value]
+
+    return decorator
diff --git a/packages/common/src/microsoft_teams/common/http/client.py b/packages/common/src/microsoft_teams/common/http/client.py
index 9d0b53fc..50ac6677 100644
--- a/packages/common/src/microsoft_teams/common/http/client.py
+++ b/packages/common/src/microsoft_teams/common/http/client.py
@@ -13,14 +13,13 @@
 from httpx._models import Request, Response
 from httpx._types import QueryParamTypes, RequestContent, RequestData, RequestFiles
 
-from ..logging import ConsoleLogger
 from .client_token import Token, resolve_token
 from .interceptor import Interceptor, InterceptorRequestContext, InterceptorResponseContext
 
-console_logger = ConsoleLogger()
+logger = logging.getLogger(__name__)
 
 
-def _wrap_response_json(response: httpx.Response, logger: logging.Logger) -> None:
+def _wrap_response_json(response: httpx.Response) -> None:
     """
     Wrap the response.json method to handle JSONDecodeError gracefully.
 
@@ -52,7 +51,6 @@ class ClientOptions:
         base_url: The base URL for all requests.
         headers: Default headers to include with every request.
         timeout: Default request timeout in seconds.
-        logger: Logger instance for request/response/error logging.
         token: Default authorization token (string, string-like, or callable).
         interceptors: List of interceptors for request/response middleware.
     """
@@ -60,7 +58,6 @@ class ClientOptions:
     base_url: Optional[str] = None
     headers: Dict[str, str] = field(default_factory=dict[str, str])
     timeout: Optional[float] = None
-    logger: Optional[logging.Logger] = None
     token: Optional[Token] = None
     interceptors: Optional[List[Interceptor]] = field(default_factory=list[Interceptor])
 
@@ -84,12 +81,9 @@ def __init__(self, options: Optional[ClientOptions] = None):
             options = ClientOptions()
 
         self._options = options
-        self._logger = options.logger or console_logger.create_logger("http-client")
         self._token = options.token
-
-        # Configure httpx logging to match our logger's level
         httpx_logger = logging.getLogger("httpx")
-        httpx_logger.setLevel(self._logger.level)
+        httpx_logger.setLevel(logger.level)
 
         # Maintain interceptors as a separate instance attribute (do not mutate options)
         self._interceptors = list(options.interceptors or [])
@@ -143,7 +137,7 @@ async def get(
         req_headers = await self._prepare_headers(headers, token)
         response = await self.http.get(url, headers=req_headers, params=params, **kwargs)
         response.raise_for_status()
-        _wrap_response_json(response, self._logger)
+        _wrap_response_json(response)
         return response
 
     async def post(
@@ -188,7 +182,7 @@ async def post(
             **kwargs,
         )
         response.raise_for_status()
-        _wrap_response_json(response, self._logger)
+        _wrap_response_json(response)
         return response
 
     async def put(
@@ -233,7 +227,7 @@ async def put(
             **kwargs,
         )
         response.raise_for_status()
-        _wrap_response_json(response, self._logger)
+        _wrap_response_json(response)
         return response
 
     async def patch(
@@ -278,7 +272,7 @@ async def patch(
             **kwargs,
         )
         response.raise_for_status()
-        _wrap_response_json(response, self._logger)
+        _wrap_response_json(response)
         return response
 
     async def delete(
@@ -306,7 +300,7 @@ async def delete(
         req_headers = await self._prepare_headers(headers, token)
         response = await self.http.delete(url, headers=req_headers, params=params, **kwargs)
         response.raise_for_status()
-        _wrap_response_json(response, self._logger)
+        _wrap_response_json(response)
         return response
 
     async def request(
@@ -354,7 +348,7 @@ async def request(
             **kwargs,
         )
         response.raise_for_status()
-        _wrap_response_json(response, self._logger)
+        _wrap_response_json(response)
         return response
 
     async def _resolve_token(self, token: Optional[Token]) -> Optional[str]:
@@ -392,7 +386,7 @@ def _update_event_hooks(self) -> None:
 
                 def _make_request_wrapper(h: Interceptor) -> Callable[[Request], Awaitable[None]]:
                     async def wrapper(request: Request) -> None:
-                        ctx = InterceptorRequestContext(request, self._logger)
+                        ctx = InterceptorRequestContext(request)
                         result = h.request(ctx)
                         if inspect.isawaitable(result):
                             await result
@@ -404,7 +398,7 @@ async def wrapper(request: Request) -> None:
 
                 def _make_response_wrapper(h: Interceptor) -> Callable[[Response], Awaitable[None]]:
                     async def wrapper(response: Response) -> None:
-                        ctx = InterceptorResponseContext(response, self._logger)
+                        ctx = InterceptorResponseContext(response)
                         result = h.response(ctx)
                         if inspect.isawaitable(result):
                             await result
@@ -429,7 +423,6 @@ def clone(self, overrides: Optional[ClientOptions] = None) -> "Client":
             base_url=overrides.base_url if overrides.base_url is not None else self._options.base_url,
             headers={**self._options.headers, **(overrides.headers or {})},
             timeout=overrides.timeout if overrides.timeout is not None else self._options.timeout,
-            logger=overrides.logger if overrides.logger is not None else self._options.logger,
             token=overrides.token if overrides.token is not None else self._options.token,
             interceptors=list(overrides.interceptors)
             if overrides.interceptors is not None
diff --git a/packages/common/src/microsoft_teams/common/http/interceptor.py b/packages/common/src/microsoft_teams/common/http/interceptor.py
index 625a5108..21d6d791 100644
--- a/packages/common/src/microsoft_teams/common/http/interceptor.py
+++ b/packages/common/src/microsoft_teams/common/http/interceptor.py
@@ -3,7 +3,6 @@
 Licensed under the MIT License.
 """
 
-import logging
 from typing import Any, Awaitable, Callable, TypeVar, Union
 
 from httpx import Request, Response
@@ -13,15 +12,13 @@
 
 
 class InterceptorRequestContext:
-    def __init__(self, request: Request, log: logging.Logger):
+    def __init__(self, request: Request):
         self.request = request
-        self.log = log
 
 
 class InterceptorResponseContext:
-    def __init__(self, response: Response, log: logging.Logger):
+    def __init__(self, response: Response):
         self.response = response
-        self.log = log
 
 
 RequestInterceptor = Callable[[InterceptorRequestContext], Union[Any, Awaitable[Any]]]
diff --git a/packages/common/src/microsoft_teams/common/logging/__init__.py b/packages/common/src/microsoft_teams/common/logging/__init__.py
index 8b854c6f..9604bcff 100644
--- a/packages/common/src/microsoft_teams/common/logging/__init__.py
+++ b/packages/common/src/microsoft_teams/common/logging/__init__.py
@@ -4,8 +4,7 @@
 """
 
 from .ansi import ANSI
-from .console import ConsoleLogger, ConsoleLoggerOptions
 from .filter import ConsoleFilter
 from .formatter import ConsoleFormatter
 
-__all__ = ["ANSI", "ConsoleLogger", "ConsoleFormatter", "ConsoleFilter", "ConsoleLoggerOptions"]
+__all__ = ["ANSI", "ConsoleFormatter", "ConsoleFilter"]
diff --git a/packages/common/src/microsoft_teams/common/logging/console.py b/packages/common/src/microsoft_teams/common/logging/console.py
deleted file mode 100644
index 7a99e8a5..00000000
--- a/packages/common/src/microsoft_teams/common/logging/console.py
+++ /dev/null
@@ -1,56 +0,0 @@
-"""
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the MIT License.
-"""
-
-import logging
-import os
-from typing import Optional, TypedDict
-
-from .filter import ConsoleFilter
-from .formatter import ConsoleFormatter
-
-
-class ConsoleLoggerOptions(TypedDict, total=False):
-    """
-    ConsoleLoggerOptions is a dictionary that contains the options for the ConsoleLogger.
-
-    :param level: The level of the logger (error, warn, info, debug)
-    :param pattern: The pattern of the logger (e.g. "my_module.*")
-    """
-
-    level: str
-    pattern: str
-
-
-class ConsoleLogger:
-    """
-    ConsoleLogger is a class that creates a logger for the console.
-    """
-
-    _levels = {"error": logging.ERROR, "warn": logging.WARNING, "info": logging.INFO, "debug": logging.DEBUG}
-
-    def create_logger(self, name: str, options: Optional[ConsoleLoggerOptions] = None) -> logging.Logger:
-        """
-        Create a logger for the console.
-
-        :param name: The name of the logger
-        :param options: The options for the logger
-        """
-
-        logger = logging.getLogger(name)
-        logger.handlers = []
-
-        handler = logging.StreamHandler()
-        handler.setFormatter(ConsoleFormatter())
-        logger.addHandler(handler)
-
-        options_level = options.get("level", "info") if options else "info"
-        level = (os.environ.get("LOG_LEVEL") or options_level).lower()
-        logger.setLevel(self._levels.get(level, logging.INFO))
-
-        options_pattern = options.get("pattern", "*") if options else "*"
-        pattern = os.environ.get("LOG") or options_pattern
-        logger.addFilter(ConsoleFilter(pattern))
-
-        return logger
diff --git a/packages/common/tests/test_backward_compat.py b/packages/common/tests/test_backward_compat.py
index a621439f..6e124d36 100644
--- a/packages/common/tests/test_backward_compat.py
+++ b/packages/common/tests/test_backward_compat.py
@@ -11,12 +11,12 @@ def test_old_import_shows_deprecation_warning():
     with warnings.catch_warnings(record=True) as w:
         warnings.simplefilter("always")
 
-        from microsoft.teams.common import ConsoleLogger
+        from microsoft.teams.common import Client
 
         assert len(w) >= 1
         assert any(issubclass(warning.category, DeprecationWarning) for warning in w)
         assert "deprecated" in str(w[0].message).lower()
-        assert ConsoleLogger is not None
+        assert Client is not None
 
 
 def test_new_import_no_warning():
@@ -24,20 +24,23 @@ def test_new_import_no_warning():
     with warnings.catch_warnings(record=True) as w:
         warnings.simplefilter("always")
 
-        from microsoft_teams.common import ConsoleLogger
+        from microsoft_teams.common import Client
 
         # No warnings expected
         assert len(w) == 0
-        assert ConsoleLogger is not None
+        assert Client is not None
 
 
 def test_both_namespaces_same_class():
     """Old and new imports reference the same class"""
-    from microsoft.teams.common import ConsoleLogger as OldLogger
-    from microsoft_teams.common import ConsoleLogger as NewLogger
+    with warnings.catch_warnings(record=True):
+        warnings.simplefilter("always")
+
+        from microsoft.teams.common import Client as OldClient
+        from microsoft_teams.common import Client as NewClient
 
-    assert OldLogger is NewLogger
-    assert id(OldLogger) == id(NewLogger)
+        assert OldClient is NewClient
+        assert id(OldClient) == id(NewClient)
 
 
 def test_new_import_from_submodule():
@@ -66,7 +69,7 @@ def test_deprecation_warning_message_content():
     with warnings.catch_warnings(record=True) as w:
         warnings.simplefilter("always")
 
-        from microsoft.teams.common import ConsoleLogger  # noqa: F401
+        from microsoft.teams.common import Client  # noqa: F401
 
         assert len(w) >= 1, f"Expected deprecation warning, got {len(w)} warnings"
         warning_msg = str(w[0].message)
@@ -86,9 +89,8 @@ def test_deprecation_warning_message_content():
 
 def test_old_namespace_exports_all():
     """Old namespace exports all classes from new namespace"""
-    from microsoft.teams.common import Client, ConsoleLogger, EventEmitter
+    from microsoft.teams.common import Client, EventEmitter
 
     # All exports should work
-    assert ConsoleLogger is not None
     assert Client is not None
     assert EventEmitter is not None
diff --git a/packages/common/tests/test_experimental.py b/packages/common/tests/test_experimental.py
new file mode 100644
index 00000000..442b3552
--- /dev/null
+++ b/packages/common/tests/test_experimental.py
@@ -0,0 +1,88 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+import asyncio
+import warnings
+
+from microsoft_teams.common.experimental import ExperimentalWarning, experimental
+
+
+@experimental("TEST001")
+class _PreviewClass:
+    def __init__(self, value: str):
+        self.value = value
+
+
+@experimental("TEST002")
+def _preview_sync_func(x: int) -> int:
+    return x * 2
+
+
+@experimental("TEST003")
+async def _preview_async_func(x: int) -> int:
+    return x * 3
+
+
+class TestExperimentalWarning:
+    def test_class_instantiation_emits_warning(self):
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            obj = _PreviewClass("test")
+            assert len(w) == 1
+            assert issubclass(w[0].category, ExperimentalWarning)
+            assert "TEST001" in str(w[0].message)
+            assert "preview" in str(w[0].message).lower()
+            assert obj.value == "test"
+
+    def test_sync_function_emits_warning(self):
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            result = _preview_sync_func(5)
+            assert len(w) == 1
+            assert issubclass(w[0].category, ExperimentalWarning)
+            assert "TEST002" in str(w[0].message)
+            assert result == 10
+
+    def test_async_function_emits_warning(self):
+        async def _run() -> int:
+            return await _preview_async_func(5)
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            result = asyncio.run(_run())
+            assert len(w) == 1
+            assert issubclass(w[0].category, ExperimentalWarning)
+            assert "TEST003" in str(w[0].message)
+            assert result == 15
+
+    def test_warning_is_suppressible(self):
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings("ignore", category=ExperimentalWarning)
+            _PreviewClass("suppressed")
+            assert len(w) == 0
+
+    def test_warning_is_suppressible_by_message(self):
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings("ignore", message=".*TEST001.*", category=ExperimentalWarning)
+            _PreviewClass("suppressed")
+            result = _preview_sync_func(5)
+            assert len(w) == 1  # only TEST002 warning, not TEST001
+            assert "TEST002" in str(w[0].message)
+            assert result == 10
+
+    def test_custom_message(self):
+        @experimental("CUSTOM", message="Custom preview message.")
+        def custom_func() -> str:
+            return "ok"
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            result = custom_func()
+            assert len(w) == 1
+            assert str(w[0].message) == "Custom preview message."
+            assert result == "ok"
+
+    def test_warning_is_future_warning_subclass(self):
+        assert issubclass(ExperimentalWarning, FutureWarning)
diff --git a/packages/devtools/src/microsoft_teams/devtools/__init__.py b/packages/devtools/src/microsoft_teams/devtools/__init__.py
index 4198a0f2..e41d9d78 100644
--- a/packages/devtools/src/microsoft_teams/devtools/__init__.py
+++ b/packages/devtools/src/microsoft_teams/devtools/__init__.py
@@ -3,7 +3,11 @@
 Licensed under the MIT License.
 """
 
+import logging
+
 from .devtools_plugin import DevToolsPlugin
 from .page import Page
 
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
 __all__: list[str] = ["DevToolsPlugin", "Page"]
diff --git a/packages/devtools/src/microsoft_teams/devtools/devtools_plugin.py b/packages/devtools/src/microsoft_teams/devtools/devtools_plugin.py
index 51b4e947..ff75aaf7 100644
--- a/packages/devtools/src/microsoft_teams/devtools/devtools_plugin.py
+++ b/packages/devtools/src/microsoft_teams/devtools/devtools_plugin.py
@@ -5,10 +5,10 @@
 
 import asyncio
 import importlib.metadata
+import logging
 import os
 from contextlib import asynccontextmanager
 from datetime import datetime
-from logging import Logger
 from typing import Annotated, Any, AsyncGenerator, Awaitable, Callable, Dict, List, Optional
 from uuid import uuid4
 
@@ -16,22 +16,20 @@
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect
 from fastapi.routing import APIRouter
 from fastapi.staticfiles import StaticFiles
-from microsoft_teams.api import Activity, ActivityParams, ConversationReference, SentActivity, TokenProtocol
+from microsoft_teams.api import Activity, TokenProtocol
 from microsoft_teams.apps import (
     ActivityEvent,
+    CoreActivity,
     DependencyMetadata,
     ErrorEvent,
     EventMetadata,
-    HttpPlugin,
-    LoggerDependencyOptions,
     Plugin,
     PluginActivityEvent,
     PluginActivityResponseEvent,
     PluginActivitySentEvent,
+    PluginBase,
     PluginErrorEvent,
     PluginStartEvent,
-    Sender,
-    StreamerProtocol,
 )
 
 from .event import DevToolsActivityEvent, DevToolsActivityReceivedEvent, DevToolsActivitySentEvent
@@ -40,16 +38,16 @@
 
 version = importlib.metadata.version("microsoft-teams-devtools")
 
+logger = logging.getLogger(__name__)
+
 
 @Plugin(
     name="devtools",
     version=version,
     description="set of tools to make development of Teams apps faster and simpler",
 )
-class DevToolsPlugin(Sender):
-    logger: Annotated[Logger, LoggerDependencyOptions()]
+class DevToolsPlugin(PluginBase):
     id: Annotated[Optional[TokenProtocol], DependencyMetadata(optional=True)]
-    http: Annotated[HttpPlugin, DependencyMetadata()]
 
     on_error_event: Annotated[Callable[[ErrorEvent], None], EventMetadata(name="error")]
     on_activity_event: Annotated[Callable[[ActivityEvent], None], EventMetadata(name="activity")]
@@ -65,12 +63,12 @@ def __init__(self):
         @asynccontextmanager
         async def lifespan(_app: FastAPI) -> AsyncGenerator[None, None]:
             # Startup
-            self.logger.info(f"listening on port {self._port} 🚀")
+            logger.info(f"listening on port {self._port} 🚀")
             if self._on_ready_callback:
                 await self._on_ready_callback()
             yield
             # Shutdown
-            self.logger.info("Server shutting down")
+            logger.info("Server shutting down")
             if self._on_stopped_callback:
                 await self._on_stopped_callback()
 
@@ -83,7 +81,7 @@ async def lifespan(_app: FastAPI) -> AsyncGenerator[None, None]:
 
         @self.app.websocket("/devtools/sockets")
         async def websocket_endpoint(websocket: WebSocket):  # type: ignore
-            self.logger.info(f"WebSocket connection initiated with scope type: {websocket.scope['type']}")
+            logger.info(f"WebSocket connection initiated with scope type: {websocket.scope['type']}")
             await self.on_socket_connection(websocket)
 
         dist = os.path.join(os.path.dirname(__file__), "web")
@@ -116,7 +114,7 @@ def on_stopped_callback(self, callback: Optional[Callable[[], Awaitable[None]]])
         self._on_stopped_callback = callback
 
     async def on_init(self) -> None:
-        self.logger.warning("⚠️ Devtools is not secure and should not be used in production environments ⚠️")
+        logger.warning("⚠️ Devtools is not secure and should not be used in production environments ⚠️")
 
     async def on_start(self, event: PluginStartEvent) -> None:
         self._port = event.port + 1
@@ -129,7 +127,10 @@ async def process(token: TokenProtocol, activity: Activity):
                 if activity.id:
                     self.pending[activity.id] = response_future
                 try:
-                    result = self.on_activity_event(ActivityEvent(token=token, activity=activity, sender=self.http))
+                    # Convert Activity to CoreActivity
+                    activity_dict = activity.model_dump(by_alias=True, exclude_none=True)
+                    core_activity = CoreActivity.model_validate(activity_dict)
+                    result = self.on_activity_event(ActivityEvent(body=core_activity, token=token))
                     # If the handler is a coroutine, schedule it
                     if asyncio.iscoroutine(result):
                         asyncio.create_task(result)
@@ -141,13 +142,13 @@ async def process(token: TokenProtocol, activity: Activity):
                         del self.pending[activity.id]
                 return result
 
-            router.include_router(get_router(RouteContext(port=self._port, log=self.logger, process=process)))
+            router.include_router(get_router(RouteContext(port=self._port, process=process)))
             self.app.include_router(router)
 
             config = uvicorn.Config(app=self.app, host="0.0.0.0", port=self._port, log_level="info")
             self._server = uvicorn.Server(config)
 
-            self.logger.info(f"available at http://localhost:{self._port}/devtools")
+            logger.info(f"available at http://localhost:{self._port}/devtools")
 
             # The lifespan handler will call the callback when the server is ready
             await self._server.serve()
@@ -155,11 +156,11 @@ async def process(token: TokenProtocol, activity: Activity):
         except OSError as error:
             # Handle port in use, permission errors, etc.
             await self.on_error(PluginErrorEvent(error=error))
-            self.logger.error("Server startup failed: %s", error)
+            logger.error("Server startup failed: %s", error)
             raise
         except Exception as error:
             await self.on_error(PluginErrorEvent(error=error))
-            self.logger.error("Failed to start server: %s", error)
+            logger.error("Failed to start server: %s", error)
             raise
 
     async def on_socket_connection(self, websocket: WebSocket):
@@ -185,16 +186,16 @@ async def on_socket_connection(self, websocket: WebSocket):
             while True:
                 try:
                     data = await websocket.receive_text()
-                    self.logger.debug(f"Received WebSocket message: {data}")
+                    logger.debug(f"Received WebSocket message: {data}")
                 except WebSocketDisconnect:
-                    self.logger.debug(f"WebSocket {socket_id} disconnected")
+                    logger.debug(f"WebSocket {socket_id} disconnected")
                     break
         finally:
             del self.sockets[socket_id]
 
     async def on_activity(self, event: PluginActivityEvent):
         """Handle incoming activities."""
-        self.logger.debug("Activity received in on_activity")
+        logger.debug("Activity received in on_activity")
 
         activity = DevToolsActivityReceivedEvent(
             id=str(uuid4()),
@@ -208,7 +209,7 @@ async def on_activity(self, event: PluginActivityEvent):
 
     async def on_activity_sent(self, event: PluginActivitySentEvent):
         """Handle sent activities."""
-        self.logger.debug(f"Activity sent: {event.activity}")
+        logger.debug(f"Activity sent: {event.activity}")
 
         activity = DevToolsActivitySentEvent(
             id=str(uuid4()),
@@ -227,19 +228,13 @@ async def on_activity_response(self, event: PluginActivityResponseEvent):
                 promise.set_result(event.response)
                 del self.pending[event.activity.id]
 
-    async def send(self, activity: ActivityParams, ref: ConversationReference) -> SentActivity:
-        return await self.http.send(activity, ref)
-
-    def create_stream(self, ref: ConversationReference) -> StreamerProtocol:
-        return self.http.create_stream(ref)
-
     async def emit_activity_to_sockets(self, event: DevToolsActivityEvent):
         data = event.model_dump(mode="json", exclude_none=True)
         for socket_id, websocket in self.sockets.items():
             try:
                 await websocket.send_json(data)
             except WebSocketDisconnect:
-                self.logger.debug(f"WebSocket {socket_id} disconnected")
+                logger.debug(f"WebSocket {socket_id} disconnected")
                 del self.sockets[socket_id]
 
     def add_page(self, page: Page) -> "DevToolsPlugin":
diff --git a/packages/devtools/src/microsoft_teams/devtools/routes/context.py b/packages/devtools/src/microsoft_teams/devtools/routes/context.py
index 91e30a12..58177228 100644
--- a/packages/devtools/src/microsoft_teams/devtools/routes/context.py
+++ b/packages/devtools/src/microsoft_teams/devtools/routes/context.py
@@ -4,7 +4,6 @@
 """
 
 from dataclasses import dataclass
-from logging import Logger
 from typing import Any, Awaitable, Callable
 
 from microsoft_teams.api import Activity, InvokeResponse, TokenProtocol
@@ -13,5 +12,4 @@
 @dataclass
 class RouteContext:
     port: int
-    log: Logger
     process: Callable[[TokenProtocol, Activity], Awaitable[InvokeResponse[Any]]]
diff --git a/packages/devtools/src/microsoft_teams/devtools/routes/router.py b/packages/devtools/src/microsoft_teams/devtools/routes/router.py
index 32bd399b..c1dcdf1a 100644
--- a/packages/devtools/src/microsoft_teams/devtools/routes/router.py
+++ b/packages/devtools/src/microsoft_teams/devtools/routes/router.py
@@ -11,7 +11,7 @@
 
 def get_router(context: RouteContext):
     router = APIRouter()
-    updated_context = RouteContext(port=context.port, log=context.log.getChild("v3"), process=context.process)
+    updated_context = RouteContext(port=context.port, process=context.process)
     res = v3_router(updated_context)
     router.include_router(res, prefix="/v3")
     return router
diff --git a/packages/devtools/src/microsoft_teams/devtools/routes/v3/conversations/activities/create.py b/packages/devtools/src/microsoft_teams/devtools/routes/v3/conversations/activities/create.py
index 9546e09f..159c5d4b 100644
--- a/packages/devtools/src/microsoft_teams/devtools/routes/v3/conversations/activities/create.py
+++ b/packages/devtools/src/microsoft_teams/devtools/routes/v3/conversations/activities/create.py
@@ -3,6 +3,7 @@
 Licensed under the MIT License.
 """
 
+import logging
 from typing import cast
 from uuid import uuid4
 
@@ -13,6 +14,8 @@
 
 from ....context import RouteContext
 
+logger = logging.getLogger(__name__)
+
 
 async def create(context: RouteContext):
     async def create_activity_endpoint(request: Request, response: Response):
@@ -51,7 +54,7 @@ async def create_activity_endpoint(request: Request, response: Response):
             return response
 
         except Exception as err:
-            context.log.error(err)
+            logger.error(err)
             raise HTTPException(status_code=500, detail=str(err)) from err
 
     return create_activity_endpoint
diff --git a/packages/devtools/src/microsoft_teams/devtools/routes/v3/conversations/activities/router.py b/packages/devtools/src/microsoft_teams/devtools/routes/v3/conversations/activities/router.py
index 0c1e152d..3df9249c 100644
--- a/packages/devtools/src/microsoft_teams/devtools/routes/v3/conversations/activities/router.py
+++ b/packages/devtools/src/microsoft_teams/devtools/routes/v3/conversations/activities/router.py
@@ -15,7 +15,7 @@ def get_router(context: RouteContext):
     # Define the POST route
     @router.post("")
     async def create_endpoint(request: Request, response: Response):  # type: ignore
-        updated_context = RouteContext(port=context.port, log=context.log.getChild("create"), process=context.process)
+        updated_context = RouteContext(port=context.port, process=context.process)
         handler = await create(updated_context)
         return await handler(request, response)
 
diff --git a/packages/devtools/src/microsoft_teams/devtools/routes/v3/conversations/router.py b/packages/devtools/src/microsoft_teams/devtools/routes/v3/conversations/router.py
index 95bffd6e..2cc8c1f8 100644
--- a/packages/devtools/src/microsoft_teams/devtools/routes/v3/conversations/router.py
+++ b/packages/devtools/src/microsoft_teams/devtools/routes/v3/conversations/router.py
@@ -11,7 +11,7 @@
 
 def get_router(ctx: RouteContext):
     router = APIRouter()
-    updated_context = RouteContext(port=ctx.port, log=ctx.log.getChild("activities"), process=ctx.process)
+    updated_context = RouteContext(port=ctx.port, process=ctx.process)
     res = activities_router(updated_context)
     router.include_router(res, prefix="/{conversationId}/activities")
     return router
diff --git a/packages/devtools/src/microsoft_teams/devtools/routes/v3/router.py b/packages/devtools/src/microsoft_teams/devtools/routes/v3/router.py
index 5258e147..01bb7d37 100644
--- a/packages/devtools/src/microsoft_teams/devtools/routes/v3/router.py
+++ b/packages/devtools/src/microsoft_teams/devtools/routes/v3/router.py
@@ -11,7 +11,7 @@
 
 def get_router(ctx: RouteContext):
     router = APIRouter()
-    updated_context = RouteContext(port=ctx.port, log=ctx.log.getChild("conversations"), process=ctx.process)
+    updated_context = RouteContext(port=ctx.port, process=ctx.process)
     res = conversations_router(updated_context)
     router.include_router(res, prefix="/conversations")
     return router
diff --git a/packages/graph/pyproject.toml b/packages/graph/pyproject.toml
index 884e4781..2df35734 100644
--- a/packages/graph/pyproject.toml
+++ b/packages/graph/pyproject.toml
@@ -11,7 +11,7 @@ dependencies = [
     "azure-core>=1.31.0",
     "msgraph-sdk>=1.30.0,<2.0.0",
     "microsoft-teams-common",
-    "pyjwt[crypto]>=2.10.0",
+    "pyjwt[crypto]>=2.12.0",
 ]
 
 [dependency-groups]
diff --git a/packages/graph/src/microsoft_teams/graph/__init__.py b/packages/graph/src/microsoft_teams/graph/__init__.py
index 48e5b47b..16bf47cf 100644
--- a/packages/graph/src/microsoft_teams/graph/__init__.py
+++ b/packages/graph/src/microsoft_teams/graph/__init__.py
@@ -3,9 +3,13 @@
 Licensed under the MIT License.
 """
 
+import logging
+
 from .auth_provider import AuthProvider
 from .graph import get_graph_client
 
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
 __all__ = [
     "AuthProvider",
     "get_graph_client",
diff --git a/packages/mcpplugin/pyproject.toml b/packages/mcpplugin/pyproject.toml
index f882b7a8..78cd56aa 100644
--- a/packages/mcpplugin/pyproject.toml
+++ b/packages/mcpplugin/pyproject.toml
@@ -11,7 +11,7 @@ license = "MIT"
 dependencies = [
     "mcp>=1.13.1",
     "microsoft-teams-common",
-    "fastmcp>=0.5.0",
+    "fastmcp>=2.14.2",
     "microsoft-teams-apps",
     "microsoft-teams-ai"
 ]
diff --git a/packages/mcpplugin/src/microsoft_teams/mcpplugin/__init__.py b/packages/mcpplugin/src/microsoft_teams/mcpplugin/__init__.py
index fc61cbdc..378035b2 100644
--- a/packages/mcpplugin/src/microsoft_teams/mcpplugin/__init__.py
+++ b/packages/mcpplugin/src/microsoft_teams/mcpplugin/__init__.py
@@ -3,10 +3,14 @@
 Licensed under the MIT License.
 """
 
+import logging
+
 from . import models
 from .ai_plugin import McpClientPlugin, McpClientPluginParams, McpToolDetails
 from .models import *  # noqa: F403
 from .server_plugin import McpServerPlugin
 
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
 __all__: list[str] = ["McpClientPlugin", "McpClientPluginParams", "McpToolDetails", "McpServerPlugin"]
 __all__.extend(models.__all__)
diff --git a/packages/mcpplugin/src/microsoft_teams/mcpplugin/ai_plugin.py b/packages/mcpplugin/src/microsoft_teams/mcpplugin/ai_plugin.py
index 552db972..b2b76fad 100644
--- a/packages/mcpplugin/src/microsoft_teams/mcpplugin/ai_plugin.py
+++ b/packages/mcpplugin/src/microsoft_teams/mcpplugin/ai_plugin.py
@@ -13,7 +13,6 @@
 from mcp.types import TextContent
 from microsoft_teams.ai.function import Function
 from microsoft_teams.ai.plugin import BaseAIPlugin
-from microsoft_teams.common.logging import ConsoleLogger
 from pydantic import BaseModel
 
 from .models import McpCachedValue, McpClientPluginParams, McpToolDetails
@@ -21,6 +20,8 @@
 
 REFETCH_TIMEOUT_MS = 24 * 60 * 60 * 1000  # 1 day
 
+logger = logging.getLogger(__name__)
+
 
 class McpClientPlugin(BaseAIPlugin):
     """
@@ -36,7 +37,6 @@ def __init__(
         name: str = "mcp_client",
         version: str = "0.0.0",
         cache: Optional[Dict[str, McpCachedValue]] = None,
-        logger: Optional[logging.Logger] = None,
         refetch_timeout_ms: int = REFETCH_TIMEOUT_MS,  # 1 day
     ):
         """
@@ -46,14 +46,12 @@ def __init__(
             name: Plugin identifier
             version: Plugin version
             cache: Optional cache for storing fetched tools
-            logger: Optional logger instance
             refetch_timeout_ms: How long to cache tools before refetching (default: 1 day)
         """
         super().__init__(name)
 
         self._version = version
         self._cache: Dict[str, McpCachedValue] = cache or {}
-        self._logger = logger.getChild(self.name) if logger else ConsoleLogger().create_logger(self.name)
         self._refetch_timeout_ms = refetch_timeout_ms
 
         # If cache is provided, update last_fetched for entries with tools
@@ -180,7 +178,7 @@ async def _fetch_tools_if_needed(self) -> None:
             for i, (url, params) in enumerate(fetch_needed):
                 result = results[i]
                 if isinstance(result, Exception):
-                    self._logger.error(f"Failed to fetch tools from {url}: {result}")
+                    logger.error(f"Failed to fetch tools from {url}: {result}")
                     if not params.skip_if_unavailable:
                         raise result
                 elif isinstance(result, list):
@@ -191,7 +189,7 @@ async def _fetch_tools_if_needed(self) -> None:
                     self._cache[url].last_fetched = current_time
                     self._cache[url].transport = params.transport
 
-                    self._logger.debug(f"Cached {len(result)} tools for {url}")
+                    logger.debug(f"Cached {len(result)} tools for {url}")
 
     def _create_function_from_tool(
         self, url: str, tool: McpToolDetails, plugin_params: McpClientPluginParams
@@ -224,12 +222,12 @@ async def handler(params: BaseModel) -> str:
                 Exception: If tool execution fails
             """
             try:
-                self._logger.debug(f"Making call to {url} tool-name={tool_name}")
+                logger.debug(f"Making call to {url} tool-name={tool_name}")
                 result = await self._call_mcp_tool(url, tool_name, params.model_dump(), plugin_params)
-                self._logger.debug(f"Successfully received result for mcp call {result}")
+                logger.debug(f"Successfully received result for mcp call {result}")
                 return str(result)
             except Exception as e:
-                self._logger.error(f"Error calling tool {tool_name} on {url}: {e}")
+                logger.error(f"Error calling tool {tool_name} on {url}: {e}")
                 raise
 
         return Function(
@@ -269,7 +267,7 @@ async def _fetch_tools_from_server(self, url: str, params: McpClientPluginParams
                         )
                     )
 
-                self._logger.debug(f"Got {len(tools)} tools for {url}")
+                logger.debug(f"Got {len(tools)} tools for {url}")
                 return tools
 
     async def _call_mcp_tool(
@@ -314,7 +312,7 @@ async def _call_mcp_tool(
                                 try:
                                     contents.append(json.dumps(item, default=str, ensure_ascii=False))
                                 except (TypeError, ValueError) as e:
-                                    self._logger.warning(f"Failed to serialize content item: {e}")
+                                    logger.warning(f"Failed to serialize content item: {e}")
                                     contents.append(str(item))
                         return contents
 
diff --git a/packages/mcpplugin/src/microsoft_teams/mcpplugin/server_plugin.py b/packages/mcpplugin/src/microsoft_teams/mcpplugin/server_plugin.py
index f56bdf13..3ed7578a 100644
--- a/packages/mcpplugin/src/microsoft_teams/mcpplugin/server_plugin.py
+++ b/packages/mcpplugin/src/microsoft_teams/mcpplugin/server_plugin.py
@@ -13,12 +13,12 @@
 from microsoft_teams.ai import Function, FunctionHandler
 from microsoft_teams.apps import (
     DependencyMetadata,
-    HttpPlugin,
+    FastAPIAdapter,
+    HttpServer,
     Plugin,
     PluginBase,
     PluginStartEvent,
 )
-from microsoft_teams.common.logging import ConsoleLogger
 from pydantic import BaseModel
 
 try:
@@ -26,6 +26,8 @@
 except importlib.metadata.PackageNotFoundError:
     version = "0.0.1-alpha.1"
 
+logger = logging.getLogger(__name__)
+
 P = TypeVar("P", bound=BaseModel)
 
 
@@ -40,21 +42,19 @@ class McpServerPlugin(PluginBase):
     """
 
     # Dependency injection
-    http: Annotated[HttpPlugin, DependencyMetadata()]
+    http_server: Annotated[HttpServer, DependencyMetadata()]
 
-    def __init__(self, name: str = "teams-mcp-server", path: str = "/mcp", logger: logging.Logger | None = None):
+    def __init__(self, name: str = "teams-mcp-server", path: str = "/mcp"):
         """
         Initialize the MCP server plugin.
 
         Args:
             name: The name of the MCP server for identification
             path: The HTTP path to mount the MCP server on (default: /mcp)
-            logger: Optional logger instance for debugging
         """
         self.mcp_server = FastMCP(name)
         self.path = path
         self._mounted = False
-        self.logger = logger or ConsoleLogger().create_logger("mcp-server")
 
     @property
     def server(self) -> FastMCP:
@@ -127,7 +127,7 @@ async def wrapped_handler(**kwargs: Any) -> Any:
                         return await result
                     return result
                 except Exception as e:
-                    self.logger.error(f"Function execution failed for '{function.name}': {e}")
+                    logger.error(f"Function execution failed for '{function.name}': {e}")
                     raise
 
             function_tool = FunctionTool(
@@ -135,16 +135,16 @@ async def wrapped_handler(**kwargs: Any) -> Any:
             )
             self.mcp_server.add_tool(function_tool)
 
-            self.logger.debug(f"Registered AI function '{function.name}' as MCP tool")
+            logger.debug(f"Registered AI function '{function.name}' as MCP tool")
 
             return self
         except Exception as e:
-            self.logger.error(f"Failed to register function '{function.name}' as MCP tool: {e}")
+            logger.error(f"Failed to register function '{function.name}' as MCP tool: {e}")
             raise
 
     async def on_start(self, event: PluginStartEvent) -> None:
         """
-        Start the plugin - mount MCP server on HTTP plugin.
+        Start the plugin - mount MCP server on HTTP server.
 
         Args:
             event: Plugin start event containing application context
@@ -154,20 +154,24 @@ async def on_start(self, event: PluginStartEvent) -> None:
         """
 
         if self._mounted:
-            self.logger.warning("MCP server already mounted")
+            logger.warning("MCP server already mounted")
             return
 
         try:
+            adapter = self.http_server.adapter
+            if not isinstance(adapter, FastAPIAdapter):
+                raise RuntimeError("McpServerPlugin requires FastAPIAdapter. Custom adapters are not supported.")
+
             # We mount the mcp server as a separate app at self.path
             mcp_http_app = self.mcp_server.http_app(path=self.path, transport="http")
-            self.http.lifespans.append(mcp_http_app.lifespan)
-            self.http.app.mount("/", mcp_http_app)
+            adapter.lifespans.append(mcp_http_app.lifespan)  # pyright: ignore[reportArgumentType]
+            adapter.app.mount("/", mcp_http_app)
 
             self._mounted = True
 
-            self.logger.info(f"MCP server mounted at {self.path}")
+            logger.info(f"MCP server mounted at {self.path}")
         except Exception as e:
-            self.logger.error(f"Failed to mount MCP server: {e}")
+            logger.error(f"Failed to mount MCP server: {e}")
             raise
 
     async def on_stop(self) -> None:
@@ -177,5 +181,5 @@ async def on_stop(self) -> None:
         Performs graceful shutdown of the MCP server and cleans up resources.
         """
         if self._mounted:
-            self.logger.info("MCP server shutting down")
+            logger.info("MCP server shutting down")
             self._mounted = False
diff --git a/packages/mcpplugin/tests/test_ai_plugin.py b/packages/mcpplugin/tests/test_ai_plugin.py
index 2957370f..13f30406 100644
--- a/packages/mcpplugin/tests/test_ai_plugin.py
+++ b/packages/mcpplugin/tests/test_ai_plugin.py
@@ -5,6 +5,7 @@
 
 import asyncio
 import inspect
+import json
 import time
 from contextlib import asynccontextmanager
 from typing import Any, Dict, List, Optional, Tuple
@@ -439,6 +440,58 @@ async def test_cache_initialization_with_provided_cache(self, sample_tools: List
             assert "calculator" in function_names
             assert "weather" in function_names
 
+    @pytest.mark.asyncio
+    async def test_cache_initialization_sets_last_fetched_when_missing(self, sample_tools: List[MockMCPTool]):
+        """__init__ sets last_fetched on cache entries that have tools but no timestamp."""
+        tool_details = [
+            McpToolDetails(name=tool.name, description=tool.description, input_schema=tool.inputSchema)
+            for tool in sample_tools[:1]
+        ]
+
+        cached_value = McpCachedValue(available_tools=tool_details, last_fetched=None)
+        assert cached_value.last_fetched is None
+
+        before = time.time() * 1000
+        plugin = McpClientPlugin(cache={"http://test-server": cached_value})
+        after = time.time() * 1000
+
+        assert plugin.cache["http://test-server"].last_fetched is not None
+        assert before <= plugin.cache["http://test-server"].last_fetched <= after  # type: ignore[operator]
+
+    @pytest.mark.asyncio
+    async def test_partial_server_failure_skip_succeeds_other_cached(self, sample_tools: List[MockMCPTool]):
+        """When one server fails with skip_if_unavailable=True and another succeeds, good server tools are cached."""
+        good_session = MockClientSession(tools=[sample_tools[0]])
+        connection_error = ConnectionError("bad server down")
+
+        call_count = 0
+
+        def transport_factory(url, transport_type, headers=None):
+            nonlocal call_count
+            call_count += 1
+            mock = MagicMock()
+            if "bad" in url:
+                mock.__aenter__ = AsyncMock(side_effect=connection_error)
+            else:
+                mock.__aenter__ = AsyncMock(return_value=(MagicMock(), MagicMock()))
+            mock.__aexit__ = AsyncMock(return_value=None)
+            return mock
+
+        with (
+            patch("microsoft_teams.mcpplugin.ai_plugin.create_transport", side_effect=transport_factory),
+            patch("microsoft_teams.mcpplugin.ai_plugin.ClientSession", return_value=good_session),
+        ):
+            plugin = McpClientPlugin()
+            plugin.use_mcp_server("http://good-server", McpClientPluginParams(skip_if_unavailable=False))
+            plugin.use_mcp_server("http://bad-server", McpClientPluginParams(skip_if_unavailable=True))
+
+            functions = await plugin.on_build_functions([])
+
+        assert len(functions) == 1
+        assert functions[0].name == "calculator"
+        assert "http://good-server" in plugin.cache
+        assert "http://bad-server" not in plugin.cache
+
     @pytest.mark.asyncio
     async def test_predefined_tools_not_fetched(self, sample_tools: List[MockMCPTool]):
         """Test that predefined tools are not fetched from server."""
@@ -459,3 +512,92 @@ async def test_predefined_tools_not_fetched(self, sample_tools: List[MockMCPTool
             function_names = [f.name for f in functions]
             assert "calculator" in function_names
             assert "weather" in function_names
+
+
+class TestCallMcpToolContentHandling:
+    """Tests for _call_mcp_tool content processing branches."""
+
+    @pytest.fixture
+    def plugin(self):
+        return McpClientPlugin()
+
+    @pytest.fixture
+    def mock_transport(self):
+        transport = MagicMock()
+        transport.__aenter__ = AsyncMock(return_value=(MagicMock(), MagicMock()))
+        transport.__aexit__ = AsyncMock(return_value=False)
+        return transport
+
+    def _make_session(self, call_result):
+        session = AsyncMock()
+        session.initialize = AsyncMock()
+        session.call_tool = AsyncMock(return_value=call_result)
+        session.__aenter__ = AsyncMock(return_value=session)
+        session.__aexit__ = AsyncMock(return_value=False)
+        return session
+
+    @pytest.mark.asyncio
+    async def test_empty_content_returns_none(self, plugin, mock_transport):
+        """When result.content is empty, returns None."""
+        mock_result = MagicMock()
+        mock_result.content = []
+        session = self._make_session(mock_result)
+
+        with (
+            patch("microsoft_teams.mcpplugin.ai_plugin.create_transport", return_value=mock_transport),
+            patch("microsoft_teams.mcpplugin.ai_plugin.ClientSession", return_value=session),
+        ):
+            result = await plugin._call_mcp_tool("http://server", "tool", {}, McpClientPluginParams())
+
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_single_non_text_content_returns_str(self, plugin, mock_transport):
+        """Single non-TextContent item falls back to str(item)."""
+        non_text = MagicMock()
+        mock_result = MagicMock()
+        mock_result.content = [non_text]
+        session = self._make_session(mock_result)
+
+        with (
+            patch("microsoft_teams.mcpplugin.ai_plugin.create_transport", return_value=mock_transport),
+            patch("microsoft_teams.mcpplugin.ai_plugin.ClientSession", return_value=session),
+        ):
+            result = await plugin._call_mcp_tool("http://server", "tool", {}, McpClientPluginParams())
+
+        assert result == str(non_text)
+
+    @pytest.mark.asyncio
+    async def test_multiple_items_non_text_json_serialized(self, plugin, mock_transport):
+        """Multiple items: TextContent uses .text; non-TextContent is JSON serialized."""
+        text_item = TextContent(type="text", text="hello")
+        non_text = {"type": "image", "url": "http://example.com/img.png"}
+        mock_result = MagicMock()
+        mock_result.content = [text_item, non_text]
+        session = self._make_session(mock_result)
+
+        with (
+            patch("microsoft_teams.mcpplugin.ai_plugin.create_transport", return_value=mock_transport),
+            patch("microsoft_teams.mcpplugin.ai_plugin.ClientSession", return_value=session),
+        ):
+            result = await plugin._call_mcp_tool("http://server", "tool", {}, McpClientPluginParams())
+
+        assert result == ["hello", json.dumps(non_text, default=str, ensure_ascii=False)]
+
+    @pytest.mark.asyncio
+    async def test_multiple_items_json_serialization_fallback(self, plugin, mock_transport):
+        """When JSON serialization raises, falls back to str(item)."""
+        text_item = TextContent(type="text", text="hello")
+        non_text = MagicMock()
+        mock_result = MagicMock()
+        mock_result.content = [text_item, non_text]
+        session = self._make_session(mock_result)
+
+        with (
+            patch("microsoft_teams.mcpplugin.ai_plugin.create_transport", return_value=mock_transport),
+            patch("microsoft_teams.mcpplugin.ai_plugin.ClientSession", return_value=session),
+            patch("microsoft_teams.mcpplugin.ai_plugin.json.dumps", side_effect=TypeError("not serializable")),
+        ):
+            result = await plugin._call_mcp_tool("http://server", "tool", {}, McpClientPluginParams())
+
+        assert result == ["hello", str(non_text)]
diff --git a/packages/mcpplugin/tests/test_server_plugin.py b/packages/mcpplugin/tests/test_server_plugin.py
new file mode 100644
index 00000000..1069544b
--- /dev/null
+++ b/packages/mcpplugin/tests/test_server_plugin.py
@@ -0,0 +1,383 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from microsoft_teams.ai import Function
+from microsoft_teams.apps import FastAPIAdapter, HttpServer, PluginStartEvent
+from microsoft_teams.mcpplugin.server_plugin import McpServerPlugin
+from pydantic import BaseModel, ValidationError
+
+# pyright: basic
+
+
+class TestMcpServerPluginInit:
+    """Tests for McpServerPlugin.__init__"""
+
+    def test_init_default_args(self):
+        """Test __init__ with default arguments creates correct state."""
+        with patch("microsoft_teams.mcpplugin.server_plugin.FastMCP") as mock_fastmcp_class:
+            mock_fastmcp_instance = MagicMock()
+            mock_fastmcp_class.return_value = mock_fastmcp_instance
+
+            plugin = McpServerPlugin()
+
+            mock_fastmcp_class.assert_called_once_with("teams-mcp-server")
+            assert plugin.mcp_server is mock_fastmcp_instance
+            assert plugin.path == "/mcp"
+            assert plugin._mounted is False
+
+    def test_init_custom_args(self):
+        """Test __init__ with custom name and path."""
+        with patch("microsoft_teams.mcpplugin.server_plugin.FastMCP") as mock_fastmcp_class:
+            mock_fastmcp_instance = MagicMock()
+            mock_fastmcp_class.return_value = mock_fastmcp_instance
+
+            plugin = McpServerPlugin(name="my-mcp-server", path="/custom-mcp")
+
+            mock_fastmcp_class.assert_called_once_with("my-mcp-server")
+            assert plugin.mcp_server is mock_fastmcp_instance
+            assert plugin.path == "/custom-mcp"
+            assert plugin._mounted is False
+
+
+class TestMcpServerPluginUseTool:
+    """Tests for McpServerPlugin.use_tool method."""
+
+    @pytest.fixture
+    def mock_mcp_server(self):
+        return MagicMock()
+
+    @pytest.fixture
+    def plugin(self, mock_mcp_server: MagicMock):
+        with patch("microsoft_teams.mcpplugin.server_plugin.FastMCP") as mock_fastmcp_class:
+            mock_fastmcp_class.return_value = mock_mcp_server
+            p = McpServerPlugin()
+            yield p
+
+    def test_use_tool_with_dict_schema(self, plugin: McpServerPlugin, mock_mcp_server: MagicMock):
+        """Test use_tool registers a function with dict parameter schema."""
+        dict_schema = {
+            "type": "object",
+            "properties": {"query": {"type": "string"}},
+            "required": ["query"],
+        }
+
+        def sync_handler(**kwargs):
+            return f"result: {kwargs.get('query')}"
+
+        function = Function(
+            name="search",
+            description="Search for something",
+            parameter_schema=dict_schema,
+            handler=sync_handler,
+        )
+
+        with patch("microsoft_teams.mcpplugin.server_plugin.FunctionTool") as mock_function_tool_class:
+            mock_tool_instance = MagicMock()
+            mock_function_tool_class.return_value = mock_tool_instance
+
+            result = plugin.use_tool(function)
+
+            assert result is plugin
+
+            mock_function_tool_class.assert_called_once()
+            call_kwargs = mock_function_tool_class.call_args.kwargs
+            assert call_kwargs["name"] == "search"
+            assert call_kwargs["description"] == "Search for something"
+            assert call_kwargs["parameters"] == dict_schema
+
+            mock_mcp_server.add_tool.assert_called_once_with(mock_tool_instance)
+
+    def test_use_tool_with_pydantic_model_schema(self, plugin: McpServerPlugin, mock_mcp_server: MagicMock):
+        """Test use_tool with a Pydantic model as parameter schema."""
+
+        class SearchParams(BaseModel):
+            query: str
+            limit: int = 10
+
+        def handler(params: SearchParams):
+            return f"searched: {params.query}"
+
+        function = Function[SearchParams](
+            name="pydantic_search",
+            description="Search with pydantic params",
+            parameter_schema=SearchParams,
+            handler=handler,
+        )
+
+        with patch("microsoft_teams.mcpplugin.server_plugin.FunctionTool") as mock_function_tool_class:
+            mock_tool_instance = MagicMock()
+            mock_function_tool_class.return_value = mock_tool_instance
+
+            result = plugin.use_tool(function)
+
+            assert result is plugin
+
+            call_kwargs = mock_function_tool_class.call_args.kwargs
+            assert call_kwargs["name"] == "pydantic_search"
+            assert call_kwargs["description"] == "Search with pydantic params"
+            assert call_kwargs["parameters"] == SearchParams.model_json_schema()
+
+            mock_mcp_server.add_tool.assert_called_once_with(mock_tool_instance)
+
+    def test_use_tool_with_none_schema(self, plugin: McpServerPlugin, mock_mcp_server: MagicMock):
+        """Test use_tool with None parameter schema uses empty dict."""
+
+        def no_param_handler(**kwargs):
+            return "no params needed"
+
+        function = Function(
+            name="no_params",
+            description="A function with no parameters",
+            parameter_schema=None,
+            handler=no_param_handler,
+        )
+
+        with patch("microsoft_teams.mcpplugin.server_plugin.FunctionTool") as mock_function_tool_class:
+            mock_tool_instance = MagicMock()
+            mock_function_tool_class.return_value = mock_tool_instance
+
+            result = plugin.use_tool(function)
+
+            assert result is plugin
+
+            call_kwargs = mock_function_tool_class.call_args.kwargs
+            assert call_kwargs["name"] == "no_params"
+            assert call_kwargs["parameters"] == {}
+
+            mock_mcp_server.add_tool.assert_called_once_with(mock_tool_instance)
+
+    def test_use_tool_raises_on_add_tool_failure(self, plugin: McpServerPlugin, mock_mcp_server: MagicMock):
+        """Test that exceptions from mcp_server.add_tool propagate."""
+
+        def handler(**kwargs):
+            return "ok"
+
+        function = Function(name="bad_fn", description="fails", parameter_schema=None, handler=handler)
+
+        mock_mcp_server.add_tool.side_effect = ValueError("add_tool failed")
+
+        with patch("microsoft_teams.mcpplugin.server_plugin.FunctionTool"):
+            with pytest.raises(ValueError, match="add_tool failed"):
+                plugin.use_tool(function)
+
+    async def test_wrapped_handler_sync_dict_schema(self, plugin: McpServerPlugin, mock_mcp_server: MagicMock):
+        """wrapped_handler with dict schema passes kwargs directly to the sync handler."""
+        received: dict = {}
+
+        def sync_handler(**kwargs):
+            received.update(kwargs)
+            return "sync result"
+
+        function = Function(name="fn", description="d", parameter_schema={"type": "object"}, handler=sync_handler)
+
+        with patch("microsoft_teams.mcpplugin.server_plugin.FunctionTool") as mock_ft_class:
+            plugin.use_tool(function)
+            wrapped_fn = mock_ft_class.call_args.kwargs["fn"]
+
+        result = await wrapped_fn(x=1, y=2)
+
+        assert result == "sync result"
+        assert received == {"x": 1, "y": 2}
+
+    async def test_wrapped_handler_async_handler_is_awaited(self, plugin: McpServerPlugin, mock_mcp_server: MagicMock):
+        """wrapped_handler awaits async handlers."""
+
+        async def async_handler(**kwargs):
+            return "async result"
+
+        function = Function(name="fn", description="d", parameter_schema=None, handler=async_handler)
+
+        with patch("microsoft_teams.mcpplugin.server_plugin.FunctionTool") as mock_ft_class:
+            plugin.use_tool(function)
+            wrapped_fn = mock_ft_class.call_args.kwargs["fn"]
+
+        result = await wrapped_fn()
+
+        assert result == "async result"
+
+    async def test_wrapped_handler_pydantic_schema_instantiates_model(
+        self, plugin: McpServerPlugin, mock_mcp_server: MagicMock
+    ):
+        """wrapped_handler with a Pydantic class schema instantiates the model before calling the handler."""
+
+        class MyParams(BaseModel):
+            x: int
+            y: str
+
+        received: dict = {}
+
+        def handler(params: MyParams):
+            received["params"] = params
+            return "pydantic result"
+
+        function = Function[MyParams](name="fn", description="d", parameter_schema=MyParams, handler=handler)
+
+        with patch("microsoft_teams.mcpplugin.server_plugin.FunctionTool") as mock_ft_class:
+            plugin.use_tool(function)
+            wrapped_fn = mock_ft_class.call_args.kwargs["fn"]
+
+        result = await wrapped_fn(x=42, y="hello")
+
+        assert result == "pydantic result"
+        assert isinstance(received["params"], MyParams)
+        assert received["params"].x == 42
+        assert received["params"].y == "hello"
+
+    async def test_wrapped_handler_exception_propagates(self, plugin: McpServerPlugin, mock_mcp_server: MagicMock):
+        """wrapped_handler re-raises exceptions from the underlying handler."""
+
+        def failing_handler(**kwargs):
+            raise ValueError("handler failed")
+
+        function = Function(name="fn", description="d", parameter_schema=None, handler=failing_handler)
+
+        with patch("microsoft_teams.mcpplugin.server_plugin.FunctionTool") as mock_ft_class:
+            plugin.use_tool(function)
+            wrapped_fn = mock_ft_class.call_args.kwargs["fn"]
+
+        with pytest.raises(ValueError, match="handler failed"):
+            await wrapped_fn()
+
+    async def test_wrapped_handler_pydantic_validation_error_propagates(self, plugin: McpServerPlugin):
+        """wrapped_handler re-raises Pydantic ValidationError when kwargs don't match the model."""
+
+        class StrictParams(BaseModel):
+            count: int
+
+        def handler(params: StrictParams):  # noqa: ARG001
+            return "ok"
+
+        function = Function[StrictParams](name="fn", description="d", parameter_schema=StrictParams, handler=handler)
+
+        with patch("microsoft_teams.mcpplugin.server_plugin.FunctionTool") as mock_ft_class:
+            plugin.use_tool(function)
+            wrapped_fn = mock_ft_class.call_args.kwargs["fn"]
+
+        with pytest.raises(ValidationError):
+            await wrapped_fn(count="not-an-int")
+
+
+class TestMcpServerPluginOnStart:
+    """Tests for McpServerPlugin.on_start method."""
+
+    @pytest.fixture
+    def mock_mcp_server(self):
+        return MagicMock()
+
+    @pytest.fixture
+    def plugin(self, mock_mcp_server: MagicMock):
+        with patch("microsoft_teams.mcpplugin.server_plugin.FastMCP") as mock_fastmcp_class:
+            mock_fastmcp_class.return_value = mock_mcp_server
+            p = McpServerPlugin(name="test-server", path="/mcp")
+        return p
+
+    @pytest.fixture
+    def mock_http_server(self):
+        server = MagicMock(spec=HttpServer)
+        return server
+
+    async def test_on_start_raises_when_not_fastapi_adapter(self, plugin: McpServerPlugin, mock_http_server):
+        """Test on_start raises RuntimeError when adapter is not FastAPIAdapter."""
+        mock_adapter = MagicMock()  # Not a FastAPIAdapter instance
+        mock_http_server.adapter = mock_adapter
+        plugin.http_server = mock_http_server
+
+        event = PluginStartEvent(port=3978)
+
+        with pytest.raises(RuntimeError, match="McpServerPlugin requires FastAPIAdapter"):
+            await plugin.on_start(event)
+
+        assert plugin._mounted is False
+
+    async def test_on_start_success_mounts_mcp_server(
+        self, plugin: McpServerPlugin, mock_mcp_server: MagicMock, mock_http_server
+    ):
+        """Test on_start successfully mounts MCP server with FastAPIAdapter."""
+        mock_fastapi_adapter = MagicMock(spec=FastAPIAdapter)
+        mock_fastapi_adapter.lifespans = []
+        mock_fastapi_adapter.app = MagicMock()
+
+        mock_http_server.adapter = mock_fastapi_adapter
+        plugin.http_server = mock_http_server
+
+        mock_mcp_http_app = MagicMock()
+        mock_mcp_http_app.lifespan = MagicMock()
+        mock_mcp_server.http_app = MagicMock(return_value=mock_mcp_http_app)
+
+        event = PluginStartEvent(port=3978)
+
+        await plugin.on_start(event)
+
+        mock_mcp_server.http_app.assert_called_once_with(path="/mcp", transport="http")
+        assert mock_mcp_http_app.lifespan in mock_fastapi_adapter.lifespans
+        mock_fastapi_adapter.app.mount.assert_called_once_with("/", mock_mcp_http_app)
+        assert plugin._mounted is True
+
+    async def test_on_start_already_mounted_logs_warning_and_returns(self, plugin: McpServerPlugin, mock_http_server):
+        """Test on_start logs warning and returns early if already mounted."""
+        plugin._mounted = True
+        plugin.http_server = mock_http_server
+
+        event = PluginStartEvent(port=3978)
+
+        with patch("microsoft_teams.mcpplugin.server_plugin.logger") as mock_logger:
+            await plugin.on_start(event)
+            mock_logger.warning.assert_called_once_with("MCP server already mounted")
+
+        mock_http_server.adapter.assert_not_called()
+
+    async def test_on_start_exception_propagates_and_not_mounted(
+        self, plugin: McpServerPlugin, mock_mcp_server: MagicMock, mock_http_server
+    ):
+        """Test that exceptions during mounting propagate and _mounted stays False."""
+        mock_fastapi_adapter = MagicMock(spec=FastAPIAdapter)
+        mock_fastapi_adapter.lifespans = []
+        mock_fastapi_adapter.app = MagicMock()
+        mock_fastapi_adapter.app.mount.side_effect = RuntimeError("mount failed")
+        mock_http_server.adapter = mock_fastapi_adapter
+        plugin.http_server = mock_http_server
+
+        mock_mcp_http_app = MagicMock()
+        mock_mcp_server.http_app = MagicMock(return_value=mock_mcp_http_app)
+
+        event = PluginStartEvent(port=3978)
+
+        with pytest.raises(RuntimeError, match="mount failed"):
+            await plugin.on_start(event)
+
+        assert plugin._mounted is False
+
+
+class TestMcpServerPluginOnStop:
+    """Tests for McpServerPlugin.on_stop method."""
+
+    @pytest.fixture
+    def plugin(self):
+        with patch("microsoft_teams.mcpplugin.server_plugin.FastMCP"):
+            p = McpServerPlugin()
+        return p
+
+    async def test_on_stop_when_mounted_sets_mounted_false(self, plugin: McpServerPlugin):
+        """Test on_stop sets _mounted=False and logs shutdown when mounted."""
+        plugin._mounted = True
+
+        with patch("microsoft_teams.mcpplugin.server_plugin.logger") as mock_logger:
+            await plugin.on_stop()
+
+        assert plugin._mounted is False
+        mock_logger.info.assert_called_once_with("MCP server shutting down")
+
+    async def test_on_stop_when_not_mounted_does_nothing(self, plugin: McpServerPlugin):
+        """Test on_stop does nothing when not mounted."""
+        plugin._mounted = False
+
+        with patch("microsoft_teams.mcpplugin.server_plugin.logger") as mock_logger:
+            await plugin.on_stop()
+
+        assert plugin._mounted is False
+        mock_logger.info.assert_not_called()
diff --git a/packages/mcpplugin/tests/test_transport.py b/packages/mcpplugin/tests/test_transport.py
new file mode 100644
index 00000000..dd71c743
--- /dev/null
+++ b/packages/mcpplugin/tests/test_transport.py
@@ -0,0 +1,371 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+from contextlib import asynccontextmanager
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from microsoft_teams.mcpplugin.transport import create_sse_transport, create_streamable_http_transport, create_transport
+
+# pyright: basic
+
+
+class TestCreateTransportFactory:
+    """Tests for the create_transport factory function."""
+
+    def test_unknown_transport_type_raises_value_error(self):
+        """create_transport raises ValueError for unsupported transport types."""
+        with pytest.raises(ValueError, match="Unsupported transport type: grpc"):
+            create_transport("http://example.com", "grpc")
+
+    def test_streamable_http_passes_url_and_headers(self):
+        """create_transport forwards url and headers to create_streamable_http_transport."""
+        headers = {"Authorization": "Bearer token"}
+        with patch("microsoft_teams.mcpplugin.transport.create_streamable_http_transport") as mock_fn:
+            create_transport("http://example.com", "streamable_http", headers)
+            mock_fn.assert_called_once_with("http://example.com", headers)
+
+    def test_sse_passes_url_and_headers(self):
+        """create_transport forwards url and headers to create_sse_transport."""
+        headers = {"X-Custom": "value"}
+        with patch("microsoft_teams.mcpplugin.transport.create_sse_transport") as mock_fn:
+            create_transport("http://example.com", "sse", headers)
+            mock_fn.assert_called_once_with("http://example.com", headers)
+
+
+class TestCreateStreamableHttpTransport:
+    """Tests for create_streamable_http_transport."""
+
+    async def test_no_headers_skips_httpx_async_client(self):
+        """Without headers, httpx.AsyncClient is never instantiated."""
+        read_stream = MagicMock()
+        write_stream = MagicMock()
+
+        @asynccontextmanager
+        async def mock_streamable_http_client(url, http_client=None):
+            yield (read_stream, write_stream, MagicMock())
+
+        with (
+            patch(
+                "microsoft_teams.mcpplugin.transport.streamable_http_client",
+                mock_streamable_http_client,
+            ),
+            patch("microsoft_teams.mcpplugin.transport.httpx.AsyncClient") as mock_async_client,
+        ):
+            async with create_streamable_http_transport("http://example.com"):
+                pass
+
+            mock_async_client.assert_not_called()
+
+    async def test_static_string_headers_creates_http_client(self):
+        """Static string headers are passed verbatim to httpx.AsyncClient."""
+        read_stream = MagicMock()
+        write_stream = MagicMock()
+
+        mock_http_client_instance = MagicMock()
+
+        @asynccontextmanager
+        async def mock_streamable_http_client(url, http_client=None):
+            yield (read_stream, write_stream, MagicMock())
+
+        with (
+            patch(
+                "microsoft_teams.mcpplugin.transport.streamable_http_client",
+                mock_streamable_http_client,
+            ),
+            patch("microsoft_teams.mcpplugin.transport.httpx.AsyncClient") as mock_async_client,
+        ):
+            mock_async_client.return_value.__aenter__ = AsyncMock(return_value=mock_http_client_instance)
+            mock_async_client.return_value.__aexit__ = AsyncMock(return_value=False)
+
+            headers = {"Authorization": "Bearer token", "X-Version": "1.0"}
+            async with create_streamable_http_transport("http://example.com", headers) as (r, w):
+                assert r is read_stream
+                assert w is write_stream
+
+            mock_async_client.assert_called_once_with(headers={"Authorization": "Bearer token", "X-Version": "1.0"})
+
+    async def test_sync_callable_header_is_resolved(self):
+        """Sync callable header values are called and resolved to strings."""
+        read_stream = MagicMock()
+        write_stream = MagicMock()
+
+        def get_token():
+            return "Bearer sync-token"
+
+        with (
+            patch("microsoft_teams.mcpplugin.transport.streamable_http_client") as mock_streamable,
+            patch("microsoft_teams.mcpplugin.transport.httpx.AsyncClient") as mock_async_client,
+        ):
+            mock_http_instance = MagicMock()
+            mock_async_client.return_value.__aenter__ = AsyncMock(return_value=mock_http_instance)
+            mock_async_client.return_value.__aexit__ = AsyncMock(return_value=False)
+
+            @asynccontextmanager
+            async def fake_streamable(url, http_client=None):
+                yield (read_stream, write_stream, MagicMock())
+
+            mock_streamable.side_effect = fake_streamable
+
+            headers = {"Authorization": get_token}
+            async with create_streamable_http_transport("http://example.com", headers):
+                pass
+
+            mock_async_client.assert_called_once_with(headers={"Authorization": "Bearer sync-token"})
+
+    async def test_async_callable_header_is_awaited_and_resolved(self):
+        """Async callable header values are awaited and resolved to strings."""
+        read_stream = MagicMock()
+        write_stream = MagicMock()
+
+        async def get_async_token():
+            return "Bearer async-token"
+
+        with (
+            patch("microsoft_teams.mcpplugin.transport.streamable_http_client") as mock_streamable,
+            patch("microsoft_teams.mcpplugin.transport.httpx.AsyncClient") as mock_async_client,
+        ):
+            mock_http_instance = MagicMock()
+            mock_async_client.return_value.__aenter__ = AsyncMock(return_value=mock_http_instance)
+            mock_async_client.return_value.__aexit__ = AsyncMock(return_value=False)
+
+            @asynccontextmanager
+            async def fake_streamable(url, http_client=None):
+                yield (read_stream, write_stream, MagicMock())
+
+            mock_streamable.side_effect = fake_streamable
+
+            headers = {"Authorization": get_async_token}
+            async with create_streamable_http_transport("http://example.com", headers):
+                pass
+
+            mock_async_client.assert_called_once_with(headers={"Authorization": "Bearer async-token"})
+
+    async def test_mixed_header_types_all_resolved(self):
+        """Mix of static string, sync callable, and async callable headers are all resolved."""
+        read_stream = MagicMock()
+        write_stream = MagicMock()
+
+        def sync_fn():
+            return "sync-value"
+
+        async def async_fn():
+            return "async-value"
+
+        with (
+            patch("microsoft_teams.mcpplugin.transport.streamable_http_client") as mock_streamable,
+            patch("microsoft_teams.mcpplugin.transport.httpx.AsyncClient") as mock_async_client,
+        ):
+            mock_http_instance = MagicMock()
+            mock_async_client.return_value.__aenter__ = AsyncMock(return_value=mock_http_instance)
+            mock_async_client.return_value.__aexit__ = AsyncMock(return_value=False)
+
+            @asynccontextmanager
+            async def fake_streamable(url, http_client=None):
+                yield (read_stream, write_stream, MagicMock())
+
+            mock_streamable.side_effect = fake_streamable
+
+            headers = {
+                "X-Static": "static-value",
+                "X-Sync": sync_fn,
+                "X-Async": async_fn,
+            }
+            async with create_streamable_http_transport("http://example.com", headers):
+                pass
+
+            mock_async_client.assert_called_once_with(
+                headers={
+                    "X-Static": "static-value",
+                    "X-Sync": "sync-value",
+                    "X-Async": "async-value",
+                }
+            )
+
+    async def test_non_string_header_values_are_coerced_to_string(self):
+        """Non-string header values (int, etc.) are coerced via str()."""
+        read_stream = MagicMock()
+        write_stream = MagicMock()
+
+        with (
+            patch("microsoft_teams.mcpplugin.transport.streamable_http_client") as mock_streamable,
+            patch("microsoft_teams.mcpplugin.transport.httpx.AsyncClient") as mock_async_client,
+        ):
+            mock_http_instance = MagicMock()
+            mock_async_client.return_value.__aenter__ = AsyncMock(return_value=mock_http_instance)
+            mock_async_client.return_value.__aexit__ = AsyncMock(return_value=False)
+
+            @asynccontextmanager
+            async def fake_streamable(url, http_client=None):
+                yield (read_stream, write_stream, MagicMock())
+
+            mock_streamable.side_effect = fake_streamable
+
+            headers: Any = {"X-Port": 8080}
+            async with create_streamable_http_transport("http://example.com", headers):
+                pass
+
+            mock_async_client.assert_called_once_with(headers={"X-Port": "8080"})
+
+    async def test_yields_read_and_write_streams(self):
+        """The context manager correctly yields (read_stream, write_stream) to callers."""
+        read_stream = MagicMock(name="read")
+        write_stream = MagicMock(name="write")
+
+        with patch("microsoft_teams.mcpplugin.transport.streamable_http_client") as mock_streamable:
+
+            @asynccontextmanager
+            async def fake_streamable(url, http_client=None):
+                yield (read_stream, write_stream, MagicMock())
+
+            mock_streamable.side_effect = fake_streamable
+
+            async with create_streamable_http_transport("http://example.com") as (r, w):
+                assert r is read_stream
+                assert w is write_stream
+
+
+class TestCreateSseTransport:
+    """Tests for create_sse_transport."""
+
+    async def test_no_headers_calls_sse_client_with_empty_headers(self):
+        """Without headers, sse_client is called with an empty resolved_headers dict."""
+        read_stream = MagicMock()
+        write_stream = MagicMock()
+        captured: dict = {}
+
+        @asynccontextmanager
+        async def mock_sse_client(url, headers=None):
+            captured["headers"] = headers
+            yield (read_stream, write_stream)
+
+        with patch(
+            "microsoft_teams.mcpplugin.transport.sse_client",
+            mock_sse_client,
+        ):
+            async with create_sse_transport("http://example.com") as (r, w):
+                assert r is read_stream
+                assert w is write_stream
+
+        assert captured["headers"] == {}
+
+    async def test_static_string_headers_passed_to_sse_client(self):
+        """Static string headers are resolved and forwarded to sse_client."""
+        read_stream = MagicMock()
+        write_stream = MagicMock()
+        captured: dict = {}
+
+        @asynccontextmanager
+        async def mock_sse_client(url, headers=None):
+            captured["headers"] = headers
+            yield (read_stream, write_stream)
+
+        with patch(
+            "microsoft_teams.mcpplugin.transport.sse_client",
+            mock_sse_client,
+        ):
+            headers = {"Authorization": "Bearer static", "Content-Type": "application/json"}
+            async with create_sse_transport("http://example.com", headers) as (r, w):
+                assert r is read_stream
+                assert w is write_stream
+
+        assert captured["headers"] == {"Authorization": "Bearer static", "Content-Type": "application/json"}
+
+    async def test_sync_callable_header_resolved_for_sse(self):
+        """Sync callable header values are called and resolved before passing to sse_client."""
+        captured: dict = {}
+
+        def get_token():
+            return "Bearer sync-sse-token"
+
+        @asynccontextmanager
+        async def mock_sse_client(url, headers=None):
+            captured["headers"] = headers
+            yield (MagicMock(), MagicMock())
+
+        with patch(
+            "microsoft_teams.mcpplugin.transport.sse_client",
+            mock_sse_client,
+        ):
+            headers = {"Authorization": get_token}
+            async with create_sse_transport("http://example.com", headers):
+                pass
+
+        assert captured["headers"] == {"Authorization": "Bearer sync-sse-token"}
+
+    async def test_async_callable_header_resolved_for_sse(self):
+        """Async callable header values are awaited and resolved before passing to sse_client."""
+        captured: dict = {}
+
+        async def get_async_token():
+            return "Bearer async-sse-token"
+
+        @asynccontextmanager
+        async def mock_sse_client(url, headers=None):
+            captured["headers"] = headers
+            yield (MagicMock(), MagicMock())
+
+        with patch(
+            "microsoft_teams.mcpplugin.transport.sse_client",
+            mock_sse_client,
+        ):
+            headers = {"Authorization": get_async_token}
+            async with create_sse_transport("http://example.com", headers):
+                pass
+
+        assert captured["headers"] == {"Authorization": "Bearer async-sse-token"}
+
+    async def test_mixed_header_types_resolved_for_sse(self):
+        """Mix of static, sync callable, and async callable headers are all resolved for SSE."""
+        captured: dict = {}
+
+        def sync_fn():
+            return "sync-val"
+
+        async def async_fn():
+            return "async-val"
+
+        @asynccontextmanager
+        async def mock_sse_client(url, headers=None):
+            captured["headers"] = headers
+            yield (MagicMock(), MagicMock())
+
+        with patch(
+            "microsoft_teams.mcpplugin.transport.sse_client",
+            mock_sse_client,
+        ):
+            headers = {
+                "X-Static": "static-val",
+                "X-Sync": sync_fn,
+                "X-Async": async_fn,
+            }
+            async with create_sse_transport("http://example.com", headers):
+                pass
+
+        assert captured["headers"] == {
+            "X-Static": "static-val",
+            "X-Sync": "sync-val",
+            "X-Async": "async-val",
+        }
+
+    async def test_sse_non_string_header_values_coerced(self):
+        """Non-string SSE header values (int, bool, etc.) are coerced via str()."""
+        captured: dict = {}
+
+        @asynccontextmanager
+        async def mock_sse_client(url, headers=None):
+            captured["headers"] = headers
+            yield (MagicMock(), MagicMock())
+
+        with patch(
+            "microsoft_teams.mcpplugin.transport.sse_client",
+            mock_sse_client,
+        ):
+            headers: Any = {"X-Retry": 3}
+            async with create_sse_transport("http://example.com", headers):
+                pass
+
+        assert captured["headers"] == {"X-Retry": "3"}
diff --git a/packages/openai/src/microsoft_teams/openai/__init__.py b/packages/openai/src/microsoft_teams/openai/__init__.py
index 85052037..da6e7607 100644
--- a/packages/openai/src/microsoft_teams/openai/__init__.py
+++ b/packages/openai/src/microsoft_teams/openai/__init__.py
@@ -3,7 +3,11 @@
 Licensed under the MIT License.
 """
 
+import logging
+
 from .completions_model import OpenAICompletionsAIModel
 from .responses_chat_model import OpenAIResponsesAIModel
 
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
 __all__ = ["OpenAICompletionsAIModel", "OpenAIResponsesAIModel"]
diff --git a/packages/openai/src/microsoft_teams/openai/common.py b/packages/openai/src/microsoft_teams/openai/common.py
index f36c8546..9339cd6a 100644
--- a/packages/openai/src/microsoft_teams/openai/common.py
+++ b/packages/openai/src/microsoft_teams/openai/common.py
@@ -3,18 +3,19 @@
 Licensed under the MIT License.
 """
 
+import logging
 from dataclasses import dataclass, field
-from logging import Logger
 from os import getenv
 from typing import Literal
 
 from dotenv import find_dotenv, load_dotenv
-from microsoft_teams.common.logging import ConsoleLogger
 
 from openai import AsyncAzureOpenAI, AsyncOpenAI
 
 load_dotenv(find_dotenv(usecwd=True))
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class OpenAIBaseModel:
@@ -45,9 +46,6 @@ class OpenAIBaseModel:
     # Azure OpenAI options
     azure_endpoint: str | None = None  # Azure OpenAI endpoint URL
     api_version: str | None = None  # Azure OpenAI API version
-    logger: Logger = field(
-        default_factory=lambda: ConsoleLogger().create_logger(name="OpenAI-Model")
-    )  # Logger instance
     _client: AsyncOpenAI = field(init=False)  # Internal client instance
     _model: str = field(init=False)  # Resolved model name
 
diff --git a/packages/openai/src/microsoft_teams/openai/completions_model.py b/packages/openai/src/microsoft_teams/openai/completions_model.py
index 9ffc7f45..f70b2604 100644
--- a/packages/openai/src/microsoft_teams/openai/completions_model.py
+++ b/packages/openai/src/microsoft_teams/openai/completions_model.py
@@ -5,6 +5,7 @@
 
 import inspect
 import json
+import logging
 from dataclasses import dataclass
 from typing import Any, Awaitable, Callable, TypedDict, cast
 
@@ -41,6 +42,8 @@
 
 from .function_utils import get_function_schema, parse_function_arguments
 
+logger = logging.getLogger(__name__)
+
 
 class _ToolCallData(TypedDict):
     """
@@ -102,7 +105,7 @@ async def generate_text(
 
         # Get conversation history from memory (make a copy to avoid modifying memory's internal state)
         messages = list(await memory.get_all())
-        self.logger.debug(f"Retrieved {len(messages)} messages from memory, {len(function_results)} function results")
+        logger.debug(f"Retrieved {len(messages)} messages from memory, {len(function_results)} function results")
 
         # Push current input to memory
         await memory.push(input)
@@ -121,12 +124,12 @@ async def generate_text(
 
         # Convert messages to OpenAI format
         openai_messages = self._convert_messages(input_to_send, system, messages)
-        self.logger.debug(f"Converted to {len(openai_messages)} OpenAI messages")
+        logger.debug(f"Converted to {len(openai_messages)} OpenAI messages")
 
         # Convert functions to OpenAI tools format if provided
         tools = self._convert_functions(functions) if functions else omit
 
-        self.logger.debug(f"Making Chat Completions API call (streaming: {bool(on_chunk)})")
+        logger.debug(f"Making Chat Completions API call (streaming: {bool(on_chunk)})")
 
         # Make OpenAI API call (with streaming if on_chunk provided)
         response = await self._client.chat.completions.create(
@@ -141,14 +144,12 @@ async def generate_text(
 
         # If response has function calls, recursively execute them
         if model_response.function_calls:
-            self.logger.debug(
-                f"Response has {len(model_response.function_calls)} function calls, executing recursively"
-            )
+            logger.debug(f"Response has {len(model_response.function_calls)} function calls, executing recursively")
             return await self.generate_text(model_response, system=system, memory=memory, functions=functions)
 
         # Push response to memory (only if not recursing)
         await memory.push(model_response)
-        self.logger.debug("Chat Completions conversation completed, returning response")
+        logger.debug("Chat Completions conversation completed, returning response")
 
         return model_response
 
@@ -160,7 +161,7 @@ async def _execute_functions(
 
         if isinstance(input, ModelMessage) and input.function_calls:
             # Execute any pending function calls
-            self.logger.debug(f"Executing {len(input.function_calls)} function calls")
+            logger.debug(f"Executing {len(input.function_calls)} function calls")
             for call in input.function_calls:
                 if functions and call.name in functions:
                     function = functions[call.name]
@@ -183,7 +184,7 @@ async def _execute_functions(
                         # Create function result message
                         function_results.append(FunctionMessage(content=fn_res, function_id=call.id))
                     except Exception as e:
-                        self.logger.error(e)
+                        logger.error(e)
                         # Handle function execution errors
                         function_results.append(
                             FunctionMessage(content=f"Function execution failed: {str(e)}", function_id=call.id)
diff --git a/packages/openai/src/microsoft_teams/openai/responses_chat_model.py b/packages/openai/src/microsoft_teams/openai/responses_chat_model.py
index 9a437d53..fb7874ec 100644
--- a/packages/openai/src/microsoft_teams/openai/responses_chat_model.py
+++ b/packages/openai/src/microsoft_teams/openai/responses_chat_model.py
@@ -5,6 +5,7 @@
 
 import inspect
 import json
+import logging
 from dataclasses import dataclass
 from typing import Awaitable, Callable, cast
 
@@ -42,6 +43,8 @@
 from .common import OpenAIBaseModel
 from .function_utils import get_function_schema, parse_function_arguments
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class OpenAIResponsesAIModel(OpenAIBaseModel, AIModel):
@@ -112,7 +115,7 @@ async def _send_stateful(
             if isinstance(msg, ModelMessage) and msg.id:
                 previous_response_id = msg.id
                 break
-        self.logger.debug(f"Found previous response ID: {previous_response_id}")
+        logger.debug(f"Found previous response ID: {previous_response_id}")
         if function_results:
             for result in function_results:
                 await memory.push(result)
@@ -123,7 +126,7 @@ async def _send_stateful(
         # Convert functions to tools format
         tools = self._convert_functions_to_tools(functions) if functions else omit
 
-        self.logger.debug(f"Making Responses API call with input type: {type(input).__name__}")
+        logger.debug(f"Making Responses API call with input type: {type(input).__name__}")
 
         # Make OpenAI Responses API call
         response = await self._client.responses.create(
@@ -134,9 +137,9 @@ async def _send_stateful(
             previous_response_id=previous_response_id,
         )
 
-        self.logger.debug(f"Response API returned: {type(response)}")
-        self.logger.debug(f"Response has content: {hasattr(response, 'content')}")
-        self.logger.debug(f"Response attributes: {[attr for attr in dir(response) if not attr.startswith('_')]}")
+        logger.debug(f"Response API returned: {type(response)}")
+        logger.debug(f"Response has content: {hasattr(response, 'content')}")
+        logger.debug(f"Response attributes: {[attr for attr in dir(response) if not attr.startswith('_')]}")
 
         # Convert response to ModelMessage format
         model_response = self._convert_from_responses_format(response)
@@ -150,15 +153,13 @@ async def _send_stateful(
 
         # If response has function calls, recursively execute them
         if model_response.function_calls:
-            self.logger.debug(
-                f"Response has {len(model_response.function_calls)} function calls, executing recursively"
-            )
+            logger.debug(f"Response has {len(model_response.function_calls)} function calls, executing recursively")
             return await self.generate_text(
                 model_response, system=system, memory=memory, functions=functions, on_chunk=on_chunk
             )
 
-        self.logger.debug("Stateful Responses API conversation completed")
-        self.logger.debug(model_response)
+        logger.debug("Stateful Responses API conversation completed")
+        logger.debug(model_response)
         return model_response
 
     async def _send_stateless(
@@ -173,7 +174,7 @@ async def _send_stateless(
         """Handle stateless conversation using standard OpenAI API pattern."""
         # Get conversation history from memory (make a copy to avoid modifying memory's internal state)
         messages = list(await memory.get_all())
-        self.logger.debug(f"Retrieved {len(messages)} messages from memory")
+        logger.debug(f"Retrieved {len(messages)} messages from memory")
 
         # Push current input to memory
         await memory.push(input)
@@ -191,7 +192,7 @@ async def _send_stateless(
         # Convert functions to tools format
         tools = self._convert_functions_to_tools(functions) if functions else omit
 
-        self.logger.debug(f"Making Responses API call with input type: {type(input).__name__}")
+        logger.debug(f"Making Responses API call with input type: {type(input).__name__}")
 
         # Make OpenAI Responses API call (stateless)
         response = await self._client.responses.create(
@@ -201,20 +202,18 @@ async def _send_stateless(
             tools=tools,
         )
 
-        self.logger.debug(f"Response API returned: {type(response)}")
-        self.logger.debug(f"Response has content: {hasattr(response, 'content')}")
+        logger.debug(f"Response API returned: {type(response)}")
+        logger.debug(f"Response has content: {hasattr(response, 'content')}")
         if hasattr(response, "output"):
-            self.logger.debug(f"Response content: {response.output}")
-        self.logger.debug(f"Response attributes: {[attr for attr in dir(response) if not attr.startswith('_')]}")
+            logger.debug(f"Response content: {response.output}")
+        logger.debug(f"Response attributes: {[attr for attr in dir(response) if not attr.startswith('_')]}")
 
         # Convert response to ModelMessage format
         model_response = self._convert_from_responses_format(response)
 
         # If response has function calls, recursively execute them
         if model_response.function_calls:
-            self.logger.debug(
-                f"Response has {len(model_response.function_calls)} function calls, executing recursively"
-            )
+            logger.debug(f"Response has {len(model_response.function_calls)} function calls, executing recursively")
             return await self.generate_text(model_response, system=system, memory=memory, functions=functions)
 
         # Push response to memory (only if not recursing)
@@ -225,7 +224,7 @@ async def _send_stateless(
             if model_response.content:
                 await on_chunk(model_response.content)
 
-        self.logger.debug("Stateless Responses API conversation completed")
+        logger.debug("Stateless Responses API conversation completed")
         return model_response
 
     async def _execute_functions(
@@ -314,7 +313,7 @@ def _convert_to_responses_format(
                                 }
                             )
                         else:
-                            self.logger.warning(f"No associated result found for call id ({call.name} - {call.id})")
+                            logger.warning(f"No associated result found for call id ({call.name} - {call.id})")
                 else:
                     # ModelMessage with content but no function calls
                     content = message.content or ""
diff --git a/pyproject.toml b/pyproject.toml
index bad5cea2..033ca677 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -25,6 +25,9 @@ dev = [
     "ruff>=0.11.13",
     "pyright>=1.1.404",
     "cookiecutter>=2.6.0",
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "pytest-cov>=6.0.0",
 ]
 release = [
     "nbgv-python>=0.1.8",
@@ -58,6 +61,38 @@ lint = "ruff check"
 check = ["fmt", "lint"]
 test = "pytest"
 generate-activity-handlers = "python packages/apps/scripts/generate_handlers.py"
+test-cov = "pytest --cov=packages --cov-report=term-missing --cov-report=html"
+test-cov-ci = "pytest --cov=packages --cov-report=term-missing"
+test-cov-xml = "pytest --cov=packages --cov-report=xml"
+
+[tool.coverage.run]
+source = ["packages"]
+branch = true
+omit = [
+    "*/tests/*",
+    "*/test_*.py",
+    "*/__pycache__/*",
+    "*/venv/*",
+    "*/.venv/*",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+    "@abstractmethod",
+]
+precision = 2
+show_missing = true
+fail_under = 74
+
+[tool.coverage.html]
+directory = "htmlcov"
+title = "Teams Python SDK Coverage Report"
 
 [tool.hatch.build.targets.wheel]
 packages = ["packages/*"]
diff --git a/uv.lock b/uv.lock
index 42bfd1a9..31f256ca 100644
--- a/uv.lock
+++ b/uv.lock
@@ -15,6 +15,7 @@ members = [
     "dialogs",
     "echo",
     "graph",
+    "http-adapters",
     "mcp-client",
     "mcp-server",
     "meetings",
@@ -31,6 +32,7 @@ members = [
     "microsoft-teams-mcpplugin",
     "microsoft-teams-openai",
     "oauth",
+    "proactive-messaging",
     "reactions",
     "stream",
     "tab",
@@ -43,6 +45,9 @@ dev = [
     { name = "poethepoet", specifier = ">=0.35.0" },
     { name = "pre-commit", specifier = ">=4.2.0" },
     { name = "pyright", specifier = ">=1.1.404" },
+    { name = "pytest", specifier = ">=8.0.0" },
+    { name = "pytest-asyncio", specifier = ">=0.23.0" },
+    { name = "pytest-cov", specifier = ">=6.0.0" },
     { name = "ruff", specifier = ">=0.11.13" },
 ]
 release = [{ name = "nbgv-python", specifier = ">=0.1.8" }]
@@ -112,6 +117,18 @@ requires-dist = [
     { name = "microsoft-teams-openai", editable = "packages/openai" },
 ]
 
+[[package]]
+name = "aiofile"
+version = "3.9.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "caio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/67/e2/d7cb819de8df6b5c1968a2756c3cb4122d4fa2b8fc768b53b7c9e5edb646/aiofile-3.9.0.tar.gz", hash = "sha256:e5ad718bb148b265b6df1b3752c4d1d83024b93da9bd599df74b9d9ffcf7919b", size = 17943, upload-time = "2024-10-08T10:39:35.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/50/25/da1f0b4dd970e52bf5a36c204c107e11a0c6d3ed195eba0bfbc664c312b2/aiofile-3.9.0-py3-none-any.whl", hash = "sha256:ce2f6c1571538cbdfa0143b04e16b208ecb0e9cb4148e528af8a640ed51cc8aa", size = 19539, upload-time = "2024-10-08T10:39:32.955Z" },
+]
+
 [[package]]
 name = "aiohappyeyeballs"
 version = "2.6.1"
@@ -275,14 +292,14 @@ wheels = [
 
 [[package]]
 name = "authlib"
-version = "1.6.6"
+version = "1.6.9"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cryptography" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/bb/9b/b1661026ff24bc641b76b78c5222d614776b0c085bcfdac9bd15a1cb4b35/authlib-1.6.6.tar.gz", hash = "sha256:45770e8e056d0f283451d9996fbb59b70d45722b45d854d58f32878d0a40c38e", size = 164894, upload-time = "2025-12-12T08:01:41.464Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/98/00d3dd826d46959ad8e32af2dbb2398868fd9fd0683c26e56d0789bd0e68/authlib-1.6.9.tar.gz", hash = "sha256:d8f2421e7e5980cc1ddb4e32d3f5fa659cfaf60d8eaf3281ebed192e4ab74f04", size = 165134, upload-time = "2026-03-02T07:44:01.998Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/54/51/321e821856452f7386c4e9df866f196720b1ad0c5ea1623ea7399969ae3b/authlib-1.6.6-py2.py3-none-any.whl", hash = "sha256:7d9e9bc535c13974313a87f53e8430eb6ea3d1cf6ae4f6efcd793f2e949143fd", size = 244005, upload-time = "2025-12-12T08:01:40.209Z" },
+    { url = "https://files.pythonhosted.org/packages/53/23/b65f568ed0c22f1efacb744d2db1a33c8068f384b8c9b482b52ebdbc3ef6/authlib-1.6.9-py2.py3-none-any.whl", hash = "sha256:f08b4c14e08f0861dc18a32357b33fbcfd2ea86cfe3fe149484b4d764c4a0ac3", size = 244197, upload-time = "2026-03-02T07:44:00.307Z" },
 ]
 
 [[package]]
@@ -432,6 +449,27 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/96/c5/1e741d26306c42e2bf6ab740b2202872727e0f606033c9dd713f8b93f5a8/cachetools-6.2.1-py3-none-any.whl", hash = "sha256:09868944b6dde876dfd44e1d47e18484541eaf12f26f29b7af91b26cc892d701", size = 11280, upload-time = "2025-10-12T14:55:28.382Z" },
 ]
 
+[[package]]
+name = "caio"
+version = "0.9.25"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/92/88/b8527e1b00c1811db339a1df8bd1ae49d146fcea9d6a5c40e3a80aaeb38d/caio-0.9.25.tar.gz", hash = "sha256:16498e7f81d1d0f5a4c0ad3f2540e65fe25691376e0a5bd367f558067113ed10", size = 26781, upload-time = "2025-12-26T15:21:36.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d3/25/79c98ebe12df31548ba4eaf44db11b7cad6b3e7b4203718335620939083c/caio-0.9.25-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fb7ff95af4c31ad3f03179149aab61097a71fd85e05f89b4786de0359dffd044", size = 36983, upload-time = "2025-12-26T15:21:36.075Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/2b/21288691f16d479945968a0a4f2856818c1c5be56881d51d4dac9b255d26/caio-0.9.25-cp312-cp312-manylinux2010_x86_64.manylinux2014_x86_64.manylinux_2_12_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:97084e4e30dfa598449d874c4d8e0c8d5ea17d2f752ef5e48e150ff9d240cd64", size = 82012, upload-time = "2025-12-26T15:22:20.983Z" },
+    { url = "https://files.pythonhosted.org/packages/03/c4/8a1b580875303500a9c12b9e0af58cb82e47f5bcf888c2457742a138273c/caio-0.9.25-cp312-cp312-manylinux_2_34_aarch64.whl", hash = "sha256:4fa69eba47e0f041b9d4f336e2ad40740681c43e686b18b191b6c5f4c5544bfb", size = 81502, upload-time = "2026-03-04T22:08:22.381Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/1c/0fe770b8ffc8362c48134d1592d653a81a3d8748d764bec33864db36319d/caio-0.9.25-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:6bebf6f079f1341d19f7386db9b8b1f07e8cc15ae13bfdaff573371ba0575d69", size = 80200, upload-time = "2026-03-04T22:08:23.382Z" },
+    { url = "https://files.pythonhosted.org/packages/31/57/5e6ff127e6f62c9f15d989560435c642144aa4210882f9494204bc892305/caio-0.9.25-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d6c2a3411af97762a2b03840c3cec2f7f728921ff8adda53d7ea2315a8563451", size = 36979, upload-time = "2025-12-26T15:21:35.484Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/9f/f21af50e72117eb528c422d4276cbac11fb941b1b812b182e0a9c70d19c5/caio-0.9.25-cp313-cp313-manylinux2010_x86_64.manylinux2014_x86_64.manylinux_2_12_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0998210a4d5cd5cb565b32ccfe4e53d67303f868a76f212e002a8554692870e6", size = 81900, upload-time = "2025-12-26T15:22:21.919Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/12/c39ae2a4037cb10ad5eb3578eb4d5f8c1a2575c62bba675f3406b7ef0824/caio-0.9.25-cp313-cp313-manylinux_2_34_aarch64.whl", hash = "sha256:1a177d4777141b96f175fe2c37a3d96dec7911ed9ad5f02bac38aaa1c936611f", size = 81523, upload-time = "2026-03-04T22:08:25.187Z" },
+    { url = "https://files.pythonhosted.org/packages/22/59/f8f2e950eb4f1a5a3883e198dca514b9d475415cb6cd7b78b9213a0dd45a/caio-0.9.25-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:9ed3cfb28c0e99fec5e208c934e5c157d0866aa9c32aa4dc5e9b6034af6286b7", size = 80243, upload-time = "2026-03-04T22:08:26.449Z" },
+    { url = "https://files.pythonhosted.org/packages/69/ca/a08fdc7efdcc24e6a6131a93c85be1f204d41c58f474c42b0670af8c016b/caio-0.9.25-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fab6078b9348e883c80a5e14b382e6ad6aabbc4429ca034e76e730cf464269db", size = 36978, upload-time = "2025-12-26T15:21:41.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/6c/d4d24f65e690213c097174d26eda6831f45f4734d9d036d81790a27e7b78/caio-0.9.25-cp314-cp314-manylinux2010_x86_64.manylinux2014_x86_64.manylinux_2_12_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:44a6b58e52d488c75cfaa5ecaa404b2b41cc965e6c417e03251e868ecd5b6d77", size = 81832, upload-time = "2025-12-26T15:22:22.757Z" },
+    { url = "https://files.pythonhosted.org/packages/87/a4/e534cf7d2d0e8d880e25dd61e8d921ffcfe15bd696734589826f5a2df727/caio-0.9.25-cp314-cp314-manylinux_2_34_aarch64.whl", hash = "sha256:628a630eb7fb22381dd8e3c8ab7f59e854b9c806639811fc3f4310c6bd711d79", size = 81565, upload-time = "2026-03-04T22:08:27.483Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/ed/bf81aeac1d290017e5e5ac3e880fd56ee15e50a6d0353986799d1bc5cfd5/caio-0.9.25-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:0ba16aa605ccb174665357fc729cf500679c2d94d5f1458a6f0d5ca48f2060a7", size = 80071, upload-time = "2026-03-04T22:08:28.751Z" },
+    { url = "https://files.pythonhosted.org/packages/86/93/1f76c8d1bafe3b0614e06b2195784a3765bbf7b0a067661af9e2dd47fc33/caio-0.9.25-py3-none-any.whl", hash = "sha256:06c0bb02d6b929119b1cfbe1ca403c768b2013a369e2db46bfa2a5761cf82e40", size = 19087, upload-time = "2025-12-26T15:22:00.221Z" },
+]
+
 [[package]]
 name = "cards"
 version = "0.1.0"
@@ -602,15 +640,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/db/d3/9dcc0f5797f070ec8edf30fbadfb200e71d9db6b84d211e3b2085a7589a0/click-8.3.0-py3-none-any.whl", hash = "sha256:9b9f285302c6e3064f4330c05f05b81945b2a39544279343e6e7c5f27a9baddc", size = 107295, upload-time = "2025-09-18T17:32:22.42Z" },
 ]
 
-[[package]]
-name = "cloudpickle"
-version = "3.1.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", hash = "sha256:7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414", size = 22330, upload-time = "2025-11-03T09:25:26.604Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", hash = "sha256:9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a", size = 22228, upload-time = "2025-11-03T09:25:25.534Z" },
-]
-
 [[package]]
 name = "colorama"
 version = "0.4.6"
@@ -715,58 +744,55 @@ wheels = [
 
 [[package]]
 name = "cryptography"
-version = "46.0.3"
+version = "46.0.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9f/33/c00162f49c0e2fe8064a62cb92b93e50c74a72bc370ab92f86112b33ff62/cryptography-46.0.3.tar.gz", hash = "sha256:a8b17438104fed022ce745b362294d9ce35b4c2e45c1d958ad4a4b019285f4a1", size = 749258, upload-time = "2025-10-15T23:18:31.74Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/1d/42/9c391dd801d6cf0d561b5890549d4b27bafcc53b39c31a817e69d87c625b/cryptography-46.0.3-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:109d4ddfadf17e8e7779c39f9b18111a09efb969a301a31e987416a0191ed93a", size = 7225004, upload-time = "2025-10-15T23:16:52.239Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/67/38769ca6b65f07461eb200e85fc1639b438bdc667be02cf7f2cd6a64601c/cryptography-46.0.3-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:09859af8466b69bc3c27bdf4f5d84a665e0f7ab5088412e9e2ec49758eca5cbc", size = 4296667, upload-time = "2025-10-15T23:16:54.369Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/49/498c86566a1d80e978b42f0d702795f69887005548c041636df6ae1ca64c/cryptography-46.0.3-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:01ca9ff2885f3acc98c29f1860552e37f6d7c7d013d7334ff2a9de43a449315d", size = 4450807, upload-time = "2025-10-15T23:16:56.414Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/0a/863a3604112174c8624a2ac3c038662d9e59970c7f926acdcfaed8d61142/cryptography-46.0.3-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:6eae65d4c3d33da080cff9c4ab1f711b15c1d9760809dad6ea763f3812d254cb", size = 4299615, upload-time = "2025-10-15T23:16:58.442Z" },
-    { url = "https://files.pythonhosted.org/packages/64/02/b73a533f6b64a69f3cd3872acb6ebc12aef924d8d103133bb3ea750dc703/cryptography-46.0.3-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5bf0ed4490068a2e72ac03d786693adeb909981cc596425d09032d372bcc849", size = 4016800, upload-time = "2025-10-15T23:17:00.378Z" },
-    { url = "https://files.pythonhosted.org/packages/25/d5/16e41afbfa450cde85a3b7ec599bebefaef16b5c6ba4ec49a3532336ed72/cryptography-46.0.3-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:5ecfccd2329e37e9b7112a888e76d9feca2347f12f37918facbb893d7bb88ee8", size = 4984707, upload-time = "2025-10-15T23:17:01.98Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/56/e7e69b427c3878352c2fb9b450bd0e19ed552753491d39d7d0a2f5226d41/cryptography-46.0.3-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a2c0cd47381a3229c403062f764160d57d4d175e022c1df84e168c6251a22eec", size = 4482541, upload-time = "2025-10-15T23:17:04.078Z" },
-    { url = "https://files.pythonhosted.org/packages/78/f6/50736d40d97e8483172f1bb6e698895b92a223dba513b0ca6f06b2365339/cryptography-46.0.3-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:549e234ff32571b1f4076ac269fcce7a808d3bf98b76c8dd560e42dbc66d7d91", size = 4299464, upload-time = "2025-10-15T23:17:05.483Z" },
-    { url = "https://files.pythonhosted.org/packages/00/de/d8e26b1a855f19d9994a19c702fa2e93b0456beccbcfe437eda00e0701f2/cryptography-46.0.3-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:c0a7bb1a68a5d3471880e264621346c48665b3bf1c3759d682fc0864c540bd9e", size = 4950838, upload-time = "2025-10-15T23:17:07.425Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/29/798fc4ec461a1c9e9f735f2fc58741b0daae30688f41b2497dcbc9ed1355/cryptography-46.0.3-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:10b01676fc208c3e6feeb25a8b83d81767e8059e1fe86e1dc62d10a3018fa926", size = 4481596, upload-time = "2025-10-15T23:17:09.343Z" },
-    { url = "https://files.pythonhosted.org/packages/15/8d/03cd48b20a573adfff7652b76271078e3045b9f49387920e7f1f631d125e/cryptography-46.0.3-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0abf1ffd6e57c67e92af68330d05760b7b7efb243aab8377e583284dbab72c71", size = 4426782, upload-time = "2025-10-15T23:17:11.22Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/b1/ebacbfe53317d55cf33165bda24c86523497a6881f339f9aae5c2e13e57b/cryptography-46.0.3-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a04bee9ab6a4da801eb9b51f1b708a1b5b5c9eb48c03f74198464c66f0d344ac", size = 4698381, upload-time = "2025-10-15T23:17:12.829Z" },
-    { url = "https://files.pythonhosted.org/packages/96/92/8a6a9525893325fc057a01f654d7efc2c64b9de90413adcf605a85744ff4/cryptography-46.0.3-cp311-abi3-win32.whl", hash = "sha256:f260d0d41e9b4da1ed1e0f1ce571f97fe370b152ab18778e9e8f67d6af432018", size = 3055988, upload-time = "2025-10-15T23:17:14.65Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/bf/80fbf45253ea585a1e492a6a17efcb93467701fa79e71550a430c5e60df0/cryptography-46.0.3-cp311-abi3-win_amd64.whl", hash = "sha256:a9a3008438615669153eb86b26b61e09993921ebdd75385ddd748702c5adfddb", size = 3514451, upload-time = "2025-10-15T23:17:16.142Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/af/9b302da4c87b0beb9db4e756386a7c6c5b8003cd0e742277888d352ae91d/cryptography-46.0.3-cp311-abi3-win_arm64.whl", hash = "sha256:5d7f93296ee28f68447397bf5198428c9aeeab45705a55d53a6343455dcb2c3c", size = 2928007, upload-time = "2025-10-15T23:17:18.04Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/e2/a510aa736755bffa9d2f75029c229111a1d02f8ecd5de03078f4c18d91a3/cryptography-46.0.3-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:00a5e7e87938e5ff9ff5447ab086a5706a957137e6e433841e9d24f38a065217", size = 7158012, upload-time = "2025-10-15T23:17:19.982Z" },
-    { url = "https://files.pythonhosted.org/packages/73/dc/9aa866fbdbb95b02e7f9d086f1fccfeebf8953509b87e3f28fff927ff8a0/cryptography-46.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c8daeb2d2174beb4575b77482320303f3d39b8e81153da4f0fb08eb5fe86a6c5", size = 4288728, upload-time = "2025-10-15T23:17:21.527Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/fd/bc1daf8230eaa075184cbbf5f8cd00ba9db4fd32d63fb83da4671b72ed8a/cryptography-46.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:39b6755623145ad5eff1dab323f4eae2a32a77a7abef2c5089a04a3d04366715", size = 4435078, upload-time = "2025-10-15T23:17:23.042Z" },
-    { url = "https://files.pythonhosted.org/packages/82/98/d3bd5407ce4c60017f8ff9e63ffee4200ab3e23fe05b765cab805a7db008/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:db391fa7c66df6762ee3f00c95a89e6d428f4d60e7abc8328f4fe155b5ac6e54", size = 4293460, upload-time = "2025-10-15T23:17:24.885Z" },
-    { url = "https://files.pythonhosted.org/packages/26/e9/e23e7900983c2b8af7a08098db406cf989d7f09caea7897e347598d4cd5b/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:78a97cf6a8839a48c49271cdcbd5cf37ca2c1d6b7fdd86cc864f302b5e9bf459", size = 3995237, upload-time = "2025-10-15T23:17:26.449Z" },
-    { url = "https://files.pythonhosted.org/packages/91/15/af68c509d4a138cfe299d0d7ddb14afba15233223ebd933b4bbdbc7155d3/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:dfb781ff7eaa91a6f7fd41776ec37c5853c795d3b358d4896fdbb5df168af422", size = 4967344, upload-time = "2025-10-15T23:17:28.06Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/e3/8643d077c53868b681af077edf6b3cb58288b5423610f21c62aadcbe99f4/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:6f61efb26e76c45c4a227835ddeae96d83624fb0d29eb5df5b96e14ed1a0afb7", size = 4466564, upload-time = "2025-10-15T23:17:29.665Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/43/c1e8726fa59c236ff477ff2b5dc071e54b21e5a1e51aa2cee1676f1c986f/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:23b1a8f26e43f47ceb6d6a43115f33a5a37d57df4ea0ca295b780ae8546e8044", size = 4292415, upload-time = "2025-10-15T23:17:31.686Z" },
-    { url = "https://files.pythonhosted.org/packages/42/f9/2f8fefdb1aee8a8e3256a0568cffc4e6d517b256a2fe97a029b3f1b9fe7e/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:b419ae593c86b87014b9be7396b385491ad7f320bde96826d0dd174459e54665", size = 4931457, upload-time = "2025-10-15T23:17:33.478Z" },
-    { url = "https://files.pythonhosted.org/packages/79/30/9b54127a9a778ccd6d27c3da7563e9f2d341826075ceab89ae3b41bf5be2/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:50fc3343ac490c6b08c0cf0d704e881d0d660be923fd3076db3e932007e726e3", size = 4466074, upload-time = "2025-10-15T23:17:35.158Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/68/b4f4a10928e26c941b1b6a179143af9f4d27d88fe84a6a3c53592d2e76bf/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:22d7e97932f511d6b0b04f2bfd818d73dcd5928db509460aaf48384778eb6d20", size = 4420569, upload-time = "2025-10-15T23:17:37.188Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/49/3746dab4c0d1979888f125226357d3262a6dd40e114ac29e3d2abdf1ec55/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d55f3dffadd674514ad19451161118fd010988540cee43d8bc20675e775925de", size = 4681941, upload-time = "2025-10-15T23:17:39.236Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/30/27654c1dbaf7e4a3531fa1fc77986d04aefa4d6d78259a62c9dc13d7ad36/cryptography-46.0.3-cp314-cp314t-win32.whl", hash = "sha256:8a6e050cb6164d3f830453754094c086ff2d0b2f3a897a1d9820f6139a1f0914", size = 3022339, upload-time = "2025-10-15T23:17:40.888Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/30/640f34ccd4d2a1bc88367b54b926b781b5a018d65f404d409aba76a84b1c/cryptography-46.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:760f83faa07f8b64e9c33fc963d790a2edb24efb479e3520c14a45741cd9b2db", size = 3494315, upload-time = "2025-10-15T23:17:42.769Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/8b/88cc7e3bd0a8e7b861f26981f7b820e1f46aa9d26cc482d0feba0ecb4919/cryptography-46.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:516ea134e703e9fe26bcd1277a4b59ad30586ea90c365a87781d7887a646fe21", size = 2919331, upload-time = "2025-10-15T23:17:44.468Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/23/45fe7f376a7df8daf6da3556603b36f53475a99ce4faacb6ba2cf3d82021/cryptography-46.0.3-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:cb3d760a6117f621261d662bccc8ef5bc32ca673e037c83fbe565324f5c46936", size = 7218248, upload-time = "2025-10-15T23:17:46.294Z" },
-    { url = "https://files.pythonhosted.org/packages/27/32/b68d27471372737054cbd34c84981f9edbc24fe67ca225d389799614e27f/cryptography-46.0.3-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4b7387121ac7d15e550f5cb4a43aef2559ed759c35df7336c402bb8275ac9683", size = 4294089, upload-time = "2025-10-15T23:17:48.269Z" },
-    { url = "https://files.pythonhosted.org/packages/26/42/fa8389d4478368743e24e61eea78846a0006caffaf72ea24a15159215a14/cryptography-46.0.3-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:15ab9b093e8f09daab0f2159bb7e47532596075139dd74365da52ecc9cb46c5d", size = 4440029, upload-time = "2025-10-15T23:17:49.837Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/eb/f483db0ec5ac040824f269e93dd2bd8a21ecd1027e77ad7bdf6914f2fd80/cryptography-46.0.3-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:46acf53b40ea38f9c6c229599a4a13f0d46a6c3fa9ef19fc1a124d62e338dfa0", size = 4297222, upload-time = "2025-10-15T23:17:51.357Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/cf/da9502c4e1912cb1da3807ea3618a6829bee8207456fbbeebc361ec38ba3/cryptography-46.0.3-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:10ca84c4668d066a9878890047f03546f3ae0a6b8b39b697457b7757aaf18dbc", size = 4012280, upload-time = "2025-10-15T23:17:52.964Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/8f/9adb86b93330e0df8b3dcf03eae67c33ba89958fc2e03862ef1ac2b42465/cryptography-46.0.3-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:36e627112085bb3b81b19fed209c05ce2a52ee8b15d161b7c643a7d5a88491f3", size = 4978958, upload-time = "2025-10-15T23:17:54.965Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/a0/5fa77988289c34bdb9f913f5606ecc9ada1adb5ae870bd0d1054a7021cc4/cryptography-46.0.3-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1000713389b75c449a6e979ffc7dcc8ac90b437048766cef052d4d30b8220971", size = 4473714, upload-time = "2025-10-15T23:17:56.754Z" },
-    { url = "https://files.pythonhosted.org/packages/14/e5/fc82d72a58d41c393697aa18c9abe5ae1214ff6f2a5c18ac470f92777895/cryptography-46.0.3-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:b02cf04496f6576afffef5ddd04a0cb7d49cf6be16a9059d793a30b035f6b6ac", size = 4296970, upload-time = "2025-10-15T23:17:58.588Z" },
-    { url = "https://files.pythonhosted.org/packages/78/06/5663ed35438d0b09056973994f1aec467492b33bd31da36e468b01ec1097/cryptography-46.0.3-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:71e842ec9bc7abf543b47cf86b9a743baa95f4677d22baa4c7d5c69e49e9bc04", size = 4940236, upload-time = "2025-10-15T23:18:00.897Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/59/873633f3f2dcd8a053b8dd1d38f783043b5fce589c0f6988bf55ef57e43e/cryptography-46.0.3-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:402b58fc32614f00980b66d6e56a5b4118e6cb362ae8f3fda141ba4689bd4506", size = 4472642, upload-time = "2025-10-15T23:18:02.749Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/39/8e71f3930e40f6877737d6f69248cf74d4e34b886a3967d32f919cc50d3b/cryptography-46.0.3-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ef639cb3372f69ec44915fafcd6698b6cc78fbe0c2ea41be867f6ed612811963", size = 4423126, upload-time = "2025-10-15T23:18:04.85Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/c7/f65027c2810e14c3e7268353b1681932b87e5a48e65505d8cc17c99e36ae/cryptography-46.0.3-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3b51b8ca4f1c6453d8829e1eb7299499ca7f313900dd4d89a24b8b87c0a780d4", size = 4686573, upload-time = "2025-10-15T23:18:06.908Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/6e/1c8331ddf91ca4730ab3086a0f1be19c65510a33b5a441cb334e7a2d2560/cryptography-46.0.3-cp38-abi3-win32.whl", hash = "sha256:6276eb85ef938dc035d59b87c8a7dc559a232f954962520137529d77b18ff1df", size = 3036695, upload-time = "2025-10-15T23:18:08.672Z" },
-    { url = "https://files.pythonhosted.org/packages/90/45/b0d691df20633eff80955a0fc7695ff9051ffce8b69741444bd9ed7bd0db/cryptography-46.0.3-cp38-abi3-win_amd64.whl", hash = "sha256:416260257577718c05135c55958b674000baef9a1c7d9e8f306ec60d71db850f", size = 3501720, upload-time = "2025-10-15T23:18:10.632Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/cb/2da4cc83f5edb9c3257d09e1e7ab7b23f049c7962cae8d842bbef0a9cec9/cryptography-46.0.3-cp38-abi3-win_arm64.whl", hash = "sha256:d89c3468de4cdc4f08a57e214384d0471911a3830fcdaf7a8cc587e42a866372", size = 2918740, upload-time = "2025-10-15T23:18:12.277Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/60/04/ee2a9e8542e4fa2773b81771ff8349ff19cdd56b7258a0cc442639052edb/cryptography-46.0.5.tar.gz", hash = "sha256:abace499247268e3757271b2f1e244b36b06f8515cf27c4d49468fc9eb16e93d", size = 750064, upload-time = "2026-02-10T19:18:38.255Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f7/81/b0bb27f2ba931a65409c6b8a8b358a7f03c0e46eceacddff55f7c84b1f3b/cryptography-46.0.5-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:351695ada9ea9618b3500b490ad54c739860883df6c1f555e088eaf25b1bbaad", size = 7176289, upload-time = "2026-02-10T19:17:08.274Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/9e/6b4397a3e3d15123de3b1806ef342522393d50736c13b20ec4c9ea6693a6/cryptography-46.0.5-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c18ff11e86df2e28854939acde2d003f7984f721eba450b56a200ad90eeb0e6b", size = 4275637, upload-time = "2026-02-10T19:17:10.53Z" },
+    { url = "https://files.pythonhosted.org/packages/63/e7/471ab61099a3920b0c77852ea3f0ea611c9702f651600397ac567848b897/cryptography-46.0.5-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d7e3d356b8cd4ea5aff04f129d5f66ebdc7b6f8eae802b93739ed520c47c79b", size = 4424742, upload-time = "2026-02-10T19:17:12.388Z" },
+    { url = "https://files.pythonhosted.org/packages/37/53/a18500f270342d66bf7e4d9f091114e31e5ee9e7375a5aba2e85a91e0044/cryptography-46.0.5-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:50bfb6925eff619c9c023b967d5b77a54e04256c4281b0e21336a130cd7fc263", size = 4277528, upload-time = "2026-02-10T19:17:13.853Z" },
+    { url = "https://files.pythonhosted.org/packages/22/29/c2e812ebc38c57b40e7c583895e73c8c5adb4d1e4a0cc4c5a4fdab2b1acc/cryptography-46.0.5-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:803812e111e75d1aa73690d2facc295eaefd4439be1023fefc4995eaea2af90d", size = 4947993, upload-time = "2026-02-10T19:17:15.618Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/e7/237155ae19a9023de7e30ec64e5d99a9431a567407ac21170a046d22a5a3/cryptography-46.0.5-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ee190460e2fbe447175cda91b88b84ae8322a104fc27766ad09428754a618ed", size = 4456855, upload-time = "2026-02-10T19:17:17.221Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/87/fc628a7ad85b81206738abbd213b07702bcbdada1dd43f72236ef3cffbb5/cryptography-46.0.5-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:f145bba11b878005c496e93e257c1e88f154d278d2638e6450d17e0f31e558d2", size = 3984635, upload-time = "2026-02-10T19:17:18.792Z" },
+    { url = "https://files.pythonhosted.org/packages/84/29/65b55622bde135aedf4565dc509d99b560ee4095e56989e815f8fd2aa910/cryptography-46.0.5-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:e9251e3be159d1020c4030bd2e5f84d6a43fe54b6c19c12f51cde9542a2817b2", size = 4277038, upload-time = "2026-02-10T19:17:20.256Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/36/45e76c68d7311432741faf1fbf7fac8a196a0a735ca21f504c75d37e2558/cryptography-46.0.5-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:47fb8a66058b80e509c47118ef8a75d14c455e81ac369050f20ba0d23e77fee0", size = 4912181, upload-time = "2026-02-10T19:17:21.825Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/1a/c1ba8fead184d6e3d5afcf03d569acac5ad063f3ac9fb7258af158f7e378/cryptography-46.0.5-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:4c3341037c136030cb46e4b1e17b7418ea4cbd9dd207e4a6f3b2b24e0d4ac731", size = 4456482, upload-time = "2026-02-10T19:17:25.133Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/e5/3fb22e37f66827ced3b902cf895e6a6bc1d095b5b26be26bd13c441fdf19/cryptography-46.0.5-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:890bcb4abd5a2d3f852196437129eb3667d62630333aacc13dfd470fad3aaa82", size = 4405497, upload-time = "2026-02-10T19:17:26.66Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/df/9d58bb32b1121a8a2f27383fabae4d63080c7ca60b9b5c88be742be04ee7/cryptography-46.0.5-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:80a8d7bfdf38f87ca30a5391c0c9ce4ed2926918e017c29ddf643d0ed2778ea1", size = 4667819, upload-time = "2026-02-10T19:17:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/ed/325d2a490c5e94038cdb0117da9397ece1f11201f425c4e9c57fe5b9f08b/cryptography-46.0.5-cp311-abi3-win32.whl", hash = "sha256:60ee7e19e95104d4c03871d7d7dfb3d22ef8a9b9c6778c94e1c8fcc8365afd48", size = 3028230, upload-time = "2026-02-10T19:17:30.518Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/5a/ac0f49e48063ab4255d9e3b79f5def51697fce1a95ea1370f03dc9db76f6/cryptography-46.0.5-cp311-abi3-win_amd64.whl", hash = "sha256:38946c54b16c885c72c4f59846be9743d699eee2b69b6988e0a00a01f46a61a4", size = 3480909, upload-time = "2026-02-10T19:17:32.083Z" },
+    { url = "https://files.pythonhosted.org/packages/00/13/3d278bfa7a15a96b9dc22db5a12ad1e48a9eb3d40e1827ef66a5df75d0d0/cryptography-46.0.5-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:94a76daa32eb78d61339aff7952ea819b1734b46f73646a07decb40e5b3448e2", size = 7119287, upload-time = "2026-02-10T19:17:33.801Z" },
+    { url = "https://files.pythonhosted.org/packages/67/c8/581a6702e14f0898a0848105cbefd20c058099e2c2d22ef4e476dfec75d7/cryptography-46.0.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5be7bf2fb40769e05739dd0046e7b26f9d4670badc7b032d6ce4db64dddc0678", size = 4265728, upload-time = "2026-02-10T19:17:35.569Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/4a/ba1a65ce8fc65435e5a849558379896c957870dd64fecea97b1ad5f46a37/cryptography-46.0.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fe346b143ff9685e40192a4960938545c699054ba11d4f9029f94751e3f71d87", size = 4408287, upload-time = "2026-02-10T19:17:36.938Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/67/8ffdbf7b65ed1ac224d1c2df3943553766914a8ca718747ee3871da6107e/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:c69fd885df7d089548a42d5ec05be26050ebcd2283d89b3d30676eb32ff87dee", size = 4270291, upload-time = "2026-02-10T19:17:38.748Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e5/f52377ee93bc2f2bba55a41a886fd208c15276ffbd2569f2ddc89d50e2c5/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:8293f3dea7fc929ef7240796ba231413afa7b68ce38fd21da2995549f5961981", size = 4927539, upload-time = "2026-02-10T19:17:40.241Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/02/cfe39181b02419bbbbcf3abdd16c1c5c8541f03ca8bda240debc467d5a12/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:1abfdb89b41c3be0365328a410baa9df3ff8a9110fb75e7b52e66803ddabc9a9", size = 4442199, upload-time = "2026-02-10T19:17:41.789Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/96/2fcaeb4873e536cf71421a388a6c11b5bc846e986b2b069c79363dc1648e/cryptography-46.0.5-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:d66e421495fdb797610a08f43b05269e0a5ea7f5e652a89bfd5a7d3c1dee3648", size = 3960131, upload-time = "2026-02-10T19:17:43.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/d2/b27631f401ddd644e94c5cf33c9a4069f72011821cf3dc7309546b0642a0/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:4e817a8920bfbcff8940ecfd60f23d01836408242b30f1a708d93198393a80b4", size = 4270072, upload-time = "2026-02-10T19:17:45.481Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/a7/60d32b0370dae0b4ebe55ffa10e8599a2a59935b5ece1b9f06edb73abdeb/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:68f68d13f2e1cb95163fa3b4db4bf9a159a418f5f6e7242564fc75fcae667fd0", size = 4892170, upload-time = "2026-02-10T19:17:46.997Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/b9/cf73ddf8ef1164330eb0b199a589103c363afa0cf794218c24d524a58eab/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:a3d1fae9863299076f05cb8a778c467578262fae09f9dc0ee9b12eb4268ce663", size = 4441741, upload-time = "2026-02-10T19:17:48.661Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/eb/eee00b28c84c726fe8fa0158c65afe312d9c3b78d9d01daf700f1f6e37ff/cryptography-46.0.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4143987a42a2397f2fc3b4d7e3a7d313fbe684f67ff443999e803dd75a76826", size = 4396728, upload-time = "2026-02-10T19:17:50.058Z" },
+    { url = "https://files.pythonhosted.org/packages/65/f4/6bc1a9ed5aef7145045114b75b77c2a8261b4d38717bd8dea111a63c3442/cryptography-46.0.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:7d731d4b107030987fd61a7f8ab512b25b53cef8f233a97379ede116f30eb67d", size = 4652001, upload-time = "2026-02-10T19:17:51.54Z" },
+    { url = "https://files.pythonhosted.org/packages/86/ef/5d00ef966ddd71ac2e6951d278884a84a40ffbd88948ef0e294b214ae9e4/cryptography-46.0.5-cp314-cp314t-win32.whl", hash = "sha256:c3bcce8521d785d510b2aad26ae2c966092b7daa8f45dd8f44734a104dc0bc1a", size = 3003637, upload-time = "2026-02-10T19:17:52.997Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/57/f3f4160123da6d098db78350fdfd9705057aad21de7388eacb2401dceab9/cryptography-46.0.5-cp314-cp314t-win_amd64.whl", hash = "sha256:4d8ae8659ab18c65ced284993c2265910f6c9e650189d4e3f68445ef82a810e4", size = 3469487, upload-time = "2026-02-10T19:17:54.549Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/fa/a66aa722105ad6a458bebd64086ca2b72cdd361fed31763d20390f6f1389/cryptography-46.0.5-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:4108d4c09fbbf2789d0c926eb4152ae1760d5a2d97612b92d508d96c861e4d31", size = 7170514, upload-time = "2026-02-10T19:17:56.267Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/04/c85bdeab78c8bc77b701bf0d9bdcf514c044e18a46dcff330df5448631b0/cryptography-46.0.5-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d1f30a86d2757199cb2d56e48cce14deddf1f9c95f1ef1b64ee91ea43fe2e18", size = 4275349, upload-time = "2026-02-10T19:17:58.419Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/32/9b87132a2f91ee7f5223b091dc963055503e9b442c98fc0b8a5ca765fab0/cryptography-46.0.5-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:039917b0dc418bb9f6edce8a906572d69e74bd330b0b3fea4f79dab7f8ddd235", size = 4420667, upload-time = "2026-02-10T19:18:00.619Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/a6/a7cb7010bec4b7c5692ca6f024150371b295ee1c108bdc1c400e4c44562b/cryptography-46.0.5-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:ba2a27ff02f48193fc4daeadf8ad2590516fa3d0adeeb34336b96f7fa64c1e3a", size = 4276980, upload-time = "2026-02-10T19:18:02.379Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/7c/c4f45e0eeff9b91e3f12dbd0e165fcf2a38847288fcfd889deea99fb7b6d/cryptography-46.0.5-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:61aa400dce22cb001a98014f647dc21cda08f7915ceb95df0c9eaf84b4b6af76", size = 4939143, upload-time = "2026-02-10T19:18:03.964Z" },
+    { url = "https://files.pythonhosted.org/packages/37/19/e1b8f964a834eddb44fa1b9a9976f4e414cbb7aa62809b6760c8803d22d1/cryptography-46.0.5-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ce58ba46e1bc2aac4f7d9290223cead56743fa6ab94a5d53292ffaac6a91614", size = 4453674, upload-time = "2026-02-10T19:18:05.588Z" },
+    { url = "https://files.pythonhosted.org/packages/db/ed/db15d3956f65264ca204625597c410d420e26530c4e2943e05a0d2f24d51/cryptography-46.0.5-cp38-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:420d0e909050490d04359e7fdb5ed7e667ca5c3c402b809ae2563d7e66a92229", size = 3978801, upload-time = "2026-02-10T19:18:07.167Z" },
+    { url = "https://files.pythonhosted.org/packages/41/e2/df40a31d82df0a70a0daf69791f91dbb70e47644c58581d654879b382d11/cryptography-46.0.5-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:582f5fcd2afa31622f317f80426a027f30dc792e9c80ffee87b993200ea115f1", size = 4276755, upload-time = "2026-02-10T19:18:09.813Z" },
+    { url = "https://files.pythonhosted.org/packages/33/45/726809d1176959f4a896b86907b98ff4391a8aa29c0aaaf9450a8a10630e/cryptography-46.0.5-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:bfd56bb4b37ed4f330b82402f6f435845a5f5648edf1ad497da51a8452d5d62d", size = 4901539, upload-time = "2026-02-10T19:18:11.263Z" },
+    { url = "https://files.pythonhosted.org/packages/99/0f/a3076874e9c88ecb2ecc31382f6e7c21b428ede6f55aafa1aa272613e3cd/cryptography-46.0.5-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:a3d507bb6a513ca96ba84443226af944b0f7f47dcc9a399d110cd6146481d24c", size = 4452794, upload-time = "2026-02-10T19:18:12.914Z" },
+    { url = "https://files.pythonhosted.org/packages/02/ef/ffeb542d3683d24194a38f66ca17c0a4b8bf10631feef44a7ef64e631b1a/cryptography-46.0.5-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9f16fbdf4da055efb21c22d81b89f155f02ba420558db21288b3d0035bafd5f4", size = 4404160, upload-time = "2026-02-10T19:18:14.375Z" },
+    { url = "https://files.pythonhosted.org/packages/96/93/682d2b43c1d5f1406ed048f377c0fc9fc8f7b0447a478d5c65ab3d3a66eb/cryptography-46.0.5-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ced80795227d70549a411a4ab66e8ce307899fad2220ce5ab2f296e687eacde9", size = 4667123, upload-time = "2026-02-10T19:18:15.886Z" },
+    { url = "https://files.pythonhosted.org/packages/45/2d/9c5f2926cb5300a8eefc3f4f0b3f3df39db7f7ce40c8365444c49363cbda/cryptography-46.0.5-cp38-abi3-win32.whl", hash = "sha256:02f547fce831f5096c9a567fd41bc12ca8f11df260959ecc7c3202555cc47a72", size = 3010220, upload-time = "2026-02-10T19:18:17.361Z" },
+    { url = "https://files.pythonhosted.org/packages/48/ef/0c2f4a8e31018a986949d34a01115dd057bf536905dca38897bacd21fac3/cryptography-46.0.5-cp38-abi3-win_amd64.whl", hash = "sha256:556e106ee01aa13484ce9b0239bca667be5004efb0aabbed28d353df86445595", size = 3467050, upload-time = "2026-02-10T19:18:18.899Z" },
 ]
 
 [[package]]
@@ -814,15 +840,6 @@ requires-dist = [
     { name = "microsoft-teams-apps", editable = "packages/apps" },
 ]
 
-[[package]]
-name = "diskcache"
-version = "5.6.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/3f/21/1c1ffc1a039ddcc459db43cc108658f32c57d271d7289a2794e401d0fdb6/diskcache-5.6.3.tar.gz", hash = "sha256:2c3a3fa2743d8535d832ec61c2054a1641f41775aa7c556758a109941e33e4fc", size = 67916, upload-time = "2023-08-31T06:12:00.316Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3f/27/4570e78fc0bf5ea0ca45eb1de3818a23787af9b390c0b0a0033a1b8236f9/diskcache-5.6.3-py3-none-any.whl", hash = "sha256:5e31b2d5fbad117cc363ebaf6b689474db18a1f6438bc82358b024abd4c2ca19", size = 45550, upload-time = "2023-08-31T06:11:58.822Z" },
-]
-
 [[package]]
 name = "distlib"
 version = "0.4.0"
@@ -923,64 +940,52 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/36/f4/c6e662dade71f56cd2f3735141b265c3c79293c109549c1e6933b0651ffc/exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10", size = 16674, upload-time = "2025-05-10T17:42:49.33Z" },
 ]
 
-[[package]]
-name = "fakeredis"
-version = "2.33.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "redis" },
-    { name = "sortedcontainers" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/5f/f9/57464119936414d60697fcbd32f38909bb5688b616ae13de6e98384433e0/fakeredis-2.33.0.tar.gz", hash = "sha256:d7bc9a69d21df108a6451bbffee23b3eba432c21a654afc7ff2d295428ec5770", size = 175187, upload-time = "2025-12-16T19:45:52.269Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6e/78/a850fed8aeef96d4a99043c90b818b2ed5419cd5b24a4049fd7cfb9f1471/fakeredis-2.33.0-py3-none-any.whl", hash = "sha256:de535f3f9ccde1c56672ab2fdd6a8efbc4f2619fc2f1acc87b8737177d71c965", size = 119605, upload-time = "2025-12-16T19:45:51.08Z" },
-]
-
-[package.optional-dependencies]
-lua = [
-    { name = "lupa" },
-]
-
 [[package]]
 name = "fastapi"
-version = "0.128.0"
+version = "0.135.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "annotated-doc" },
     { name = "pydantic" },
     { name = "starlette" },
     { name = "typing-extensions" },
+    { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/52/08/8c8508db6c7b9aae8f7175046af41baad690771c9bcde676419965e338c7/fastapi-0.128.0.tar.gz", hash = "sha256:1cc179e1cef10a6be60ffe429f79b829dce99d8de32d7acb7e6c8dfdf7f2645a", size = 365682, upload-time = "2025-12-27T15:21:13.714Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c4/73/5903c4b13beae98618d64eb9870c3fac4f605523dd0312ca5c80dadbd5b9/fastapi-0.135.2.tar.gz", hash = "sha256:88a832095359755527b7f63bb4c6bc9edb8329a026189eed83d6c1afcf419d56", size = 395833, upload-time = "2026-03-23T14:12:41.697Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5c/05/5cbb59154b093548acd0f4c7c474a118eda06da25aa75c616b72d8fcd92a/fastapi-0.128.0-py3-none-any.whl", hash = "sha256:aebd93f9716ee3b4f4fcfe13ffb7cf308d99c9f3ab5622d8877441072561582d", size = 103094, upload-time = "2025-12-27T15:21:12.154Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/ea/18f6d0457f9efb2fc6fa594857f92810cadb03024975726db6546b3d6fcf/fastapi-0.135.2-py3-none-any.whl", hash = "sha256:0af0447d541867e8db2a6a25c23a8c4bd80e2394ac5529bd87501bbb9e240ca5", size = 117407, upload-time = "2026-03-23T14:12:43.284Z" },
 ]
 
 [[package]]
 name = "fastmcp"
-version = "2.14.0"
+version = "3.1.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "authlib" },
     { name = "cyclopts" },
     { name = "exceptiongroup" },
     { name = "httpx" },
+    { name = "jsonref" },
     { name = "jsonschema-path" },
     { name = "mcp" },
     { name = "openapi-pydantic" },
+    { name = "opentelemetry-api" },
+    { name = "packaging" },
     { name = "platformdirs" },
-    { name = "py-key-value-aio", extra = ["disk", "keyring", "memory"] },
+    { name = "py-key-value-aio", extra = ["filetree", "keyring", "memory"] },
     { name = "pydantic", extra = ["email"] },
-    { name = "pydocket" },
     { name = "pyperclip" },
     { name = "python-dotenv" },
+    { name = "pyyaml" },
     { name = "rich" },
+    { name = "uncalled-for" },
     { name = "uvicorn" },
+    { name = "watchfiles" },
     { name = "websockets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/35/50/9bb042a2d290ccadb35db3580ac507f192e1a39c489eb8faa167cd5e3b57/fastmcp-2.14.0.tar.gz", hash = "sha256:c1f487b36a3e4b043dbf3330e588830047df2e06f8ef0920d62dfb34d0905727", size = 8232562, upload-time = "2025-12-11T23:04:27.134Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/25/83/c95d3bf717698a693eccb43e137a32939d2549876e884e246028bff6ecce/fastmcp-3.1.1.tar.gz", hash = "sha256:db184b5391a31199323766a3abf3a8bfbb8010479f77eca84c0e554f18655c48", size = 17347644, upload-time = "2026-03-14T19:12:20.235Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/54/73/b5656172a6beb2eacec95f04403ddea1928e4b22066700fd14780f8f45d1/fastmcp-2.14.0-py3-none-any.whl", hash = "sha256:7b374c0bcaf1ef1ef46b9255ea84c607f354291eaf647ff56a47c69f5ec0c204", size = 398965, upload-time = "2025-12-11T23:04:25.587Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ea/570122de7e24f72138d006f799768e14cc1ccf7fcb22b7750b2bd276c711/fastmcp-3.1.1-py3-none-any.whl", hash = "sha256:8132ba069d89f14566b3266919d6d72e2ec23dd45d8944622dca407e9beda7eb", size = 633754, upload-time = "2026-03-14T19:12:22.736Z" },
 ]
 
 [[package]]
@@ -1171,6 +1176,29 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/07/c6/80c95b1b2b94682a72cbdbfb85b81ae2daffa4291fbfa1b1464502ede10d/hpack-4.1.0-py3-none-any.whl", hash = "sha256:157ac792668d995c657d93111f46b4535ed114f0c9c8d672271bbec7eae1b496", size = 34357, upload-time = "2025-01-22T21:44:56.92Z" },
 ]
 
+[[package]]
+name = "http-adapters"
+version = "0.1.0"
+source = { virtual = "examples/http-adapters" }
+dependencies = [
+    { name = "dotenv" },
+    { name = "httptools" },
+    { name = "microsoft-teams-api" },
+    { name = "microsoft-teams-apps" },
+    { name = "starlette" },
+    { name = "uvicorn" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "dotenv", specifier = ">=0.9.9" },
+    { name = "httptools" },
+    { name = "microsoft-teams-api", editable = "packages/api" },
+    { name = "microsoft-teams-apps", editable = "packages/apps" },
+    { name = "starlette" },
+    { name = "uvicorn" },
+]
+
 [[package]]
 name = "httpcore"
 version = "1.0.9"
@@ -1410,6 +1438,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ee/d5/1cc282dc23346a43aab461bf2e8c36593aacd34242bee1a13fa750db0cfe/jsonpickle-1.4.2-py2.py3-none-any.whl", hash = "sha256:2ac5863099864c63d7f0c367af5e512c94f3384977dd367f2eae5f2303f7b92c", size = 36529, upload-time = "2020-11-30T03:21:53.857Z" },
 ]
 
+[[package]]
+name = "jsonref"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/0d/c1f3277e90ccdb50d33ed5ba1ec5b3f0a242ed8c1b1a85d3afeb68464dca/jsonref-1.1.0.tar.gz", hash = "sha256:32fe8e1d85af0fdefbebce950af85590b22b60f9e95443176adbde4e1ecea552", size = 8814, upload-time = "2023-01-16T16:10:04.455Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/ec/e1db9922bceb168197a558a2b8c03a7963f1afe93517ddd3cf99f202f996/jsonref-1.1.0-py3-none-any.whl", hash = "sha256:590dc7773df6c21cbf948b5dac07a72a251db28b0238ceecce0a2abfa8ec30a9", size = 9425, upload-time = "2023-01-16T16:10:02.255Z" },
+]
+
 [[package]]
 name = "jsonschema"
 version = "4.25.1"
@@ -1469,58 +1506,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/81/db/e655086b7f3a705df045bf0933bdd9c2f79bb3c97bfef1384598bb79a217/keyring-25.7.0-py3-none-any.whl", hash = "sha256:be4a0b195f149690c166e850609a477c532ddbfbaed96a404d4e43f8d5e2689f", size = 39160, upload-time = "2025-11-16T16:26:08.402Z" },
 ]
 
-[[package]]
-name = "lupa"
-version = "2.6"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b8/1c/191c3e6ec6502e3dbe25a53e27f69a5daeac3e56de1f73c0138224171ead/lupa-2.6.tar.gz", hash = "sha256:9a770a6e89576be3447668d7ced312cd6fd41d3c13c2462c9dc2c2ab570e45d9", size = 7240282, upload-time = "2025-10-24T07:20:29.738Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/94/86/ce243390535c39d53ea17ccf0240815e6e457e413e40428a658ea4ee4b8d/lupa-2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:47ce718817ef1cc0c40d87c3d5ae56a800d61af00fbc0fad1ca9be12df2f3b56", size = 951707, upload-time = "2025-10-24T07:18:03.884Z" },
-    { url = "https://files.pythonhosted.org/packages/86/85/cedea5e6cbeb54396fdcc55f6b741696f3f036d23cfaf986d50d680446da/lupa-2.6-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:7aba985b15b101495aa4b07112cdc08baa0c545390d560ad5cfde2e9e34f4d58", size = 1916703, upload-time = "2025-10-24T07:18:05.6Z" },
-    { url = "https://files.pythonhosted.org/packages/24/be/3d6b5f9a8588c01a4d88129284c726017b2089f3a3fd3ba8bd977292fea0/lupa-2.6-cp312-cp312-macosx_11_0_x86_64.whl", hash = "sha256:b766f62f95b2739f2248977d29b0722e589dcf4f0ccfa827ccbd29f0148bd2e5", size = 985152, upload-time = "2025-10-24T07:18:08.561Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/23/9f9a05beee5d5dce9deca4cb07c91c40a90541fc0a8e09db4ee670da550f/lupa-2.6-cp312-cp312-manylinux2010_i686.manylinux_2_12_i686.manylinux_2_28_i686.whl", hash = "sha256:00a934c23331f94cb51760097ebfab14b005d55a6b30a2b480e3c53dd2fa290d", size = 1159599, upload-time = "2025-10-24T07:18:10.346Z" },
-    { url = "https://files.pythonhosted.org/packages/40/4e/e7c0583083db9d7f1fd023800a9767d8e4391e8330d56c2373d890ac971b/lupa-2.6-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:21de9f38bd475303e34a042b7081aabdf50bd9bafd36ce4faea2f90fd9f15c31", size = 1038686, upload-time = "2025-10-24T07:18:12.112Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/9f/5a4f7d959d4feba5e203ff0c31889e74d1ca3153122be4a46dca7d92bf7c/lupa-2.6-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cf3bda96d3fc41237e964a69c23647d50d4e28421111360274d4799832c560e9", size = 2071956, upload-time = "2025-10-24T07:18:14.572Z" },
-    { url = "https://files.pythonhosted.org/packages/92/34/2f4f13ca65d01169b1720176aedc4af17bc19ee834598c7292db232cb6dc/lupa-2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5a76ead245da54801a81053794aa3975f213221f6542d14ec4b859ee2e7e0323", size = 1057199, upload-time = "2025-10-24T07:18:16.379Z" },
-    { url = "https://files.pythonhosted.org/packages/35/2a/5f7d2eebec6993b0dcd428e0184ad71afb06a45ba13e717f6501bfed1da3/lupa-2.6-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8dd0861741caa20886ddbda0a121d8e52fb9b5bb153d82fa9bba796962bf30e8", size = 1173693, upload-time = "2025-10-24T07:18:18.153Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/29/089b4d2f8e34417349af3904bb40bec40b65c8731f45e3fd8d497ca573e5/lupa-2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:239e63948b0b23023f81d9a19a395e768ed3da6a299f84e7963b8f813f6e3f9c", size = 2164394, upload-time = "2025-10-24T07:18:20.403Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/1b/79c17b23c921f81468a111cad843b076a17ef4b684c4a8dff32a7969c3f0/lupa-2.6-cp312-cp312-win32.whl", hash = "sha256:325894e1099499e7a6f9c351147661a2011887603c71086d36fe0f964d52d1ce", size = 1420647, upload-time = "2025-10-24T07:18:23.368Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/15/5121e68aad3584e26e1425a5c9a79cd898f8a152292059e128c206ee817c/lupa-2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c735a1ce8ee60edb0fe71d665f1e6b7c55c6021f1d340eb8c865952c602cd36f", size = 1688529, upload-time = "2025-10-24T07:18:25.523Z" },
-    { url = "https://files.pythonhosted.org/packages/28/1d/21176b682ca5469001199d8b95fa1737e29957a3d185186e7a8b55345f2e/lupa-2.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:663a6e58a0f60e7d212017d6678639ac8df0119bc13c2145029dcba084391310", size = 947232, upload-time = "2025-10-24T07:18:27.878Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/4c/d327befb684660ca13cf79cd1f1d604331808f9f1b6fb6bf57832f8edf80/lupa-2.6-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:d1f5afda5c20b1f3217a80e9bc1b77037f8a6eb11612fd3ada19065303c8f380", size = 1908625, upload-time = "2025-10-24T07:18:29.944Z" },
-    { url = "https://files.pythonhosted.org/packages/66/8e/ad22b0a19454dfd08662237a84c792d6d420d36b061f239e084f29d1a4f3/lupa-2.6-cp313-cp313-macosx_11_0_x86_64.whl", hash = "sha256:26f2b3c085fe76e9119e48c1013c1cccdc1f51585d456858290475aa38e7089e", size = 981057, upload-time = "2025-10-24T07:18:31.553Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/48/74859073ab276bd0566c719f9ca0108b0cfc1956ca0d68678d117d47d155/lupa-2.6-cp313-cp313-manylinux2010_i686.manylinux_2_12_i686.manylinux_2_28_i686.whl", hash = "sha256:60d2f902c7b96fb8ab98493dcff315e7bb4d0b44dc9dd76eb37de575025d5685", size = 1156227, upload-time = "2025-10-24T07:18:33.981Z" },
-    { url = "https://files.pythonhosted.org/packages/09/6c/0e9ded061916877253c2266074060eb71ed99fb21d73c8c114a76725bce2/lupa-2.6-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a02d25dee3a3250967c36590128d9220ae02f2eda166a24279da0b481519cbff", size = 1035752, upload-time = "2025-10-24T07:18:36.32Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/ef/f8c32e454ef9f3fe909f6c7d57a39f950996c37a3deb7b391fec7903dab7/lupa-2.6-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6eae1ee16b886b8914ff292dbefbf2f48abfbdee94b33a88d1d5475e02423203", size = 2069009, upload-time = "2025-10-24T07:18:38.072Z" },
-    { url = "https://files.pythonhosted.org/packages/53/dc/15b80c226a5225815a890ee1c11f07968e0aba7a852df41e8ae6fe285063/lupa-2.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b0edd5073a4ee74ab36f74fe61450148e6044f3952b8d21248581f3c5d1a58be", size = 1056301, upload-time = "2025-10-24T07:18:40.165Z" },
-    { url = "https://files.pythonhosted.org/packages/31/14/2086c1425c985acfb30997a67e90c39457122df41324d3c179d6ee2292c6/lupa-2.6-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:0c53ee9f22a8a17e7d4266ad48e86f43771951797042dd51d1494aaa4f5f3f0a", size = 1170673, upload-time = "2025-10-24T07:18:42.426Z" },
-    { url = "https://files.pythonhosted.org/packages/10/e5/b216c054cf86576c0191bf9a9f05de6f7e8e07164897d95eea0078dca9b2/lupa-2.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:de7c0f157a9064a400d828789191a96da7f4ce889969a588b87ec80de9b14772", size = 2162227, upload-time = "2025-10-24T07:18:46.112Z" },
-    { url = "https://files.pythonhosted.org/packages/59/2f/33ecb5bedf4f3bc297ceacb7f016ff951331d352f58e7e791589609ea306/lupa-2.6-cp313-cp313-win32.whl", hash = "sha256:ee9523941ae0a87b5b703417720c5d78f72d2f5bc23883a2ea80a949a3ed9e75", size = 1419558, upload-time = "2025-10-24T07:18:48.371Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/b4/55e885834c847ea610e111d87b9ed4768f0afdaeebc00cd46810f25029f6/lupa-2.6-cp313-cp313-win_amd64.whl", hash = "sha256:b1335a5835b0a25ebdbc75cf0bda195e54d133e4d994877ef025e218c2e59db9", size = 1683424, upload-time = "2025-10-24T07:18:50.976Z" },
-    { url = "https://files.pythonhosted.org/packages/66/9d/d9427394e54d22a35d1139ef12e845fd700d4872a67a34db32516170b746/lupa-2.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:dcb6d0a3264873e1653bc188499f48c1fb4b41a779e315eba45256cfe7bc33c1", size = 953818, upload-time = "2025-10-24T07:18:53.378Z" },
-    { url = "https://files.pythonhosted.org/packages/10/41/27bbe81953fb2f9ecfced5d9c99f85b37964cfaf6aa8453bb11283983721/lupa-2.6-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:a37e01f2128f8c36106726cb9d360bac087d58c54b4522b033cc5691c584db18", size = 1915850, upload-time = "2025-10-24T07:18:55.259Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/98/f9ff60db84a75ba8725506bbf448fb085bc77868a021998ed2a66d920568/lupa-2.6-cp314-cp314-macosx_11_0_x86_64.whl", hash = "sha256:458bd7e9ff3c150b245b0fcfbb9bd2593d1152ea7f0a7b91c1d185846da033fe", size = 982344, upload-time = "2025-10-24T07:18:57.05Z" },
-    { url = "https://files.pythonhosted.org/packages/41/f7/f39e0f1c055c3b887d86b404aaf0ca197b5edfd235a8b81b45b25bac7fc3/lupa-2.6-cp314-cp314-manylinux2010_i686.manylinux_2_12_i686.manylinux_2_28_i686.whl", hash = "sha256:052ee82cac5206a02df77119c325339acbc09f5ce66967f66a2e12a0f3211cad", size = 1156543, upload-time = "2025-10-24T07:18:59.251Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/9c/59e6cffa0d672d662ae17bd7ac8ecd2c89c9449dee499e3eb13ca9cd10d9/lupa-2.6-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96594eca3c87dd07938009e95e591e43d554c1dbd0385be03c100367141db5a8", size = 1047974, upload-time = "2025-10-24T07:19:01.449Z" },
-    { url = "https://files.pythonhosted.org/packages/23/c6/a04e9cef7c052717fcb28fb63b3824802488f688391895b618e39be0f684/lupa-2.6-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e8faddd9d198688c8884091173a088a8e920ecc96cda2ffed576a23574c4b3f6", size = 2073458, upload-time = "2025-10-24T07:19:03.369Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/10/824173d10f38b51fc77785228f01411b6ca28826ce27404c7c912e0e442c/lupa-2.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:daebb3a6b58095c917e76ba727ab37b27477fb926957c825205fbda431552134", size = 1067683, upload-time = "2025-10-24T07:19:06.2Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/dc/9692fbcf3c924d9c4ece2d8d2f724451ac2e09af0bd2a782db1cef34e799/lupa-2.6-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:f3154e68972befe0f81564e37d8142b5d5d79931a18309226a04ec92487d4ea3", size = 1171892, upload-time = "2025-10-24T07:19:08.544Z" },
-    { url = "https://files.pythonhosted.org/packages/84/ff/e318b628d4643c278c96ab3ddea07fc36b075a57383c837f5b11e537ba9d/lupa-2.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e4dadf77b9fedc0bfa53417cc28dc2278a26d4cbd95c29f8927ad4d8fe0a7ef9", size = 2166641, upload-time = "2025-10-24T07:19:10.485Z" },
-    { url = "https://files.pythonhosted.org/packages/12/f7/a6f9ec2806cf2d50826980cdb4b3cffc7691dc6f95e13cc728846d5cb793/lupa-2.6-cp314-cp314-win32.whl", hash = "sha256:cb34169c6fa3bab3e8ac58ca21b8a7102f6a94b6a5d08d3636312f3f02fafd8f", size = 1456857, upload-time = "2025-10-24T07:19:37.989Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/de/df71896f25bdc18360fdfa3b802cd7d57d7fede41a0e9724a4625b412c85/lupa-2.6-cp314-cp314-win_amd64.whl", hash = "sha256:b74f944fe46c421e25d0f8692aef1e842192f6f7f68034201382ac440ef9ea67", size = 1731191, upload-time = "2025-10-24T07:19:40.281Z" },
-    { url = "https://files.pythonhosted.org/packages/47/3c/a1f23b01c54669465f5f4c4083107d496fbe6fb45998771420e9aadcf145/lupa-2.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0e21b716408a21ab65723f8841cf7f2f37a844b7a965eeabb785e27fca4099cf", size = 999343, upload-time = "2025-10-24T07:19:12.519Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/6d/501994291cb640bfa2ccf7f554be4e6914afa21c4026bd01bff9ca8aac57/lupa-2.6-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:589db872a141bfff828340079bbdf3e9a31f2689f4ca0d88f97d9e8c2eae6142", size = 2000730, upload-time = "2025-10-24T07:19:14.869Z" },
-    { url = "https://files.pythonhosted.org/packages/53/a5/457ffb4f3f20469956c2d4c4842a7675e884efc895b2f23d126d23e126cc/lupa-2.6-cp314-cp314t-macosx_11_0_x86_64.whl", hash = "sha256:cd852a91a4a9d4dcbb9a58100f820a75a425703ec3e3f049055f60b8533b7953", size = 1021553, upload-time = "2025-10-24T07:19:17.123Z" },
-    { url = "https://files.pythonhosted.org/packages/51/6b/36bb5a5d0960f2a5c7c700e0819abb76fd9bf9c1d8a66e5106416d6e9b14/lupa-2.6-cp314-cp314t-manylinux2010_i686.manylinux_2_12_i686.manylinux_2_28_i686.whl", hash = "sha256:0334753be028358922415ca97a64a3048e4ed155413fc4eaf87dd0a7e2752983", size = 1133275, upload-time = "2025-10-24T07:19:20.51Z" },
-    { url = "https://files.pythonhosted.org/packages/19/86/202ff4429f663013f37d2229f6176ca9f83678a50257d70f61a0a97281bf/lupa-2.6-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:661d895cd38c87658a34780fac54a690ec036ead743e41b74c3fb81a9e65a6aa", size = 1038441, upload-time = "2025-10-24T07:19:22.509Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/42/d8125f8e420714e5b52e9c08d88b5329dfb02dcca731b4f21faaee6cc5b5/lupa-2.6-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6aa58454ccc13878cc177c62529a2056be734da16369e451987ff92784994ca7", size = 2058324, upload-time = "2025-10-24T07:19:24.979Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/2c/47bf8b84059876e877a339717ddb595a4a7b0e8740bacae78ba527562e1c/lupa-2.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1425017264e470c98022bba8cff5bd46d054a827f5df6b80274f9cc71dafd24f", size = 1060250, upload-time = "2025-10-24T07:19:27.262Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/06/d88add2b6406ca1bdec99d11a429222837ca6d03bea42ca75afa169a78cb/lupa-2.6-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:224af0532d216e3105f0a127410f12320f7c5f1aa0300bdf9646b8d9afb0048c", size = 1151126, upload-time = "2025-10-24T07:19:29.522Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/a0/89e6a024c3b4485b89ef86881c9d55e097e7cb0bdb74efb746f2fa6a9a76/lupa-2.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9abb98d5a8fd27c8285302e82199f0e56e463066f88f619d6594a450bf269d80", size = 2153693, upload-time = "2025-10-24T07:19:31.379Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/36/a0f007dc58fc1bbf51fb85dcc82fcb1f21b8c4261361de7dab0e3d8521ef/lupa-2.6-cp314-cp314t-win32.whl", hash = "sha256:1849efeba7a8f6fb8aa2c13790bee988fd242ae404bd459509640eeea3d1e291", size = 1590104, upload-time = "2025-10-24T07:19:33.514Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/5e/db903ce9cf82c48d6b91bf6d63ae4c8d0d17958939a4e04ba6b9f38b8643/lupa-2.6-cp314-cp314t-win_amd64.whl", hash = "sha256:fc1498d1a4fc028bc521c26d0fad4ca00ed63b952e32fb95949bda76a04bad52", size = 1913818, upload-time = "2025-10-24T07:19:36.039Z" },
-]
-
 [[package]]
 name = "markdown-it-py"
 version = "4.0.0"
@@ -1851,7 +1836,7 @@ requires-dist = [
     { name = "microsoft-teams-cards", editable = "packages/cards" },
     { name = "microsoft-teams-common", editable = "packages/common" },
     { name = "pydantic", specifier = ">=2.0.0" },
-    { name = "pyjwt", extras = ["crypto"], specifier = ">=2.10.0" },
+    { name = "pyjwt", extras = ["crypto"], specifier = ">=2.12.0" },
 ]
 
 [package.metadata.requires-dev]
@@ -1899,7 +1884,7 @@ requires-dist = [
     { name = "microsoft-teams-graph", marker = "extra == 'graph'", editable = "packages/graph" },
     { name = "msal", specifier = ">=1.33.0" },
     { name = "pydantic-settings", specifier = ">=2.11.0" },
-    { name = "pyjwt", extras = ["crypto"], specifier = ">=2.10.0" },
+    { name = "pyjwt", extras = ["crypto"], specifier = ">=2.12.0" },
     { name = "python-dotenv", specifier = ">=1.0.0" },
     { name = "uvicorn", specifier = ">=0.34.3" },
 ]
@@ -2019,7 +2004,7 @@ requires-dist = [
     { name = "azure-core", specifier = ">=1.31.0" },
     { name = "microsoft-teams-common", editable = "packages/common" },
     { name = "msgraph-sdk", specifier = ">=1.30.0,<2.0.0" },
-    { name = "pyjwt", extras = ["crypto"], specifier = ">=2.10.0" },
+    { name = "pyjwt", extras = ["crypto"], specifier = ">=2.12.0" },
 ]
 
 [package.metadata.requires-dev]
@@ -2041,7 +2026,7 @@ dependencies = [
 
 [package.metadata]
 requires-dist = [
-    { name = "fastmcp", specifier = ">=0.5.0" },
+    { name = "fastmcp", specifier = ">=2.14.2" },
     { name = "mcp", specifier = ">=1.13.1" },
     { name = "microsoft-teams-ai", editable = "packages/ai" },
     { name = "microsoft-teams-apps", editable = "packages/apps" },
@@ -2391,15 +2376,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/7d/eb/b6260b31b1a96386c0a880edebe26f89669098acea8e0318bff6adb378fd/pathable-0.4.4-py3-none-any.whl", hash = "sha256:5ae9e94793b6ef5a4cbe0a7ce9dbbefc1eec38df253763fd0aeeacf2762dbbc2", size = 9592, upload-time = "2025-01-10T18:43:11.88Z" },
 ]
 
-[[package]]
-name = "pathvalidate"
-version = "3.3.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fa/2a/52a8da6fe965dea6192eb716b357558e103aea0a1e9a8352ad575a8406ca/pathvalidate-3.3.1.tar.gz", hash = "sha256:b18c07212bfead624345bb8e1d6141cdcf15a39736994ea0b94035ad2b1ba177", size = 63262, upload-time = "2025-06-15T09:07:20.736Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/70/875f4a23bfc4731703a5835487d0d2fb999031bd415e7d17c0ae615c18b7/pathvalidate-3.3.1-py3-none-any.whl", hash = "sha256:5263baab691f8e1af96092fa5137ee17df5bdfbd6cff1fcac4d6ef4bc2e1735f", size = 24305, upload-time = "2025-06-15T09:07:19.117Z" },
-]
-
 [[package]]
 name = "platformdirs"
 version = "4.5.0"
@@ -2448,12 +2424,18 @@ wheels = [
 ]
 
 [[package]]
-name = "prometheus-client"
-version = "0.24.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f0/58/a794d23feb6b00fc0c72787d7e87d872a6730dd9ed7c7b3e954637d8f280/prometheus_client-0.24.1.tar.gz", hash = "sha256:7e0ced7fbbd40f7b84962d5d2ab6f17ef88a72504dcf7c0b40737b43b2a461f9", size = 85616, upload-time = "2026-01-14T15:26:26.965Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/74/c3/24a2f845e3917201628ecaba4f18bab4d18a337834c1df2a159ee9d22a42/prometheus_client-0.24.1-py3-none-any.whl", hash = "sha256:150db128af71a5c2482b36e588fc8a6b95e498750da4b17065947c16070f4055", size = 64057, upload-time = "2026-01-14T15:26:24.42Z" },
+name = "proactive-messaging"
+version = "0.1.0"
+source = { virtual = "examples/proactive-messaging" }
+dependencies = [
+    { name = "dotenv" },
+    { name = "microsoft-teams-apps" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "dotenv", specifier = ">=0.9.9" },
+    { name = "microsoft-teams-apps", editable = "packages/apps" },
 ]
 
 [[package]]
@@ -2569,21 +2551,21 @@ wheels = [
 
 [[package]]
 name = "py-key-value-aio"
-version = "0.3.0"
+version = "0.4.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "beartype" },
-    { name = "py-key-value-shared" },
+    { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/93/ce/3136b771dddf5ac905cc193b461eb67967cf3979688c6696e1f2cdcde7ea/py_key_value_aio-0.3.0.tar.gz", hash = "sha256:858e852fcf6d696d231266da66042d3355a7f9871650415feef9fca7a6cd4155", size = 50801, upload-time = "2025-11-17T16:50:04.711Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/3c/0397c072a38d4bc580994b42e0c90c5f44f679303489e4376289534735e5/py_key_value_aio-0.4.4.tar.gz", hash = "sha256:e3012e6243ed7cc09bb05457bd4d03b1ba5c2b1ca8700096b3927db79ffbbe55", size = 92300, upload-time = "2026-02-16T21:21:43.245Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/99/10/72f6f213b8f0bce36eff21fda0a13271834e9eeff7f9609b01afdc253c79/py_key_value_aio-0.3.0-py3-none-any.whl", hash = "sha256:1c781915766078bfd608daa769fefb97e65d1d73746a3dfb640460e322071b64", size = 96342, upload-time = "2025-11-17T16:50:03.801Z" },
+    { url = "https://files.pythonhosted.org/packages/32/69/f1b537ee70b7def42d63124a539ed3026a11a3ffc3086947a1ca6e861868/py_key_value_aio-0.4.4-py3-none-any.whl", hash = "sha256:18e17564ecae61b987f909fc2cd41ee2012c84b4b1dcb8c055cf8b4bc1bf3f5d", size = 152291, upload-time = "2026-02-16T21:21:44.241Z" },
 ]
 
 [package.optional-dependencies]
-disk = [
-    { name = "diskcache" },
-    { name = "pathvalidate" },
+filetree = [
+    { name = "aiofile" },
+    { name = "anyio" },
 ]
 keyring = [
     { name = "keyring" },
@@ -2591,30 +2573,14 @@ keyring = [
 memory = [
     { name = "cachetools" },
 ]
-redis = [
-    { name = "redis" },
-]
-
-[[package]]
-name = "py-key-value-shared"
-version = "0.3.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "beartype" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/7b/e4/1971dfc4620a3a15b4579fe99e024f5edd6e0967a71154771a059daff4db/py_key_value_shared-0.3.0.tar.gz", hash = "sha256:8fdd786cf96c3e900102945f92aa1473138ebe960ef49da1c833790160c28a4b", size = 11666, upload-time = "2025-11-17T16:50:06.849Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/51/e4/b8b0a03ece72f47dce2307d36e1c34725b7223d209fc679315ffe6a4e2c3/py_key_value_shared-0.3.0-py3-none-any.whl", hash = "sha256:5b0efba7ebca08bb158b1e93afc2f07d30b8f40c2fc12ce24a4c0d84f42f9298", size = 19560, upload-time = "2025-11-17T16:50:05.954Z" },
-]
 
 [[package]]
 name = "pyasn1"
-version = "0.6.2"
+version = "0.6.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fe/b6/6e630dff89739fcd427e3f72b3d905ce0acb85a45d4ec3e2678718a3487f/pyasn1-0.6.2.tar.gz", hash = "sha256:9b59a2b25ba7e4f8197db7686c09fb33e658b98339fadb826e9512629017833b", size = 146586, upload-time = "2026-01-16T18:04:18.534Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5c/5f/6583902b6f79b399c9c40674ac384fd9cd77805f9e6205075f828ef11fb2/pyasn1-0.6.3.tar.gz", hash = "sha256:697a8ecd6d98891189184ca1fa05d1bb00e2f84b5977c481452050549c8a72cf", size = 148685, upload-time = "2026-03-17T01:06:53.382Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/44/b5/a96872e5184f354da9c84ae119971a0a4c221fe9b27a4d94bd43f2596727/pyasn1-0.6.2-py3-none-any.whl", hash = "sha256:1eb26d860996a18e9b6ed05e7aae0e9fc21619fcee6af91cca9bad4fbea224bf", size = 83371, upload-time = "2026-01-16T18:04:17.174Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/a0/7d793dce3fa811fe047d6ae2431c672364b462850c6235ae306c0efd025f/pyasn1-0.6.3-py3-none-any.whl", hash = "sha256:a80184d120f0864a52a073acc6fc642847d0be408e7c7252f31390c0f4eadcde", size = 83997, upload-time = "2026-03-17T01:06:52.036Z" },
 ]
 
 [[package]]
@@ -2739,27 +2705,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/83/d6/887a1ff844e64aa823fb4905978d882a633cfe295c32eacad582b78a7d8b/pydantic_settings-2.11.0-py3-none-any.whl", hash = "sha256:fe2cea3413b9530d10f3a5875adffb17ada5c1e1bab0b2885546d7310415207c", size = 48608, upload-time = "2025-09-24T14:19:10.015Z" },
 ]
 
-[[package]]
-name = "pydocket"
-version = "0.17.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cloudpickle" },
-    { name = "fakeredis", extra = ["lua"] },
-    { name = "opentelemetry-api" },
-    { name = "prometheus-client" },
-    { name = "py-key-value-aio", extra = ["memory", "redis"] },
-    { name = "python-json-logger" },
-    { name = "redis" },
-    { name = "rich" },
-    { name = "typer" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ec/65/eb3b4f7afac80308d74bab2a668b31f074524ff6fbc664a685c6ed7c8885/pydocket-0.17.3.tar.gz", hash = "sha256:8922b4ca5f3f428e69b7695b9b5a313bbedc3ce35c74045cadcd89f7c0e6ac2d", size = 329828, upload-time = "2026-01-27T01:08:06.514Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ea/3b/29c69e4f88f5e5ea5e90e3cf93493cafb68bf9a2f625b916cc26ab1def89/pydocket-0.17.3-py3-none-any.whl", hash = "sha256:9ef2c6e855f52a3210acff300bcbcc45773d79295e2deddcc7aef7f67b2a5ba7", size = 91626, upload-time = "2026-01-27T01:08:05.085Z" },
-]
-
 [[package]]
 name = "pygments"
 version = "2.19.2"
@@ -2771,11 +2716,11 @@ wheels = [
 
 [[package]]
 name = "pyjwt"
-version = "2.10.1"
+version = "2.12.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e7/46/bd74733ff231675599650d3e47f361794b22ef3e3770998dda30d3b63726/pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953", size = 87785, upload-time = "2024-11-28T03:43:29.933Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c2/27/a3b6e5bf6ff856d2509292e95c8f57f0df7017cf5394921fc4e4ef40308a/pyjwt-2.12.1.tar.gz", hash = "sha256:c74a7a2adf861c04d002db713dd85f84beb242228e671280bf709d765b03672b", size = 102564, upload-time = "2026-03-13T19:27:37.25Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/61/ad/689f02752eeec26aed679477e80e632ef1b682313be70793d798c1d5fc8f/PyJWT-2.10.1-py3-none-any.whl", hash = "sha256:dcdd193e30abefd5debf142f9adfcdd2b58004e644f25406ffaebd50bd98dacb", size = 22997, upload-time = "2024-11-28T03:43:27.893Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/7a/8dd906bd22e79e47397a61742927f6747fe93242ef86645ee9092e610244/pyjwt-2.12.1-py3-none-any.whl", hash = "sha256:28ca37c070cad8ba8cd9790cd940535d40274d22f80ab87f3ac6a713e6e8454c", size = 29726, upload-time = "2026-03-13T19:27:35.677Z" },
 ]
 
 [package.optional-dependencies]
@@ -2834,6 +2779,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/04/93/2fa34714b7a4ae72f2f8dad66ba17dd9a2c793220719e736dda28b7aec27/pytest_asyncio-1.2.0-py3-none-any.whl", hash = "sha256:8e17ae5e46d8e7efe51ab6494dd2010f4ca8dae51652aa3c8d55acf50bfb2e99", size = 15095, upload-time = "2025-09-12T07:33:52.639Z" },
 ]
 
+[[package]]
+name = "pytest-cov"
+version = "7.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "coverage" },
+    { name = "pluggy" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5e/f7/c933acc76f5208b3b00089573cf6a2bc26dc80a8aece8f52bb7d6b1855ca/pytest_cov-7.0.0.tar.gz", hash = "sha256:33c97eda2e049a0c5298e91f519302a1334c26ac65c1a483d6206fd458361af1", size = 54328, upload-time = "2025-09-09T10:57:02.113Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ee/49/1377b49de7d0c1ce41292161ea0f721913fa8722c19fb9c1e3aa0367eecb/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861", size = 22424, upload-time = "2025-09-09T10:57:00.695Z" },
+]
+
 [[package]]
 name = "python-dateutil"
 version = "2.9.0.post0"
@@ -2855,15 +2814,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5f/ed/539768cf28c661b5b068d66d96a2f155c4971a5d55684a514c1a0e0dec2f/python_dotenv-1.1.1-py3-none-any.whl", hash = "sha256:31f23644fe2602f88ff55e1f5c79ba497e01224ee7737937930c448e4d0e24dc", size = 20556, upload-time = "2025-06-24T04:21:06.073Z" },
 ]
 
-[[package]]
-name = "python-json-logger"
-version = "4.0.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/29/bf/eca6a3d43db1dae7070f70e160ab20b807627ba953663ba07928cdd3dc58/python_json_logger-4.0.0.tar.gz", hash = "sha256:f58e68eb46e1faed27e0f574a55a0455eecd7b8a5b88b85a784519ba3cff047f", size = 17683, upload-time = "2025-10-06T04:15:18.984Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/51/e5/fecf13f06e5e5f67e8837d777d1bc43fac0ed2b77a676804df5c34744727/python_json_logger-4.0.0-py3-none-any.whl", hash = "sha256:af09c9daf6a813aa4cc7180395f50f2a9e5fa056034c9953aec92e381c5ba1e2", size = 15548, upload-time = "2025-10-06T04:15:17.553Z" },
-]
-
 [[package]]
 name = "python-multipart"
 version = "0.0.22"
@@ -2973,15 +2923,6 @@ requires-dist = [
     { name = "microsoft-teams-apps", editable = "packages/apps" },
 ]
 
-[[package]]
-name = "redis"
-version = "7.1.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/43/c8/983d5c6579a411d8a99bc5823cc5712768859b5ce2c8afe1a65b37832c81/redis-7.1.0.tar.gz", hash = "sha256:b1cc3cfa5a2cb9c2ab3ba700864fb0ad75617b41f01352ce5779dabf6d5f9c3c", size = 4796669, upload-time = "2025-11-19T15:54:39.961Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/89/f0/8956f8a86b20d7bb9d6ac0187cf4cd54d8065bc9a1a09eb8011d4d326596/redis-7.1.0-py3-none-any.whl", hash = "sha256:23c52b208f92b56103e17c5d06bdc1a6c2c0b3106583985a76a18f83b265de2b", size = 354159, upload-time = "2025-11-19T15:54:38.064Z" },
-]
-
 [[package]]
 name = "referencing"
 version = "0.36.2"
@@ -3182,15 +3123,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b7/46/f5af3402b579fd5e11573ce652019a67074317e18c1935cc0b4ba9b35552/secretstorage-3.5.0-py3-none-any.whl", hash = "sha256:0ce65888c0725fcb2c5bc0fdb8e5438eece02c523557ea40ce0703c266248137", size = 15554, upload-time = "2025-11-23T19:02:51.545Z" },
 ]
 
-[[package]]
-name = "shellingham"
-version = "1.5.4"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" },
-]
-
 [[package]]
 name = "six"
 version = "1.17.0"
@@ -3209,15 +3141,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
 ]
 
-[[package]]
-name = "sortedcontainers"
-version = "2.4.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594, upload-time = "2021-05-16T22:03:42.897Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" },
-]
-
 [[package]]
 name = "sse-starlette"
 version = "3.0.2"
@@ -3232,15 +3155,15 @@ wheels = [
 
 [[package]]
 name = "starlette"
-version = "0.49.1"
+version = "1.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/1b/3f/507c21db33b66fb027a332f2cb3abbbe924cc3a79ced12f01ed8645955c9/starlette-0.49.1.tar.gz", hash = "sha256:481a43b71e24ed8c43b11ea02f5353d77840e01480881b8cb5a26b8cae64a8cb", size = 2654703, upload-time = "2025-10-28T17:34:10.928Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/81/69/17425771797c36cded50b7fe44e850315d039f28b15901ab44839e70b593/starlette-1.0.0.tar.gz", hash = "sha256:6a4beaf1f81bb472fd19ea9b918b50dc3a77a6f2e190a12954b25e6ed5eea149", size = 2655289, upload-time = "2026-03-22T18:29:46.779Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/51/da/545b75d420bb23b5d494b0517757b351963e974e79933f01e05c929f20a6/starlette-0.49.1-py3-none-any.whl", hash = "sha256:d92ce9f07e4a3caa3ac13a79523bd18e3bc0042bb8ff2d759a8e7dd0e1859875", size = 74175, upload-time = "2025-10-28T17:34:09.13Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/c9/584bc9651441b4ba60cc4d557d8a547b5aff901af35bda3a4ee30c819b82/starlette-1.0.0-py3-none-any.whl", hash = "sha256:d3ec55e0bb321692d275455ddfd3df75fff145d009685eb40dc91fc66b03d38b", size = 72651, upload-time = "2026-03-22T18:29:45.111Z" },
 ]
 
 [[package]]
@@ -3326,21 +3249,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload-time = "2024-11-24T20:12:19.698Z" },
 ]
 
-[[package]]
-name = "typer"
-version = "0.21.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "click" },
-    { name = "rich" },
-    { name = "shellingham" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/36/bf/8825b5929afd84d0dabd606c67cd57b8388cb3ec385f7ef19c5cc2202069/typer-0.21.1.tar.gz", hash = "sha256:ea835607cd752343b6b2b7ce676893e5a0324082268b48f27aa058bdb7d2145d", size = 110371, upload-time = "2026-01-06T11:21:10.989Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/1d/d9257dd49ff2ca23ea5f132edf1281a0c4f9de8a762b9ae399b670a59235/typer-0.21.1-py3-none-any.whl", hash = "sha256:7985e89081c636b88d172c2ee0cfe33c253160994d47bdfdc302defd7d1f1d01", size = 47381, upload-time = "2026-01-06T11:21:09.824Z" },
-]
-
 [[package]]
 name = "types-python-dateutil"
 version = "2.9.0.20251008"
@@ -3371,6 +3279,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
 ]
 
+[[package]]
+name = "uncalled-for"
+version = "0.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/02/7c/b5b7d8136f872e3f13b0584e576886de0489d7213a12de6bebf29ff6ebfc/uncalled_for-0.2.0.tar.gz", hash = "sha256:b4f8fdbcec328c5a113807d653e041c5094473dd4afa7c34599ace69ccb7e69f", size = 49488, upload-time = "2026-02-27T17:40:58.137Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ff/7f/4320d9ce3be404e6310b915c3629fe27bf1e2f438a1a7a3cb0396e32e9a9/uncalled_for-0.2.0-py3-none-any.whl", hash = "sha256:2c0bd338faff5f930918f79e7eb9ff48290df2cb05fcc0b40a7f334e55d4d85f", size = 11351, upload-time = "2026-02-27T17:40:56.804Z" },
+]
+
 [[package]]
 name = "urllib3"
 version = "2.6.3"