Merge branch 'main' into feature-foundry-agents

python/packages/chatkit/README.md

@@ -60,8 +60,17 @@ class MyChatKitServer(ChatKitServer[dict[str, Any]]):
         if input_user_message is None:
             return
 
-        # Convert ChatKit message to Agent Framework format
-        agent_messages = await simple_to_agent_input(input_user_message)
+        # Load full thread history to maintain conversation context
+        thread_items_page = await self.store.load_thread_items(
+            thread_id=thread.id,
+            after=None,
+            limit=1000,
+            order="asc",
+            context=context,
+        )
+
+        # Convert all ChatKit messages to Agent Framework format
+        agent_messages = await simple_to_agent_input(thread_items_page.data)
 
         # Run the agent and stream responses
         response_stream = agent.run_stream(agent_messages)

python/samples/README.md

@@ -55,6 +55,7 @@ This directory contains samples demonstrating the capabilities of Microsoft Agen
 | [`getting_started/agents/azure_openai/azure_responses_client_with_code_interpreter.py`](./getting_started/agents/azure_openai/azure_responses_client_with_code_interpreter.py) | Azure OpenAI Responses Client with Code Interpreter Example |
 | [`getting_started/agents/azure_openai/azure_responses_client_with_explicit_settings.py`](./getting_started/agents/azure_openai/azure_responses_client_with_explicit_settings.py) | Azure OpenAI Responses Client with Explicit Settings Example |
 | [`getting_started/agents/azure_openai/azure_responses_client_with_function_tools.py`](./getting_started/agents/azure_openai/azure_responses_client_with_function_tools.py) | Azure OpenAI Responses Client with Function Tools Example |
+| [`getting_started/agents/azure_openai/azure_responses_client_with_hosted_mcp.py`](./getting_started/agents/azure_openai/azure_responses_client_with_hosted_mcp.py) | Azure OpenAI Responses Client with Hosted Model Context Protocol (MCP) Example |
 | [`getting_started/agents/azure_openai/azure_responses_client_with_local_mcp.py`](./getting_started/agents/azure_openai/azure_responses_client_with_local_mcp.py) | Azure OpenAI Responses Client with local Model Context Protocol (MCP) Example |
 | [`getting_started/agents/azure_openai/azure_responses_client_with_thread.py`](./getting_started/agents/azure_openai/azure_responses_client_with_thread.py) | Azure OpenAI Responses Client with Thread Management Example |
 

python/samples/demos/chatkit-integration/app.py

@@ -16,11 +16,43 @@ from random import randint
 from typing import Annotated, Any
 
 import uvicorn
+
+# Agent Framework imports
+from agent_framework import AgentRunResponseUpdate, ChatAgent, ChatMessage, FunctionResultContent, Role
+from agent_framework.azure import AzureOpenAIChatClient
+
+# Agent Framework ChatKit integration
+from agent_framework_chatkit import ThreadItemConverter, stream_agent_response
+
+# Local imports
+from attachment_store import FileBasedAttachmentStore
 from azure.identity import AzureCliCredential
+
+# ChatKit imports
+from chatkit.actions import Action
+from chatkit.server import ChatKitServer
+from chatkit.store import StoreItemType, default_generate_id
+from chatkit.types import (
+    ThreadItem,
+    ThreadItemDoneEvent,
+    ThreadMetadata,
+    ThreadStreamEvent,
+    UserMessageItem,
+    WidgetItem,
+)
+from chatkit.widgets import WidgetRoot
 from fastapi import FastAPI, File, Request, UploadFile
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse, JSONResponse, Response, StreamingResponse
 from pydantic import Field
+from store import SQLiteStore
+from weather_widget import (
+    WeatherData,
+    city_selector_copy_text,
+    render_city_selector_widget,
+    render_weather_widget,
+    weather_widget_copy_text,
+)
 
 # ============================================================================
 # Configuration Constants
@@ -56,37 +88,6 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# Agent Framework imports
-from agent_framework import AgentRunResponseUpdate, ChatAgent, ChatMessage, FunctionResultContent, Role
-from agent_framework.azure import AzureOpenAIChatClient
-
-# Agent Framework ChatKit integration
-from agent_framework_chatkit import ThreadItemConverter, stream_agent_response
-
-# Local imports
-from attachment_store import FileBasedAttachmentStore
-
-# ChatKit imports
-from chatkit.actions import Action
-from chatkit.server import ChatKitServer
-from chatkit.store import StoreItemType, default_generate_id
-from chatkit.types import (
-    ThreadItemDoneEvent,
-    ThreadMetadata,
-    ThreadStreamEvent,
-    UserMessageItem,
-    WidgetItem,
-)
-from chatkit.widgets import WidgetRoot
-from store import SQLiteStore
-from weather_widget import (
-    WeatherData,
-    city_selector_copy_text,
-    render_city_selector_widget,
-    render_weather_widget,
-    weather_widget_copy_text,
-)
-
 
 class WeatherResponse(str):
     """A string response that also carries WeatherData for widget creation."""
@@ -238,6 +239,81 @@ class WeatherChatKitServer(ChatKitServer[dict[str, Any]]):
         """
         return await attachment_store.read_attachment_bytes(attachment_id)
 
+    async def _update_thread_title(
+        self, thread: ThreadMetadata, thread_items: list[ThreadItem], context: dict[str, Any]
+    ) -> None:
+        """Update thread title using LLM to generate a concise summary.
+
+        Args:
+            thread: The thread metadata to update.
+            thread_items: All items in the thread.
+            context: The context dictionary.
+        """
+        logger.info(f"Attempting to update thread title for thread: {thread.id}")
+        
+        if not thread_items:
+            logger.debug("No thread items available for title generation")
+            return
+
+        # Collect user messages to understand the conversation topic
+        user_messages: list[str] = []
+        for item in thread_items:
+            if isinstance(item, UserMessageItem) and item.content:
+                for content_part in item.content:
+                    if hasattr(content_part, "text") and isinstance(content_part.text, str):
+                        user_messages.append(content_part.text)
+                        break
+
+        if not user_messages:
+            logger.debug("No user messages found for title generation")
+            return
+
+        logger.debug(f"Found {len(user_messages)} user message(s) for title generation")
+
+        try:
+            # Use the agent's chat client to generate a concise title
+            # Combine first few messages to capture the conversation topic
+            conversation_context = "\n".join(user_messages[:3])
+
+            title_prompt = [
+                ChatMessage(
+                    role=Role.USER,
+                    text=(
+                        f"Generate a very short, concise title (max 40 characters) for a conversation "
+                        f"that starts with:\n\n{conversation_context}\n\n"
+                        "Respond with ONLY the title, nothing else."
+                    ),
+                )
+            ]
+
+            # Use the chat client directly for a quick, lightweight call
+            response = await self.weather_agent.chat_client.get_response(
+                messages=title_prompt,
+                temperature=0.3,
+                max_tokens=20,
+            )
+
+            if response.messages and response.messages[-1].text:
+                title = response.messages[-1].text.strip().strip('"').strip("'")
+                # Ensure it's not too long
+                if len(title) > 50:
+                    title = title[:47] + "..."
+
+                thread.title = title
+                await self.store.save_thread(thread, context)
+                logger.info(f"Updated thread {thread.id} title to: {title}")
+
+        except Exception as e:
+            logger.warning(f"Failed to generate thread title, using fallback: {e}")
+            # Fallback to simple truncation
+            first_message: str = user_messages[0]
+            title: str = first_message[:50].strip()
+            if len(first_message) > 50:
+                title += "..."
+            thread.title = title
+            await self.store.save_thread(thread, context)
+            logger.info(f"Updated thread {thread.id} title to (fallback): {title}")
+
     async def respond(
         self,
         thread: ThreadMetadata,
@@ -263,8 +339,19 @@ class WeatherChatKitServer(ChatKitServer[dict[str, Any]]):
             weather_data: WeatherData | None = None
             show_city_selector = False
 
-            # Convert ChatKit user message to Agent Framework ChatMessage using ThreadItemConverter
-            agent_messages = await self.converter.to_agent_input(input_user_message)
+            # Load full thread history from the store
+            thread_items_page = await self.store.load_thread_items(
+                thread_id=thread.id,
+                after=None,
+                limit=1000,
+                order="asc",
+                context=context,
+            )
+            thread_items = thread_items_page.data
+
+            # Convert ALL thread items to Agent Framework ChatMessages using ThreadItemConverter
+            # This ensures the agent has the full conversation context
+            agent_messages = await self.converter.to_agent_input(thread_items)
 
             if not agent_messages:
                 logger.warning("No messages after conversion")
@@ -330,6 +417,10 @@ class WeatherChatKitServer(ChatKitServer[dict[str, Any]]):
                     yield widget_event
                 logger.debug("City selector widget streamed successfully")
 
+            # Update thread title based on first user message if not already set
+            if not thread.title or thread.title == "New thread":
+                await self._update_thread_title(thread, thread_items, context)
+
             logger.info(f"Completed processing message for thread: {thread.id}")
 
         except Exception as e:

python/samples/demos/chatkit-integration/attachment_store.py

@@ -8,7 +8,7 @@ cloud storage like S3, Azure Blob Storage, or Google Cloud Storage.
 """
 
 from pathlib import Path
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from chatkit.store import AttachmentStore
 from chatkit.types import Attachment, AttachmentCreateParams, FileAttachment, ImageAttachment
@@ -51,7 +51,7 @@ class FileBasedAttachmentStore(AttachmentStore[dict[str, Any]]):
         self.uploads_dir = Path(uploads_dir)
         self.base_url = base_url.rstrip("/")
         self.data_store = data_store
-        
+
         # Create uploads directory if it doesn't exist
         self.uploads_dir.mkdir(parents=True, exist_ok=True)
 
@@ -65,9 +65,7 @@ class FileBasedAttachmentStore(AttachmentStore[dict[str, Any]]):
         if file_path.exists():
             file_path.unlink()
 
-    async def create_attachment(
-        self, input: AttachmentCreateParams, context: dict[str, Any]
-    ) -> Attachment:
+    async def create_attachment(self, input: AttachmentCreateParams, context: dict[str, Any]) -> Attachment:
         """Create an attachment with upload URL for two-phase upload.
 
         This creates the attachment metadata and returns upload URLs that
@@ -75,7 +73,7 @@ class FileBasedAttachmentStore(AttachmentStore[dict[str, Any]]):
         """
         # Generate unique ID for this attachment
         attachment_id = self.generate_attachment_id(input.mime_type, context)
-        
+
         # Generate upload URL that points to our FastAPI upload endpoint
         upload_url = f"{self.base_url}/upload/{attachment_id}"
 
@@ -83,7 +81,7 @@ class FileBasedAttachmentStore(AttachmentStore[dict[str, Any]]):
         if input.mime_type.startswith("image/"):
             # For images, also provide a preview URL
             preview_url = f"{self.base_url}/preview/{attachment_id}"
-            
+
             attachment = ImageAttachment(
                 id=attachment_id,
                 type="image",
@@ -117,5 +115,5 @@ class FileBasedAttachmentStore(AttachmentStore[dict[str, Any]]):
         file_path = self.get_file_path(attachment_id)
         if not file_path.exists():
             raise FileNotFoundError(f"Attachment {attachment_id} not found on disk")
-        
+
         return file_path.read_bytes()

python/samples/demos/chatkit-integration/store.py

@@ -10,7 +10,7 @@ import sqlite3
 import uuid
 from typing import Any
 
-from chatkit.store import Store, NotFoundError
+from chatkit.store import NotFoundError, Store
 from chatkit.types import (
     Attachment,
     Page,
@@ -22,16 +22,19 @@ from pydantic import BaseModel
 
 class ThreadData(BaseModel):
     """Model for serializing thread data to SQLite."""
+
     thread: ThreadMetadata
 
 
 class ItemData(BaseModel):
     """Model for serializing thread item data to SQLite."""
+
     item: ThreadItem
 
 
 class AttachmentData(BaseModel):
     """Model for serializing attachment data to SQLite."""
+
     attachment: Attachment
 
 
@@ -185,19 +188,13 @@ class SQLiteStore(Store[dict[str, Any]]):
             params.append(limit + 1)
 
             items_cursor = conn.execute(query, params).fetchall()
-            items = [
-                ItemData.model_validate_json(row[0]).item for row in items_cursor
-            ]
+            items = [ItemData.model_validate_json(row[0]).item for row in items_cursor]
 
             has_more = len(items) > limit
             if has_more:
                 items = items[:limit]
 
-            return Page[ThreadItem](
-                data=items,
-                has_more=has_more,
-                after=items[-1].id if items else None
-            )
+            return Page[ThreadItem](data=items, has_more=has_more, after=items[-1].id if items else None)
 
     async def save_attachment(self, attachment: Attachment, context: dict[str, Any]) -> None:
         user_id = context.get("user_id", "demo_user")
@@ -270,23 +267,15 @@ class SQLiteStore(Store[dict[str, Any]]):
             params.append(limit + 1)
 
             threads_cursor = conn.execute(query, params).fetchall()
-            threads = [
-                ThreadData.model_validate_json(row[0]).thread for row in threads_cursor
-            ]
+            threads = [ThreadData.model_validate_json(row[0]).thread for row in threads_cursor]
 
             has_more = len(threads) > limit
             if has_more:
                 threads = threads[:limit]
 
-            return Page[ThreadMetadata](
-                data=threads,
-                has_more=has_more,
-                after=threads[-1].id if threads else None
-            )
+            return Page[ThreadMetadata](data=threads, has_more=has_more, after=threads[-1].id if threads else None)
 
-    async def add_thread_item(
-        self, thread_id: str, item: ThreadItem, context: dict[str, Any]
-    ) -> None:
+    async def add_thread_item(self, thread_id: str, item: ThreadItem, context: dict[str, Any]) -> None:
         user_id = context.get("user_id", "demo_user")
 
         with self._create_connection() as conn:
@@ -348,9 +337,7 @@ class SQLiteStore(Store[dict[str, Any]]):
             )
             conn.commit()
 
-    async def delete_thread_item(
-        self, thread_id: str, item_id: str, context: dict[str, Any]
-    ) -> None:
+    async def delete_thread_item(self, thread_id: str, item_id: str, context: dict[str, Any]) -> None:
         user_id = context.get("user_id", "demo_user")
 
         with self._create_connection() as conn:

python/samples/demos/chatkit-integration/weather_widget.py

@@ -29,7 +29,6 @@ POPULAR_CITIES = [
 CITY_VALUE_TO_NAME = {city["value"]: city["label"] for city in POPULAR_CITIES}
 
 
-
 def _sun_svg() -> str:
     """Generate SVG for sunny weather icon."""
     color = WEATHER_ICON_COLOR

python/samples/getting_started/agents/azure_ai/README.md

@@ -9,6 +9,8 @@ This folder contains examples demonstrating different ways to create and use age
 | [`azure_ai_basic.py`](azure_ai_basic.py) | The simplest way to create an agent using `AzureAIClient`. Demonstrates both streaming and non-streaming responses with function tools. Shows automatic agent creation and basic weather functionality. |
 | [`azure_ai_use_latest_version.py`](azure_ai_use_latest_version.py) | Demonstrates how to reuse the latest version of an existing agent instead of creating a new agent version on each instantiation using the `use_latest_version=True` parameter. |
 | [`azure_ai_with_azure_ai_search.py`](azure_ai_with_azure_ai_search.py) | Shows how to use Azure AI Search with Azure AI agents to search through indexed data and answer user questions with proper citations. Requires an Azure AI Search connection and index configured in your Azure AI project. |
+| [`azure_ai_with_bing_grounding.py`](azure_ai_with_bing_grounding.py) | Shows how to use Bing Grounding search with Azure AI agents to search the web for current information and provide grounded responses with citations. Requires a Bing connection configured in your Azure AI project. |
+| [`azure_ai_with_bing_custom_search.py`](azure_ai_with_bing_custom_search.py) | Shows how to use Bing Custom Search with Azure AI agents to search custom search instances and provide responses with relevant results. Requires a Bing Custom Search connection and instance configured in your Azure AI project. |
 | [`azure_ai_with_code_interpreter.py`](azure_ai_with_code_interpreter.py) | Shows how to use the `HostedCodeInterpreterTool` with Azure AI agents to write and execute Python code for mathematical problem solving and data analysis. |
 | [`azure_ai_with_existing_agent.py`](azure_ai_with_existing_agent.py) | Shows how to work with a pre-existing agent by providing the agent name and version to the Azure AI client. Demonstrates agent reuse patterns for production scenarios. |
 | [`azure_ai_with_existing_conversation.py`](azure_ai_with_existing_conversation.py) | Demonstrates how to use an existing conversation created on the service side with Azure AI agents. Shows two approaches: specifying conversation ID at the client level and using AgentThread with an existing conversation ID. |

python/samples/getting_started/agents/azure_ai/azure_ai_with_bing_custom_search.py

@@ -0,0 +1,48 @@
+# Copyright (c) Microsoft. All rights reserved.
+import asyncio
+import os
+
+from agent_framework.azure import AzureAIClient
+from azure.identity.aio import AzureCliCredential
+
+"""
+Azure AI Agent with Bing Custom Search Example
+
+This sample demonstrates usage of AzureAIClient with Bing Custom Search
+to search custom search instances and provide responses with relevant results.
+
+Prerequisites:
+1. Set AZURE_AI_PROJECT_ENDPOINT and AZURE_AI_MODEL_DEPLOYMENT_NAME environment variables.
+2. Ensure you have a Bing Custom Search connection configured in your Azure AI project
+   and set BING_CUSTOM_SEARCH_PROJECT_CONNECTION_ID and BING_CUSTOM_SEARCH_INSTANCE_NAME environment variables.
+"""
+
+
+async def main() -> None:
+    async with (
+        AzureCliCredential() as credential,
+        AzureAIClient(async_credential=credential).create_agent(
+            name="MyCustomSearchAgent",
+            instructions="""You are a helpful agent that can use Bing Custom Search tools to assist users.
+            Use the available Bing Custom Search tools to answer questions and perform tasks.""",
+            tools={
+                "type": "bing_custom_search",
+                "bing_custom_search": {
+                    "search_configurations": [
+                        {
+                            "project_connection_id": os.environ["BING_CUSTOM_SEARCH_PROJECT_CONNECTION_ID"],
+                            "instance_name": os.environ["BING_CUSTOM_SEARCH_INSTANCE_NAME"],
+                        }
+                    ]
+                },
+            },
+        ) as agent,
+    ):
+        query = "Tell me more about foundry agent service"
+        print(f"User: {query}")
+        result = await agent.run(query)
+        print(f"Result: {result}\n")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

python/samples/getting_started/agents/azure_ai/azure_ai_with_bing_grounding.py

@@ -0,0 +1,54 @@
+# Copyright (c) Microsoft. All rights reserved.
+import asyncio
+import os
+
+from agent_framework.azure import AzureAIClient
+from azure.identity.aio import AzureCliCredential
+
+"""
+Azure AI Agent with Bing Grounding Example
+
+This sample demonstrates usage of AzureAIClient with Bing Grounding
+to search the web for current information and provide grounded responses.
+
+Prerequisites:
+1. Set AZURE_AI_PROJECT_ENDPOINT and AZURE_AI_MODEL_DEPLOYMENT_NAME environment variables.
+2. Ensure you have a Bing connection configured in your Azure AI project
+   and set BING_PROJECT_CONNECTION_ID environment variable.
+
+To get your Bing connection ID:
+- Go to Azure AI Foundry portal (https://ai.azure.com)
+- Navigate to your project's "Connected resources" section
+- Add a new connection for "Grounding with Bing Search"
+- Copy the connection ID and set it as the BING_PROJECT_CONNECTION_ID environment variable
+"""
+
+
+async def main() -> None:
+    async with (
+        AzureCliCredential() as credential,
+        AzureAIClient(async_credential=credential).create_agent(
+            name="MyBingGroundingAgent",
+            instructions="""You are a helpful assistant that can search the web for current information.
+            Use the Bing search tool to find up-to-date information and provide accurate, well-sourced answers.
+            Always cite your sources when possible.""",
+            tools={
+                "type": "bing_grounding",
+                "bing_grounding": {
+                    "search_configurations": [
+                        {
+                            "project_connection_id": os.environ["BING_PROJECT_CONNECTION_ID"],
+                        }
+                    ]
+                },
+            },
+        ) as agent,
+    ):
+        query = "What is today's date and weather in Seattle?"
+        print(f"User: {query}")
+        result = await agent.run(query)
+        print(f"Result: {result}\n")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

python/samples/getting_started/agents/azure_openai/azure_responses_client_with_hosted_mcp.py

@@ -0,0 +1,240 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import asyncio
+from typing import TYPE_CHECKING, Any
+
+from agent_framework import ChatAgent, HostedMCPTool
+from agent_framework.azure import AzureOpenAIResponsesClient
+from azure.identity import AzureCliCredential
+
+"""
+Azure OpenAI Responses Client with Hosted MCP Example
+
+This sample demonstrates integrating hosted Model Context Protocol (MCP) tools with
+Azure OpenAI Responses Client, including user approval workflows for function call security.
+"""
+
+if TYPE_CHECKING:
+    from agent_framework import AgentProtocol, AgentThread
+
+
+async def handle_approvals_without_thread(query: str, agent: "AgentProtocol"):
+    """When we don't have a thread, we need to ensure we return with the input, approval request and approval."""
+    from agent_framework import ChatMessage
+
+    result = await agent.run(query)
+    while len(result.user_input_requests) > 0:
+        new_inputs: list[Any] = [query]
+        for user_input_needed in result.user_input_requests:
+            print(
+                f"User Input Request for function from {agent.name}: {user_input_needed.function_call.name}"
+                f" with arguments: {user_input_needed.function_call.arguments}"
+            )
+            new_inputs.append(ChatMessage(role="assistant", contents=[user_input_needed]))
+            user_approval = input("Approve function call? (y/n): ")
+            new_inputs.append(
+                ChatMessage(role="user", contents=[user_input_needed.create_response(user_approval.lower() == "y")])
+            )
+
+        result = await agent.run(new_inputs)
+    return result
+
+
+async def handle_approvals_with_thread(query: str, agent: "AgentProtocol", thread: "AgentThread"):
+    """Here we let the thread deal with the previous responses, and we just rerun with the approval."""
+    from agent_framework import ChatMessage
+
+    result = await agent.run(query, thread=thread, store=True)
+    while len(result.user_input_requests) > 0:
+        new_input: list[Any] = []
+        for user_input_needed in result.user_input_requests:
+            print(
+                f"User Input Request for function from {agent.name}: {user_input_needed.function_call.name}"
+                f" with arguments: {user_input_needed.function_call.arguments}"
+            )
+            user_approval = input("Approve function call? (y/n): ")
+            new_input.append(
+                ChatMessage(
+                    role="user",
+                    contents=[user_input_needed.create_response(user_approval.lower() == "y")],
+                )
+            )
+        result = await agent.run(new_input, thread=thread, store=True)
+    return result
+
+
+async def handle_approvals_with_thread_streaming(query: str, agent: "AgentProtocol", thread: "AgentThread"):
+    """Here we let the thread deal with the previous responses, and we just rerun with the approval."""
+    from agent_framework import ChatMessage
+
+    new_input: list[ChatMessage] = []
+    new_input_added = True
+    while new_input_added:
+        new_input_added = False
+        new_input.append(ChatMessage(role="user", text=query))
+        async for update in agent.run_stream(new_input, thread=thread, store=True):
+            if update.user_input_requests:
+                for user_input_needed in update.user_input_requests:
+                    print(
+                        f"User Input Request for function from {agent.name}: {user_input_needed.function_call.name}"
+                        f" with arguments: {user_input_needed.function_call.arguments}"
+                    )
+                    user_approval = input("Approve function call? (y/n): ")
+                    new_input.append(
+                        ChatMessage(
+                            role="user", contents=[user_input_needed.create_response(user_approval.lower() == "y")]
+                        )
+                    )
+                    new_input_added = True
+            else:
+                yield update
+
+
+async def run_hosted_mcp_without_thread_and_specific_approval() -> None:
+    """Example showing Mcp Tools with approvals without using a thread."""
+    print("=== Mcp with approvals and without thread ===")
+    credential = AzureCliCredential()
+    # Tools are provided when creating the agent
+    # The agent can use these tools for any query during its lifetime
+    async with ChatAgent(
+        chat_client=AzureOpenAIResponsesClient(
+            credential=credential,
+        ),
+        name="DocsAgent",
+        instructions="You are a helpful assistant that can help with microsoft documentation questions.",
+        tools=HostedMCPTool(
+            name="Microsoft Learn MCP",
+            url="https://learn.microsoft.com/api/mcp",
+            # we don't require approval for microsoft_docs_search tool calls
+            # but we do for any other tool
+            approval_mode={"never_require_approval": ["microsoft_docs_search"]},
+        ),
+    ) as agent:
+        # First query
+        query1 = "How to create an Azure storage account using az cli?"
+        print(f"User: {query1}")
+        result1 = await handle_approvals_without_thread(query1, agent)
+        print(f"{agent.name}: {result1}\n")
+        print("\n=======================================\n")
+        # Second query
+        query2 = "What is Microsoft Agent Framework?"
+        print(f"User: {query2}")
+        result2 = await handle_approvals_without_thread(query2, agent)
+        print(f"{agent.name}: {result2}\n")
+
+
+async def run_hosted_mcp_without_approval() -> None:
+    """Example showing Mcp Tools without approvals."""
+    print("=== Mcp without approvals ===")
+    credential = AzureCliCredential()
+    # Tools are provided when creating the agent
+    # The agent can use these tools for any query during its lifetime
+    async with ChatAgent(
+        chat_client=AzureOpenAIResponsesClient(
+            credential=credential,
+        ),
+        name="DocsAgent",
+        instructions="You are a helpful assistant that can help with microsoft documentation questions.",
+        tools=HostedMCPTool(
+            name="Microsoft Learn MCP",
+            url="https://learn.microsoft.com/api/mcp",
+            # we don't require approval for any function calls
+            # this means we will not see the approval messages,
+            # it is fully handled by the service and a final response is returned.
+            approval_mode="never_require",
+        ),
+    ) as agent:
+        # First query
+        query1 = "How to create an Azure storage account using az cli?"
+        print(f"User: {query1}")
+        result1 = await handle_approvals_without_thread(query1, agent)
+        print(f"{agent.name}: {result1}\n")
+        print("\n=======================================\n")
+        # Second query
+        query2 = "What is Microsoft Agent Framework?"
+        print(f"User: {query2}")
+        result2 = await handle_approvals_without_thread(query2, agent)
+        print(f"{agent.name}: {result2}\n")
+
+
+async def run_hosted_mcp_with_thread() -> None:
+    """Example showing Mcp Tools with approvals using a thread."""
+    print("=== Mcp with approvals and with thread ===")
+    credential = AzureCliCredential()
+    # Tools are provided when creating the agent
+    # The agent can use these tools for any query during its lifetime
+    async with ChatAgent(
+        chat_client=AzureOpenAIResponsesClient(
+            credential=credential,
+        ),
+        name="DocsAgent",
+        instructions="You are a helpful assistant that can help with microsoft documentation questions.",
+        tools=HostedMCPTool(
+            name="Microsoft Learn MCP",
+            url="https://learn.microsoft.com/api/mcp",
+            # we require approval for all function calls
+            approval_mode="always_require",
+        ),
+    ) as agent:
+        # First query
+        thread = agent.get_new_thread()
+        query1 = "How to create an Azure storage account using az cli?"
+        print(f"User: {query1}")
+        result1 = await handle_approvals_with_thread(query1, agent, thread)
+        print(f"{agent.name}: {result1}\n")
+        print("\n=======================================\n")
+        # Second query
+        query2 = "What is Microsoft Agent Framework?"
+        print(f"User: {query2}")
+        result2 = await handle_approvals_with_thread(query2, agent, thread)
+        print(f"{agent.name}: {result2}\n")
+
+
+async def run_hosted_mcp_with_thread_streaming() -> None:
+    """Example showing Mcp Tools with approvals using a thread."""
+    print("=== Mcp with approvals and with thread ===")
+    credential = AzureCliCredential()
+    # Tools are provided when creating the agent
+    # The agent can use these tools for any query during its lifetime
+    async with ChatAgent(
+        chat_client=AzureOpenAIResponsesClient(
+            credential=credential,
+        ),
+        name="DocsAgent",
+        instructions="You are a helpful assistant that can help with microsoft documentation questions.",
+        tools=HostedMCPTool(
+            name="Microsoft Learn MCP",
+            url="https://learn.microsoft.com/api/mcp",
+            # we require approval for all function calls
+            approval_mode="always_require",
+        ),
+    ) as agent:
+        # First query
+        thread = agent.get_new_thread()
+        query1 = "How to create an Azure storage account using az cli?"
+        print(f"User: {query1}")
+        print(f"{agent.name}: ", end="")
+        async for update in handle_approvals_with_thread_streaming(query1, agent, thread):
+            print(update, end="")
+        print("\n")
+        print("\n=======================================\n")
+        # Second query
+        query2 = "What is Microsoft Agent Framework?"
+        print(f"User: {query2}")
+        print(f"{agent.name}: ", end="")
+        async for update in handle_approvals_with_thread_streaming(query2, agent, thread):
+            print(update, end="")
+        print("\n")
+
+
+async def main() -> None:
+    print("=== OpenAI Responses Client Agent with Hosted Mcp Tools Examples ===\n")
+
+    await run_hosted_mcp_without_approval()
+    await run_hosted_mcp_without_thread_and_specific_approval()
+    await run_hosted_mcp_with_thread()
+    await run_hosted_mcp_with_thread_streaming()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())