Merge branch 'main' into flaky-test-report

2026-06-16 21:04:09 +08:00 · 2026-04-29 08:55:29 -07:00
parent e2eba0bacc f5419b9f38
commit 2e6b999bd2
286 changed files with 23505 additions and 2447 deletions
@@ -0,0 +1,8 @@
+# Azure AI Foundry Configuration (required for a2a_server.py and a2a_agent_as_function_tools.py)
+FOUNDRY_PROJECT_ENDPOINT=https://your-project.services.ai.azure.com/api/projects/your-project
+FOUNDRY_MODEL=gpt-4o
+
+# A2A Client Configuration (required for agent_with_a2a.py and a2a_agent_as_function_tools.py)
+# The function-tools flow uses http://localhost:5000/ in the sample docs/output.
+# Update this value if you start a different local A2A server instance on another port.
+A2A_AGENT_HOST=http://localhost:5000/
@@ -12,6 +12,7 @@ The remaining files are supporting modules used by the server:

 | File | Description |
 |------|-------------|
+| [`agent_framework_to_a2a.py`](agent_framework_to_a2a.py) | Exposes an agent_framework agent as an A2A-compliant server. Demonstrates how to wrap an agent_framework agent and expose it as an A2A service that other A2A clients can discover and communicate with. |
 | [`agent_definitions.py`](agent_definitions.py) | Agent and AgentCard factory definitions for invoice, policy, and logistics agents. |
 | [`agent_executor.py`](agent_executor.py) | Bridges the a2a-sdk `AgentExecutor` interface to Agent Framework agents. |
 | [`invoice_data.py`](invoice_data.py) | Mock invoice data and tool functions for the invoice agent. |
@@ -41,8 +42,33 @@ All commands below should be run from this directory:
 cd python/samples/04-hosting/a2a
 ```

+### 0. Install Dependencies
+
+Copy `.env.example` to `.env` and fill in your values:
+
+```powershell
+copy .env.example .env
+```
+
+**Option A — pip (standard):**
+
+```powershell
+python -m venv .venv
+.venv\Scripts\Activate.ps1      # Windows
+# source .venv/bin/activate     # macOS / Linux
+pip install -r requirements.txt
+```
+
+**Option B — uv:**
+
+```powershell
+uv run python a2a_server.py --agent-type policy
+```
+
 ### 1. Start the A2A Server

+> **Note (Option A — pip users):** Replace `uv run python` with `python` in all `uv run` commands below (e.g. `python a2a_server.py ...`). `uv` is not required once the virtual environment is activated.
+
 Pick an agent type and start the server (each in its own terminal):

 ```powershell
@@ -60,6 +86,9 @@ In a separate terminal (from the same directory), point the client at a running
 ```powershell
 $env:A2A_AGENT_HOST = "http://localhost:5001/"
 uv run python agent_with_a2a.py
+
+# A2A server exposing an agent_framework agent
+uv run python agent_framework_to_a2a.py
 ```

 ### 3. Run the Function Tools Sample
@@ -0,0 +1,70 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import uvicorn
+from a2a.server.apps import A2AStarletteApplication
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.tasks import InMemoryTaskStore
+from a2a.types import (
+    AgentCapabilities,
+    AgentCard,
+    AgentSkill,
+)
+from agent_framework import Agent
+from agent_framework.a2a import A2AExecutor
+from agent_framework.openai import OpenAIChatClient
+from dotenv import load_dotenv
+
+load_dotenv()
+
+if __name__ == "__main__":
+    # --8<-- [start:AgentSkill]
+    flight_skill = AgentSkill(
+        id="Flight_Booking",
+        name="Flight Booking",
+        description="Search and book flights across Europe.",
+        tags=["flights", "travel", "europe"],
+        examples=[],
+    )
+    hotel_skill = AgentSkill(
+        id="Hotel_Booking",
+        name="Hotel Booking",
+        description="Search and book hotels across Europe.",
+        tags=["hotels", "travel", "accommodation"],
+        examples=[],
+    )
+    # --8<-- [end:AgentSkill]
+
+    # --8<-- [start:AgentCard]
+    # This will be the public-facing agent card
+    public_agent_card = AgentCard(
+        name="Europe Travel Agent",
+        description="A helpful Europe Travel Agent that can help users search and book flights and hotels across Europe.",
+        url="http://localhost:9999/",
+        version="1.0.0",
+        defaultInputModes=["text"],
+        defaultOutputModes=["text"],
+        capabilities=AgentCapabilities(streaming=True),
+        skills=[flight_skill, hotel_skill],
+    )
+    # --8<-- [end:AgentCard]
+
+    agent = Agent(
+        client=OpenAIChatClient(),
+        name="Europe Travel Agent",
+        instructions="You are a helpful Europe Travel Agent. You can help users search and book flights and hotels across Europe.",
+    )
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=A2AExecutor(agent),
+        task_store=InMemoryTaskStore(),
+    )
+
+    server = A2AStarletteApplication(
+        agent_card=public_agent_card,
+        http_handler=request_handler,
+    )
+
+    server = server.build()
+    # print(schemas.get_schema(server.routes))
+
+    uvicorn.run(server, host="0.0.0.0", port=9999)
@@ -0,0 +1,23 @@
+# Agent Framework packages
+# To use the deployed version, uncomment the lines below and comment out the local installation lines
+# agent-framework-a2a
+# agent-framework-foundry
+
+# Local installation (for development and testing)
+# Each package must be listed explicitly because pip doesn't resolve uv workspace sources.
+# Without explicit entries, pip would fetch transitive dependencies from PyPI instead of local source.
+-e ../../../packages/core  # Core framework - base dependency for all packages
+-e ../../../packages/foundry  # Foundry support - dependency for FoundryChatClient in a2a_server.py
+-e ../../../packages/a2a  # A2A integration - provides A2AAgent and a2a-sdk
+
+# Azure authentication
+azure-identity
+
+# A2A server runtime
+uvicorn
+
+# HTTP client used by A2A client samples
+httpx
+
+# Environment variable loading
+python-dotenv
@@ -1,12 +1,139 @@
-# Foundry Hosted Agents Samples
+# Foundry Hosted Agent Samples

-This directory contains samples that demonstrate how to use the Agent Framework to host agents on Foundry with different capabilities and configurations. Each sample includes a README with instructions on how to set up, run, and interact with the agent.
+This directory contains samples that demonstrate how to use hosted [Agent Framework](https://github.com/microsoft/agent-framework) agents with different capabilities and configurations on Foundry using the Foundry Hosting Agent service. Each sample includes a README with instructions on how to set up, run, and interact with the agent.

-Read more about Foundry Hosted Agents [here](https://learn.microsoft.com/en-us/azure/foundry/agents/concepts/hosted-agents).
+## Samples

-## Environment setup
+### Responses API

-1. Navigate to the sample directory you want to run. For example:
+| # | Sample | Description |
+|---|--------|-------------|
+| 1 | [Basic](responses/01_basic/) | A minimal agent demonstrating basic request/response interaction and multi-turn conversations using `previous_response_id`. |
+| 2 | [Tools](responses/02_tools/) | An agent with local tools (e.g., weather lookup), demonstrating how to register and invoke custom tool functions alongside the LLM. |
+| 3 | [MCP](responses/03_mcp/) | An agent connected to a remote MCP server (GitHub), demonstrating external MCP tool provider integration. |
+| 4 | [Foundry Toolbox](responses/04_foundry_toolbox/) | An agent using Azure Foundry Toolbox, demonstrating toolbox provisioning and querying available tools at runtime. |
+| 5 | [Workflows](responses/05_workflows/) | An agent with a multi-step orchestrated workflow, demonstrating chaining prompts through an orchestrated flow. |
+| 6 | [Using deployed agent](responses/using_deployed_agent.py) | A sample demonstrating how to invoke an agent that has already been deployed to Foundry, showing how to interact with a hosted agent in code. |
+
+### Invocations API
+
+| # | Sample | Description |
+|---|--------|-------------|
+| 1 | [Basic](invocations/01_basic/) | A minimal agent demonstrating session state management via `agent_session_id` in URL params/response headers. |
+| 2 | [Break Glass](invocations/02_break_glass/) | An agent demonstrating a "break glass" scenario where customizations of the API behaviors are needed, allowing for more direct control over how requests and responses are handled by the hosting layer. |
+
+## Running the Agent Host Locally
+
+### Using `azd`
+
+#### Prerequisites
+
+1. **Azure Developer CLI (`azd`)**
+
+    - [Install azd](https://learn.microsoft.com/en-us/azure/developer/azure-developer-cli/install-azd) and the AI agent extension: `azd ext install azure.ai.agents`
+    - Authenticated: `azd auth login`
+
+2. **Azure Subscription**
+
+#### Create a new project
+
+**No cloning required**. Create a new folder, point azd at the manifest on GitHub.
+
+```bash
+mkdir hosted-agent-framework-agent && cd hosted-agent-framework-agent
+
+# Initialize from the manifest
+azd ai agent init -m https://github.com/microsoft/agent-framework/blob/main/python/samples/04-hosting/foundry-hosted-agents/responses/01_basic/agent.manifest.yaml
+```
+
+Follow the instructions from `azd ai agent init` to complete the agent initialization. If you don't have an existing Foundry project and a model deployment, `azd ai agent init` will guide you through creating them.
+
+#### Provision Azure Resources
+
+> This step is only needed if you don't have an existing Foundry project and model deployment.
+
+Run the following command to provision the necessary Azure resources:
+
+```bash
+azd provision
+```
+
+This will create the following Azure resources:
+
+- A new resource group named `rg-[project_name]-dev`. In this guide, `[project_name]` will be `hosted-agent-framework-agent`.
+- Within the resource group, among other resources, the most important ones are:
+  - A new Foundry instance
+  - A new Foundry project, within which a new model deployment will be created
+  - An Application Insights instance
+  - A container registry, which will be used to store the container images for the hosted agent
+
+#### Set Environment Variables
+
+```bash
+export FOUNDRY_PROJECT_ENDPOINT="https://<account>.services.ai.azure.com/api/projects/<project>"
+export AZURE_AI_MODEL_DEPLOYMENT_NAME="<your-model-deployment-name>"
+# And any other environment variables required by the sample
+```
+
+Or in PowerShell:
+
+```powershell
+$env:FOUNDRY_PROJECT_ENDPOINT="https://<account>.services.ai.azure.com/api/projects/<project>"
+$env:AZURE_AI_MODEL_DEPLOYMENT_NAME="<your-model-deployment-name>"
+# And any other environment variables required by the sample
+```
+
+> Note: The environment variables set above are only for the current session. You will need to set them again if you open a new terminal session. if you want to set the environment variables permanently in the azd environment, you can use `azd env set <name> <value>`.
+
+#### Running the Agent Host
+
+```bash
+azd ai agent run
+```
+
+Right now, the agent host should be running on `http://localhost:8088`
+
+#### Invoking the Agent
+
+Open another terminal, **navigate to the project directory**, and run the following command to invoke the agent:
+
+```bash
+azd ai agent invoke --local "Hello!"
+```
+
+Or you can in another terminal, without navigating to the project directory, run the following command to invoke the agent:
+
+```bash
+curl -X POST http://localhost:8088/responses -H "Content-Type: application/json" -d '{"input": "Hello!"}'
+```
+
+Or in PowerShell:
+
+```powershell
+(Invoke-WebRequest -Uri http://localhost:8088/responses -Method POST -ContentType "application/json" -Body '{"input": "Hello!"}').Content
+```
+
+### Using `python`
+
+#### Prerequisites
+
+1. An existing Foundry project
+2. A deployed model in your Foundry project
+3. Azure CLI installed and authenticated
+4. Python 3.10 or later
+
+#### Running the Agent Host with Python
+
+Clone the repository containing the sample code:
+
+```bash
+git clone https://github.com/microsoft/agent-framework.git
+cd agent-framework/python/samples/04-hosting/foundry-hosted-agents/responses
+```
+
+#### Environment setup
+
+1. Navigate to the sample directory you want to explore. Create a virtual environment:

   ```bash
   python -m venv .venv
@@ -32,25 +159,58 @@ Read more about Foundry Hosted Agents [here](https://learn.microsoft.com/en-us/a
   az login
   ```

-## Deploying to a Docker container
-
-Navigate to the sample directory and build the Docker image:
+#### Running the Agent Host

 ```bash
-docker build -t hosted-agent-sample .
+python main.py
 ```

-Run the container, passing in the required environment variables:
+Right now, the agent host should be running on `http://localhost:8088`
+
+#### Invoking the Agent
+
+On another terminal, run the following command to invoke the agent:

 ```bash
-docker run -p 8088:8088 \
-  -e FOUNDRY_PROJECT_ENDPOINT=<your-endpoint> \
-  -e MODEL_DEPLOYMENT_NAME=<your-model> \
-  hosted-agent-sample
+curl -X POST http://localhost:8088/responses -H "Content-Type: application/json" -d '{"input": "Hello!"}'
 ```

-The server will be available at `http://localhost:8088`. You can send requests using the same `curl` command shown above.
+Or in PowerShell:

-## Deploying to Foundry
+```powershell
+(Invoke-WebRequest -Uri http://localhost:8088/responses -Method POST -ContentType "application/json" -Body '{"input": "Hello!"}').Content
+```

-Follow this [guide](https://learn.microsoft.com/en-us/azure/foundry/agents/how-to/deploy-hosted-agent?tabs=bash#configure-your-agent) to deploy your agent to Foundry.
+## Deploying the Agent to Foundry
+
+Once you've tested locally, deploy to Microsoft Foundry.
+
+### With an Existing Foundry Project
+
+If you already have a Foundry project and the necessary Azure resources provisioned, you can skip the setup steps and proceed directly to deploying the agent.
+
+After running `azd ai agent init -m <agent.manifest.yaml>` and following the prompts to configure your agent, you will have a project ready for deployment.
+
+### Setting Up a New Foundry Project
+
+Follow the steps in [Using `azd`](#using-azd) to set up the project and provision the necessary Azure resources for your Foundry deployment.
+
+### Deploying the Agent
+
+Once the project is setup and resources are provisioned, you can deploy the agent to Foundry by running:
+
+```bash
+azd deploy
+```
+
+> The Foundry hosting infrastructure will inject the following environment variables into your agent at runtime:
+>
+> - `FOUNDRY_PROJECT_ENDPOINT`: The endpoint URL for the Foundry project where the agent is deployed.
+> - `AZURE_AI_MODEL_DEPLOYMENT_NAME`: The name of the model deployment in your Foundry project. This is configured during the agent initialization process with `azd ai agent init`.
+> - `APPLICATIONINSIGHTS_CONNECTION_STRING`: The connection string for Application Insights to enable telemetry for your agent.
+
+This will package your agent and deploy it to the Foundry environment, making it accessible through the Foundry project endpoint. Once it's deployed, you can also access the agent through the Foundry UI.
+
+For the full deployment guide, see the [official deployment guide](https://learn.microsoft.com/en-us/azure/foundry/agents/how-to/deploy-hosted-agent).
+
+Once deployed, learn more about how to manage deployed agents in the [official management guide](https://learn.microsoft.com/en-us/azure/foundry/agents/how-to/manage-hosted-agent).
@@ -1,2 +1,2 @@
 FOUNDRY_PROJECT_ENDPOINT="..."
-MODEL_DEPLOYMENT_NAME="..."
+AZURE_AI_MODEL_DEPLOYMENT_NAME="..."
@@ -1,18 +1,26 @@
-# Basic example of hosting an agent with the `invocations` API
+# What this sample demonstrates

-## Running the server locally
+An [Agent Framework](https://github.com/microsoft/agent-framework) agent hosted using the **Invocations protocol** with session management. Unlike the Responses protocol, the Invocations protocol does **not** provide built-in server-side conversation history — this agent maintains an in-memory session store keyed by `agent_session_id`. In production, replace it with durable storage (Redis, Cosmos DB, etc.) so history survives restarts.

-### Environment setup
+## How It Works

-Follow the instructions in the [Environment setup](../../README.md#environment-setup) section of the README in the parent directory to set up your environment and install dependencies.
+### Model Integration

-Run the following command to start the server:
+The agent uses `FoundryChatClient` from the Agent Framework to create a Responses client from the project endpoint and model deployment. When a request arrives, the handler looks up (or creates) a session by `session_id`, runs the agent with the user message and session context, and returns the reply. The agent supports both streaming (SSE events) and non-streaming (JSON) response modes.

-```bash
-python main.py
-```
+See [main.py](main.py) for the full implementation.

-### Interacting with the agent
+### Agent Hosting
+
+The agent is hosted using the [Agent Framework](https://github.com/microsoft/agent-framework) with the `InvocationsHostServer`, which provisions a REST API endpoint compatible with the Azure AI Invocations protocol.
+
+## Running the Agent Host
+
+Follow the instructions in the [Running the Agent Host Locally](../../README.md#running-the-agent-host-locally) section of the README in the parent directory to run the agent host.
+
+## Interacting with the agent
+
+> Depending on how you run the agent host, you can invoke the agent using `curl` (`Invoke-WebRequest` in PowerShell) or `azd`. Please refer to the [parent README](../../README.md) for more details. Use this README for sample queries you can send to the agent.

 Send a POST request to the server with a JSON body containing a "message" field to interact with the agent. For example:

@@ -22,7 +30,7 @@ curl -X POST http://localhost:8088/invocations -i -H "Content-Type: application/

 The server will respond with a JSON object containing the response text. The `-i` flag in the `curl` command includes the HTTP response headers in the output, which includes the session ID that can be used for multi-turn conversations. Here is an example of the response:

-```bash
+```
 HTTP/1.1 200
 content-length: 34
 content-type: application/json
@@ -42,3 +50,7 @@ To have a multi-turn conversation with the agent, take the session ID from the r
 ```bash
 curl -X POST http://localhost:8088/invocations?agent_session_id=9370b9d4-cd13-4436-a57f-03b843ac0e17 -i -H "Content-Type: application/json" -d '{"message": "How are you?"}'
 ```
+
+## Deploying the Agent to Foundry
+
+To host the agent on Foundry, follow the instructions in the [Deploying the Agent to Foundry](../../README.md#deploying-the-agent-to-foundry) section of the README in the parent directory.
@@ -15,9 +15,9 @@ template:
    - protocol: invocations
      version: 1.0.0
  environment_variables:
-    - name: MODEL_DEPLOYMENT_NAME
-      value: "{{MODEL_DEPLOYMENT_NAME}}"
+    - name: AZURE_AI_MODEL_DEPLOYMENT_NAME
+      value: "{{AZURE_AI_MODEL_DEPLOYMENT_NAME}}"
 resources:
  - kind: model
    id: gpt-4.1-mini
-    name: MODEL_DEPLOYMENT_NAME
+    name: AZURE_AI_MODEL_DEPLOYMENT_NAME
@@ -6,4 +6,4 @@ protocols:
    version: 1.0.0
 resources:
  cpu: '0.25'
-  memory: '0.5Gi'
+  memory: '0.5Gi'
@@ -5,7 +5,7 @@ import os
 from agent_framework import Agent
 from agent_framework.foundry import FoundryChatClient
 from agent_framework_foundry_hosting import InvocationsHostServer
-from azure.identity import AzureCliCredential
+from azure.identity import DefaultAzureCredential
 from dotenv import load_dotenv

 # Load environment variables from .env file
@@ -15,8 +15,8 @@ load_dotenv()
 def main():
    client = FoundryChatClient(
        project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
-        model=os.environ["MODEL_DEPLOYMENT_NAME"],
-        credential=AzureCliCredential(),
+        model=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
+        credential=DefaultAzureCredential(),
    )

    agent = Agent(
@@ -1,2 +1,2 @@
 FOUNDRY_PROJECT_ENDPOINT="..."
-MODEL_DEPLOYMENT_NAME="..."
+AZURE_AI_MODEL_DEPLOYMENT_NAME="..."
@@ -1,20 +1,26 @@
-# Basic example of hosting an agent with the `invocations` API
+# What this sample demonstrates

-This is the same as the [01_basic](../01_basic/README.md) example, but demonstrates the "break glass" scenario where you can create your own `invoke_handler` to handle specific types of invocations. This is useful when you want to override the default behavior for certain requests or add custom processing logic.
+An [Agent Framework](https://github.com/microsoft/agent-framework) agent hosted using the **Invocations protocol** with session management. Unlike the Responses protocol, the Invocations protocol does **not** provide built-in server-side conversation history — this agent maintains an in-memory session store keyed by `agent_session_id`. In production, replace it with durable storage (Redis, Cosmos DB, etc.) so history survives restarts.

-## Running the server locally
+## How It Works

-### Environment setup
+### Model Integration

-Follow the instructions in the [Environment setup](../../README.md#environment-setup) section of the README in the parent directory to set up your environment and install dependencies.
+The agent uses `FoundryChatClient` from the Agent Framework to create a Responses client from the project endpoint and model deployment. When a request arrives, the handler looks up (or creates) a session by `session_id`, runs the agent with the user message and session context, and returns the reply. The agent supports both streaming (SSE events) and non-streaming (JSON) response modes.

-Run the following command to start the server:
+See [main.py](main.py) for the full implementation.

-```bash
-python main.py
-```
+### Agent Hosting

-### Interacting with the agent
+The agent is hosted using the [Azure AI AgentServer Invocations SDK](https://pypi.org/project/azure-ai-agentserver-invocations/) (`InvocationAgentServerHost`), which provisions a REST API endpoint compatible with the Azure AI Invocations protocol.
+
+## Running the Agent Host
+
+Follow the instructions in the [Running the Agent Host Locally](../../README.md#running-the-agent-host-locally) section of the README in the parent directory to run the agent host.
+
+## Interacting with the agent
+
+> Depending on how you run the agent host, you can invoke the agent using `curl` (`Invoke-WebRequest` in PowerShell) or `azd`. Please refer to the [parent README](../../README.md) for more details. Use this README for sample queries you can send to the agent.

 Send a POST request to the server with a JSON body containing a "message" field to interact with the agent. For example:

@@ -24,7 +30,7 @@ curl -X POST http://localhost:8088/invocations -i -H "Content-Type: application/

 The server will respond with a JSON object containing the response text. The `-i` flag in the `curl` command includes the HTTP response headers in the output, which includes the session ID that can be used for multi-turn conversations. Here is an example of the response:

-```bash
+```
 HTTP/1.1 200
 content-length: 34
 content-type: application/json
@@ -44,3 +50,7 @@ To have a multi-turn conversation with the agent, take the session ID from the r
 ```bash
 curl -X POST http://localhost:8088/invocations?agent_session_id=9370b9d4-cd13-4436-a57f-03b843ac0e17 -i -H "Content-Type: application/json" -d '{"message": "How are you?"}'
 ```
+
+## Deploying the Agent to Foundry
+
+To host the agent on Foundry, follow the instructions in the [Deploying the Agent to Foundry](../../README.md#deploying-the-agent-to-foundry) section of the README in the parent directory.
@@ -15,9 +15,9 @@ template:
    - protocol: invocations
      version: 1.0.0
  environment_variables:
-    - name: MODEL_DEPLOYMENT_NAME
-      value: "{{MODEL_DEPLOYMENT_NAME}}"
+    - name: AZURE_AI_MODEL_DEPLOYMENT_NAME
+      value: "{{AZURE_AI_MODEL_DEPLOYMENT_NAME}}"
 resources:
  - kind: model
    id: gpt-4.1-mini
-    name: MODEL_DEPLOYMENT_NAME
+    name: AZURE_AI_MODEL_DEPLOYMENT_NAME
@@ -6,4 +6,4 @@ protocols:
    version: 1.0.0
 resources:
  cpu: '0.25'
-  memory: '0.5Gi'
+  memory: '0.5Gi'
@@ -22,7 +22,7 @@ _sessions: dict[str, AgentSession] = {}
 # Create the agent
 client = FoundryChatClient(
    project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
-    model=os.environ["MODEL_DEPLOYMENT_NAME"],
+    model=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
    credential=DefaultAzureCredential(),
 )

@@ -1,8 +0,0 @@
-# Hosting agents with Foundry Hosting and the `invocations` API
-
-This folder contains a list of samples that show how to host agents using the `invocations` API and deploy them to Foundry Hosting.
-
-| Sample | Description |
-| --- | --- |
-| [01_basic](./01_basic) | A basic example of hosting an agent with the `invocations` API and carrying on a multi-turn conversation. |
-| [02_break_glass](./02_break_glass) | An example of hosting an agent with the `invocations` API and a "break glass" scenario where you can create your own `invoke_handler` to handle specific types of invocations. |
@@ -1,2 +1,2 @@
 FOUNDRY_PROJECT_ENDPOINT="..."
-MODEL_DEPLOYMENT_NAME="..."
+AZURE_AI_MODEL_DEPLOYMENT_NAME="..."
@@ -1,31 +1,39 @@
-# Basic example of hosting an agent with the `responses` API
+# What this sample demonstrates

-This agent only contains an instruction (personal). It's the most basic agent with an LLM and no tools.
+An [Agent Framework](https://github.com/microsoft/agent-framework) agent hosted using the **Responses protocol**.

-## Running the server locally
+## How It Works

-### Environment setup
+### Model Integration

-Follow the instructions in the [Environment setup](../../README.md#environment-setup) section of the README in the parent directory to set up your environment and install dependencies.
+The agent uses `FoundryChatClient` from the Agent Framework to create a Responses client from the project endpoint and model deployment. The agent supports both streaming (SSE events) and non-streaming (JSON) response modes.

-Run the following command to start the server:
+See [main.py](main.py) for the full implementation.

-```bash
-python main.py
-```
+### Agent Hosting
+
+The agent is hosted using the [Agent Framework](https://github.com/microsoft/agent-framework) with the `ResponsesHostServer`, which provisions a REST API endpoint compatible with the OpenAI Responses protocol.

 ## Interacting with the agent

-Send a POST request to the server with a JSON body containing a "input" field to interact with the agent. For example:
+> Depending on how you run the agent host, you can invoke the agent using `curl` (`Invoke-WebRequest` in PowerShell) or `azd`. Please refer to the [parent README](../../README.md) for more details. Use this README for sample queries you can send to the agent.
+
+Send a POST request to the server with a JSON body containing an `"input"` field to interact with the agent. For example:

 ```bash
 curl -X POST http://localhost:8088/responses -H "Content-Type: application/json" -d '{"input": "Hi"}'
 ```

-## Multi-turn conversation
+The server will respond with a JSON object containing the response text and a response ID. You can use this response ID to continue the conversation in subsequent requests.
+
+### Multi-turn conversation

 To have a multi-turn conversation with the agent, include the previous response id in the request body. For example:

 ```bash
 curl -X POST http://localhost:8088/responses -H "Content-Type: application/json" -d '{"input": "How are you?", "previous_response_id": "REPLACE_WITH_PREVIOUS_RESPONSE_ID"}'
 ```
+
+## Deploying the Agent to Foundry
+
+To host the agent on Foundry, follow the instructions in the [Deploying the Agent to Foundry](../../README.md#deploying-the-agent-to-foundry) section of the README in the parent directory.
@@ -1,4 +1,4 @@
-name: agent-framework-agent-basic
+name: agent-framework-agent-basic-responses
 description: >
  A basic Agent Framework agent hosted by Foundry.
 metadata:
@@ -9,15 +9,15 @@ metadata:
    - Responses Protocol
    - Streaming
 template:
-  name: agent-framework-agent-basic
+  name: agent-framework-agent-basic-responses
  kind: hosted
  protocols:
    - protocol: responses
      version: 1.0.0
  environment_variables:
-    - name: MODEL_DEPLOYMENT_NAME
-      value: "{{MODEL_DEPLOYMENT_NAME}}"
+    - name: AZURE_AI_MODEL_DEPLOYMENT_NAME
+      value: "{{AZURE_AI_MODEL_DEPLOYMENT_NAME}}"
 resources:
  - kind: model
    id: gpt-4.1-mini
-    name: MODEL_DEPLOYMENT_NAME
+    name: AZURE_AI_MODEL_DEPLOYMENT_NAME
@@ -1,8 +1,9 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/microsoft/AgentSchema/refs/heads/main/schemas/v1.0/ContainerAgent.yaml
 kind: hosted
-name: agent-framework-agent-basic
+name: agent-framework-agent-basic-responses
 protocols:
  - protocol: responses
    version: 1.0.0
 resources:
-  cpu: "0.25"
-  memory: 0.5Gi
+  cpu: '0.25'
+  memory: '0.5Gi'
@@ -5,7 +5,7 @@ import os
 from agent_framework import Agent
 from agent_framework.foundry import FoundryChatClient
 from agent_framework_foundry_hosting import ResponsesHostServer
-from azure.identity import AzureCliCredential
+from azure.identity import DefaultAzureCredential
 from dotenv import load_dotenv

 # Load environment variables from .env file
@@ -15,8 +15,8 @@ load_dotenv()
 def main():
    client = FoundryChatClient(
        project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
-        model=os.environ["MODEL_DEPLOYMENT_NAME"],
-        credential=AzureCliCredential(),
+        model=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
+        credential=DefaultAzureCredential(),
    )

    agent = Agent(
@@ -1,2 +0,0 @@
-FOUNDRY_PROJECT_ENDPOINT="..."
-MODEL_DEPLOYMENT_NAME="..."
@@ -1,27 +0,0 @@
-# Basic example of hosting an agent with the `responses` API and local tools
-
-This agent is equipped with a function tool and a local shell tool.
-
-> We recommend deploying this sample on a local container or to Foundry Hosting because the agent has access to a local shell tool, which can run arbitrary commands on the machine.
-
-## Running the server locally
-
-### Environment setup
-
-Follow the instructions in the [Environment setup](../../README.md#environment-setup) section of the README in the parent directory to set up your environment and install dependencies.
-
-Run the following command to start the server:
-
-```bash
-python main.py
-```
-
-## Interacting with the agent
-
-Send a POST request to the server with a JSON body containing a "input" field to interact with the agent. For example:
-
-```bash
-curl -X POST http://localhost:8088/responses -H "Content-Type: application/json" -d '{"input": "What is the weather in Seattle?"}'
-
-curl -X POST http://localhost:8088/responses -H "Content-Type: application/json" -d '{"input": "List the files in the current directory."}'
-```
@@ -0,0 +1,2 @@
+FOUNDRY_PROJECT_ENDPOINT="..."
+AZURE_AI_MODEL_DEPLOYMENT_NAME="..."
@@ -0,0 +1,33 @@
+# What this sample demonstrates
+
+An [Agent Framework](https://github.com/microsoft/agent-framework) agent with **locally-defined Python tools** hosted using the **Responses protocol**. It shows how to define custom tools with the `@tool` decorator and register them with the agent so the model can call them during a conversation.
+
+## How It Works
+
+### Model Integration
+
+The agent uses `FoundryChatClient` from the Agent Framework to create a Responses client from the project endpoint and model deployment. The agent supports both streaming (SSE events) and non-streaming (JSON) response modes.
+
+See [main.py](main.py) for the full implementation.
+
+### Agent Hosting
+
+The agent is hosted using the [Agent Framework](https://github.com/microsoft/agent-framework) with the `ResponsesHostServer`, which provisions a REST API endpoint compatible with the OpenAI Responses protocol.
+
+## Running the Agent Host
+
+Follow the instructions in the [Running the Agent Host Locally](../../README.md#running-the-agent-host-locally) section of the README in the parent directory to run the agent host.
+
+## Interacting with the agent
+
+> Depending on how you run the agent host, you can invoke the agent using `curl` (`Invoke-WebRequest` in PowerShell) or `azd`. Please refer to the [parent README](../../README.md) for more details. Use this README for sample queries you can send to the agent.
+
+Send a POST request to the server with a JSON body containing an `"input"` field to interact with the agent. For example:
+
+```bash
+curl -X POST http://localhost:8088/responses -H "Content-Type: application/json" -d '{"input": "What is the weather in Seattle?"}'
+```
+
+## Deploying the Agent to Foundry
+
+To host the agent on Foundry, follow the instructions in the [Deploying the Agent to Foundry](../../README.md#deploying-the-agent-to-foundry) section of the README in the parent directory.
@@ -1,4 +1,4 @@
-name: agent-framework-agent-with-local-tools
+name: agent-framework-agent-with-local-tools-responses
 description: >
  An Agent Framework agent with local tools hosted by Foundry.
 metadata:
@@ -9,15 +9,15 @@ metadata:
    - Responses Protocol
    - Streaming
 template:
-  name: agent-framework-agent-with-local-tools
+  name: agent-framework-agent-with-local-tools-responses
  kind: hosted
  protocols:
    - protocol: responses
      version: 1.0.0
  environment_variables:
-    - name: MODEL_DEPLOYMENT_NAME
-      value: "{{MODEL_DEPLOYMENT_NAME}}"
+    - name: AZURE_AI_MODEL_DEPLOYMENT_NAME
+      value: "{{AZURE_AI_MODEL_DEPLOYMENT_NAME}}"
 resources:
  - kind: model
    id: gpt-4.1-mini
-    name: MODEL_DEPLOYMENT_NAME
+    name: AZURE_AI_MODEL_DEPLOYMENT_NAME
@@ -1,5 +1,5 @@
 kind: hosted
-name: agent-framework-agent-with-local-tools
+name: agent-framework-agent-with-local-tools-responses
 protocols:
  - protocol: responses
    version: 1.0.0
@@ -8,7 +8,7 @@ from typing import Annotated
 from agent_framework import Agent, tool
 from agent_framework.foundry import FoundryChatClient
 from agent_framework_foundry_hosting import ResponsesHostServer
-from azure.identity import AzureCliCredential
+from azure.identity import DefaultAzureCredential
 from dotenv import load_dotenv
 from pydantic import Field

@@ -52,8 +52,8 @@ def run_bash(command: str) -> str:
 def main():
    client = FoundryChatClient(
        project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
-        model=os.environ["MODEL_DEPLOYMENT_NAME"],
-        credential=AzureCliCredential(),
+        model=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
+        credential=DefaultAzureCredential(),
    )

    agent = Agent(
@@ -1,4 +1,3 @@
 FOUNDRY_PROJECT_ENDPOINT="..."
-MODEL_DEPLOYMENT_NAME="..."
-TOOLBOX_NAME="..."
+AZURE_AI_MODEL_DEPLOYMENT_NAME="..."
 GITHUB_PAT="..."
@@ -0,0 +1,33 @@
+# What this sample demonstrates
+
+An [Agent Framework](https://github.com/microsoft/agent-framework) agent that connects to a **remote MCP server** (GitHub) for tool discovery and hosted using the **Responses protocol**. Instead of defining tools locally, the agent discovers and invokes tools at runtime from an MCP-compatible endpoint — in this case, the GitHub Copilot MCP server. This enables dynamic tool integration without redeployment.
+
+## How It Works
+
+### Model Integration
+
+The agent uses `FoundryChatClient` from the Agent Framework to create an OpenAI-compatible Responses client. It registers a remote MCP tool pointing at `https://api.githubcopilot.com/mcp/`, authenticating with a GitHub Personal Access Token (PAT). When the model decides to call a tool, the framework forwards the call to the MCP server and returns the result to the model for the final reply.
+
+See [main.py](main.py) for the full implementation.
+
+### Agent Hosting
+
+The agent is hosted using the [Agent Framework](https://github.com/microsoft/agent-framework) with the `ResponsesHostServer`, which provisions a REST API endpoint compatible with the OpenAI Responses protocol.
+
+## Running the Agent Host
+
+Follow the instructions in the [Running the Agent Host Locally](../../README.md#running-the-agent-host-locally) section of the README in the parent directory to run the agent host.
+
+## Interacting with the agent
+
+> Depending on how you run the agent host, you can invoke the agent using `curl` (`Invoke-WebRequest` in PowerShell) or `azd`. Please refer to the [parent README](../../README.md) for more details. Use this README for sample queries you can send to the agent.
+
+Send a POST request to the server with a JSON body containing an `"input"` field to interact with the agent. For example:
+
+```bash
+curl -X POST http://localhost:8088/responses -H "Content-Type: application/json" -d '{"input": "List all the repositories I own on GitHub."}'
+```
+
+## Deploying the Agent to Foundry
+
+To host the agent on Foundry, follow the instructions in the [Deploying the Agent to Foundry](../../README.md#deploying-the-agent-to-foundry) section of the README in the parent directory.
@@ -1,4 +1,4 @@
-name: agent-framework-agent-with-remote-mcp-tools
+name: agent-framework-agent-with-remote-mcp-tools-responses
 description: >
  An Agent Framework agent with remote MCP tools hosted by Foundry.
 metadata:
@@ -9,19 +9,17 @@ metadata:
    - Responses Protocol
    - Streaming
 template:
-  name: agent-framework-agent-with-remote-mcp-tools
+  name: agent-framework-agent-with-remote-mcp-tools-responses
  kind: hosted
  protocols:
    - protocol: responses
      version: 1.0.0
  environment_variables:
-    - name: MODEL_DEPLOYMENT_NAME
-      value: "{{MODEL_DEPLOYMENT_NAME}}"
+    - name: AZURE_AI_MODEL_DEPLOYMENT_NAME
+      value: "{{AZURE_AI_MODEL_DEPLOYMENT_NAME}}"
    - name: GITHUB_PAT
      value: ${GITHUB_PAT}
-    - name: TOOLBOX_NAME
-      value: ${TOOLBOX_NAME}
 resources:
  - kind: model
    id: gpt-4.1-mini
-    name: MODEL_DEPLOYMENT_NAME
+    name: AZURE_AI_MODEL_DEPLOYMENT_NAME
@@ -0,0 +1,11 @@
+kind: hosted
+name: agent-framework-agent-with-remote-mcp-tools-responses
+protocols:
+  - protocol: responses
+    version: 1.0.0
+resources:
+  cpu: "0.25"
+  memory: 0.5Gi
+environment_variables:
+  - name: GITHUB_PAT
+    value: ${GITHUB_PAT}
@@ -0,0 +1,56 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+import os
+
+from agent_framework import Agent, ToolTypes
+from agent_framework.foundry import FoundryChatClient
+from agent_framework_foundry_hosting import ResponsesHostServer
+from azure.identity import DefaultAzureCredential
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+logger = logging.getLogger(__name__)
+
+
+def main():
+    client = FoundryChatClient(
+        project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
+        model=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
+        credential=DefaultAzureCredential(),
+    )
+
+    github_pat = os.environ["GITHUB_PAT"]
+    tools: list[ToolTypes] = []
+    if not github_pat:
+        logger.warning("GITHUB_PAT environment variable is not set. The GitHub MCP tool will not get registered.")
+    else:
+        tools.append(
+            client.get_mcp_tool(
+                name="GitHub",
+                url="https://api.githubcopilot.com/mcp/",
+                headers={
+                    "Authorization": f"Bearer {github_pat}",
+                },
+                approval_mode="never_require",
+            )
+        )
+
+    agent = Agent(
+        client=client,
+        instructions="You are a friendly assistant. Keep your answers brief.",
+        tools=tools,
+        # History will be managed by the hosting infrastructure, thus there
+        # is no need to store history by the service. Learn more at:
+        # https://developers.openai.com/api/reference/resources/responses/methods/create
+        default_options={"store": False},
+    )
+
+    server = ResponsesHostServer(agent)
+    server.run()
+
+
+if __name__ == "__main__":
+    main()
@@ -1,25 +0,0 @@
-# Basic example of hosting an agent with the `responses` API and a remote MCP
-
-This agent is equipped with a GitHub MCP server and a Foundry Toolbox, which are both remote MCPs.
-
-> Note that there are other ways to interact with Foundry toolboxes. Using it as a MCP is just one of the options.
-
-## Running the server locally
-
-### Environment setup
-
-Follow the instructions in the [Environment setup](../../README.md#environment-setup) section of the README in the parent directory to set up your environment and install dependencies.
-
-Run the following command to start the server:
-
-```bash
-python main.py
-```
-
-## Interacting with the agent
-
-Send a POST request to the server with a JSON body containing a "input" field to interact with the agent. For example:
-
-```bash
-curl -X POST http://localhost:8088/responses -H "Content-Type: application/json" -d '{"input": "List all the repositories I own on GitHub."}'
-```
@@ -1,76 +0,0 @@
-# Copyright (c) Microsoft. All rights reserved.
-
-import os
-
-import httpx
-from agent_framework import Agent, MCPStreamableHTTPTool
-from agent_framework.foundry import FoundryChatClient
-from agent_framework_foundry_hosting import ResponsesHostServer
-from azure.identity import AzureCliCredential
-from dotenv import load_dotenv
-
-# Load environment variables from .env file
-load_dotenv()
-
-
-class ToolboxAuth(httpx.Auth):
-    """httpx Auth that injects a fresh bearer token on every request."""
-
-    def auth_flow(self, request: httpx.Request):
-        credential = AzureCliCredential()
-        token = credential.get_token("https://ai.azure.com/.default").token
-        request.headers["Authorization"] = f"Bearer {token}"
-        yield request
-
-
-def main():
-    client = FoundryChatClient(
-        project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
-        model=os.environ["MODEL_DEPLOYMENT_NAME"],
-        credential=AzureCliCredential(),
-    )
-
-    # Foundry Toolbox as a MCP tool
-    project_endpoint = os.environ["FOUNDRY_PROJECT_ENDPOINT"]
-    toolbox_name = os.environ["TOOLBOX_NAME"]
-    toolbox_endpoint = f"{project_endpoint.rstrip('/')}/toolboxes/{toolbox_name}/mcp?api-version=v1"
-    http_client = httpx.AsyncClient(auth=ToolboxAuth(), headers={"Foundry-Features": "Toolboxes=V1Preview"})
-    foundry_mcp_tool = MCPStreamableHTTPTool(
-        name="toolbox",
-        url=toolbox_endpoint,
-        http_client=http_client,
-        load_prompts=False,
-    )
-
-    # GitHub MCP server
-    github_pat = os.environ["GITHUB_PAT"]
-    if not github_pat:
-        raise ValueError(
-            "GITHUB_PAT environment variable must be set. Create a token at https://github.com/settings/tokens"
-        )
-
-    github_mcp_tool = client.get_mcp_tool(
-        name="GitHub",
-        url="https://api.githubcopilot.com/mcp/",
-        headers={
-            "Authorization": f"Bearer {github_pat}",
-        },
-        approval_mode="never_require",
-    )
-
-    agent = Agent(
-        client=client,
-        instructions="You are a friendly assistant. Keep your answers brief.",
-        tools=[foundry_mcp_tool, github_mcp_tool],
-        # History will be managed by the hosting infrastructure, thus there
-        # is no need to store history by the service. Learn more at:
-        # https://developers.openai.com/api/reference/resources/responses/methods/create
-        default_options={"store": False},
-    )
-
-    server = ResponsesHostServer(agent)
-    server.run()
-
-
-if __name__ == "__main__":
-    main()
@@ -0,0 +1,3 @@
+FOUNDRY_PROJECT_ENDPOINT="..."
+AZURE_AI_MODEL_DEPLOYMENT_NAME="..."
+TOOLBOX_NAME="..."
@@ -0,0 +1,43 @@
+# What this sample demonstrates
+
+An [Agent Framework](https://github.com/microsoft/agent-framework) agent that uses **Foundry Toolbox** for tool discovery and hosted using the **Responses protocol**. Foundry Toolbox is a managed tool registry in Microsoft Foundry that lets you define tools centrally and share them across agents.
+
+## Creating a Foundry Toolbox
+
+You can create a Foundry Toolbox by code. Refer to this sample for an example: [Foundry Toolbox CRUD Sample](https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/ai/azure-ai-projects/samples/hosted_agents/sample_toolboxes_crud.py).
+
+You can also create a Foundry Toolbox in the Foundry portal. Read more about it [in the Foundry toolbox documentation](https://learn.microsoft.com/en-us/azure/foundry/agents/how-to/tools/toolbox).
+
+> If you set up a project with this sample and provision the resources using `azd provision`, a Foundry Toolbox will be created with the specified tools in [`agent.manifest.yaml`](agent.manifest.yaml).
+
+## How It Works
+
+### Model Integration
+
+The agent uses `FoundryChatClient` from the Agent Framework to create an OpenAI-compatible Responses client. It loads a named Foundry Toolbox via `client.get_toolbox(name)` — the toolbox is a server-side bundle of tool configurations (e.g., `code_interpreter`, `web_search`) defined in the Foundry portal or by `azd provision`. Omitting `version` resolves the toolbox's current default version at runtime.
+
+The sample then narrows the toolbox to a subset of tool types via `select_toolbox_tools(toolbox, include_types=[...])` before handing it to the agent. This demonstrates how one toolbox can be reused across agents that each expose only the tools they need — here, the agent only sees `code_interpreter` even though the toolbox also includes `web_search`.
+
+See [main.py](main.py) for the full implementation.
+
+### Agent Hosting
+
+The agent is hosted using the [Agent Framework](https://github.com/microsoft/agent-framework) with the `ResponsesHostServer`, which provisions a REST API endpoint compatible with the OpenAI Responses protocol.
+
+## Running the Agent Host
+
+Follow the instructions in the [Running the Agent Host Locally](../../README.md#running-the-agent-host-locally) section of the README in the parent directory to run the agent host.
+
+## Interacting with the agent
+
+> Depending on how you run the agent host, you can invoke the agent using `curl` (`Invoke-WebRequest` in PowerShell) or `azd`. Please refer to the [parent README](../../README.md) for more details. Use this README for sample queries you can send to the agent.
+
+Send a POST request to the server with a JSON body containing an `"input"` field to interact with the agent. For example:
+
+```bash
+curl -X POST http://localhost:8088/responses -H "Content-Type: application/json" -d '{"input": "What tools do you have?"}'
+```
+
+## Deploying the Agent to Foundry
+
+To host the agent on Foundry, follow the instructions in the [Deploying the Agent to Foundry](../../README.md#deploying-the-agent-to-foundry) section of the README in the parent directory.
@@ -0,0 +1,33 @@
+name: agent-framework-agent-with-foundry-toolbox-responses
+description: >
+  An Agent Framework agent with Foundry Toolbox integration.
+metadata:
+  tags:
+    - Agent Framework
+    - AI Agent Hosting
+    - Azure AI AgentServer
+    - Responses Protocol
+    - Streaming
+template:
+  name: agent-framework-agent-with-foundry-toolbox-responses
+  kind: hosted
+  protocols:
+    - protocol: responses
+      version: 1.0.0
+  environment_variables:
+    - name: AZURE_AI_MODEL_DEPLOYMENT_NAME
+      value: "{{AZURE_AI_MODEL_DEPLOYMENT_NAME}}"
+    - name: TOOLBOX_NAME
+      value: "agent-tools"
+resources:
+  - kind: model
+    id: gpt-4.1-mini
+    name: AZURE_AI_MODEL_DEPLOYMENT_NAME
+  - kind: toolbox
+    name: agent-tools
+    tools:
+      - type: web_search
+        name: web_search
+      - type: code_interpreter
+        name: code_interpreter
+
@@ -1,5 +1,5 @@
 kind: hosted
-name: agent-framework-agent-with-remote-mcp-tools
+name: agent-framework-agent-with-foundry-toolbox-responses
 protocols:
  - protocol: responses
    version: 1.0.0
@@ -0,0 +1,42 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import asyncio
+import os
+
+from agent_framework import Agent
+from agent_framework.foundry import FoundryChatClient
+from agent_framework_foundry_hosting import ResponsesHostServer
+from azure.identity import DefaultAzureCredential
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+
+async def main():
+    client = FoundryChatClient(
+        project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
+        model=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
+        credential=DefaultAzureCredential(),
+    )
+
+    # Load the named toolbox from the Foundry project. Omitting `version`
+    # resolves the toolbox's current default version at runtime.
+    toolbox = await client.get_toolbox(os.environ["TOOLBOX_NAME"])
+
+    agent = Agent(
+        client=client,
+        instructions="You are a friendly assistant. Keep your answers brief.",
+        tools=toolbox,
+        # History will be managed by the hosting infrastructure, thus there
+        # is no need to store history by the service. Learn more at:
+        # https://developers.openai.com/api/reference/resources/responses/methods/create
+        default_options={"store": False},
+    )
+
+    server = ResponsesHostServer(agent)
+    await server.run_async()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
@@ -0,0 +1,2 @@
+agent-framework
+agent-framework-foundry-hosting
@@ -1,2 +0,0 @@
-FOUNDRY_PROJECT_ENDPOINT="..."
-MODEL_DEPLOYMENT_NAME="..."
@@ -1,23 +0,0 @@
-# Basic example of hosting an agent with the `responses` API and a workflow
-
-This sample demonstrates how to host a workflow using the `responses` API.
-
-## Running the server locally
-
-### Environment setup
-
-Follow the instructions in the [Environment setup](../../README.md#environment-setup) section of the README in the parent directory to set up your environment and install dependencies.
-
-Run the following command to start the server:
-
-```bash
-python main.py
-```
-
-## Interacting with the agent
-
-Send a POST request to the server with a JSON body containing a "input" field to interact with the agent. For example:
-
-```bash
-curl -X POST http://localhost:8088/responses -H "Content-Type: application/json" -d '{"input": "Create a slogan for a new electric SUV that is affordable and fun to drive."}'
-```
@@ -0,0 +1,6 @@
+.venv
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
@@ -0,0 +1,2 @@
+FOUNDRY_PROJECT_ENDPOINT="..."
+AZURE_AI_MODEL_DEPLOYMENT_NAME="..."
@@ -0,0 +1,16 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY . user_agent/
+WORKDIR /app/user_agent
+
+RUN if [ -f requirements.txt ]; then \
+        pip install -r requirements.txt; \
+    else \
+        echo "No requirements.txt found"; \
+    fi
+
+EXPOSE 8088
+
+CMD ["python", "main.py"]
@@ -0,0 +1,43 @@
+# What this sample demonstrates
+
+An [Agent Framework](https://github.com/microsoft/agent-framework) workflow demonstrating **multi-agent chaining** and hosted using the **Responses protocol**. It shows how to use the Agent Framework's `WorkflowBuilder` to compose a pipeline of specialized agents — a slogan writer, a legal reviewer, and a formatter — that process a request sequentially. Each agent receives only the output of the previous agent, and only the final formatted result is returned to the caller.
+
+> The workflow will be used as an agent. Read more about Agent Framework workflows in the [Agent Framework documentation](https://learn.microsoft.com/en-us/agent-framework/workflows/) and workflow as an agent in the [Workflow as an Agent documentation](https://learn.microsoft.com/en-us/agent-framework/workflows/as-agents?pivots=programming-language-python).
+
+> This sample requires a more advanced model because the model needs to continue the conversation from an assistant message. Not all models perform well in this scenario. Tested with OpenAI's model `gpt-5.4`.
+
+## How It Works
+
+### Model Integration
+
+The agent creates three specialized `Agent` instances sharing the same `FoundryChatClient`: a **writer** that generates slogans, a **legal reviewer** that ensures compliance, and a **formatter** that styles the output. Each agent is wrapped in an `AgentExecutor` with `context_mode="last_agent"` so it only sees the previous agent's output. The `WorkflowBuilder` wires them into a linear pipeline and limits the output to the formatter's result.
+
+See [main.py](main.py) for the full implementation.
+
+### Agent Hosting
+
+The workflow is exposed as a single agent via `.as_agent()` and hosted using the [Agent Framework](https://github.com/microsoft/agent-framework) with the `ResponsesHostServer`, which provisions a REST API endpoint compatible with the OpenAI Responses protocol.
+
+## Running the Agent Host
+
+Follow the instructions in the [Running the Agent Host Locally](../../README.md#running-the-agent-host-locally) section of the README in the parent directory to run the agent host.
+
+## Interacting with the agent
+
+> Depending on how you run the agent host, you can invoke the agent using `curl` (`Invoke-WebRequest` in PowerShell) or `azd`. Please refer to the [parent README](../../README.md) for more details. Use this README for sample queries you can send to the agent.
+
+Send a POST request to the server with a JSON body containing an `"input"` field to interact with the agent. For example:
+
+```bash
+curl -X POST http://localhost:8088/responses -H "Content-Type: application/json" -d '{"input": "Create a slogan for a new electric SUV that is affordable and fun to drive."}'
+```
+
+Invoke with `azd`:
+
+```bash
+azd ai agent invoke --local "Create a slogan for a new electric SUV that is affordable and fun to drive."
+```
+
+## Deploying the Agent to Foundry
+
+To host the agent on Foundry, follow the instructions in the [Deploying the Agent to Foundry](../../README.md#deploying-the-agent-to-foundry) section of the README in the parent directory.
@@ -1,4 +1,4 @@
-name: agent-framework-workflows
+name: agent-framework-workflows-responses
 description: >
  An Agent Framework workflow hosted by Foundry.
 metadata:
@@ -9,15 +9,15 @@ metadata:
    - Responses Protocol
    - Streaming
 template:
-  name: agent-framework-workflows
+  name: agent-framework-workflows-responses
  kind: hosted
  protocols:
    - protocol: responses
      version: 1.0.0
  environment_variables:
-    - name: MODEL_DEPLOYMENT_NAME
-      value: "{{MODEL_DEPLOYMENT_NAME}}"
+    - name: AZURE_AI_MODEL_DEPLOYMENT_NAME
+      value: "{{AZURE_AI_MODEL_DEPLOYMENT_NAME}}"
 resources:
  - kind: model
-    id: gpt-4.1-mini
-    name: MODEL_DEPLOYMENT_NAME
+    id: gpt-5.4
+    name: AZURE_AI_MODEL_DEPLOYMENT_NAME
@@ -1,5 +1,5 @@
 kind: hosted
-name: agent-framework-workflows
+name: agent-framework-workflows-responses
 protocols:
  - protocol: responses
    version: 1.0.0
@@ -5,7 +5,7 @@ import os
 from agent_framework import Agent, AgentExecutor, WorkflowBuilder
 from agent_framework.foundry import FoundryChatClient
 from agent_framework_foundry_hosting import ResponsesHostServer
-from azure.identity import AzureCliCredential
+from azure.identity import DefaultAzureCredential
 from dotenv import load_dotenv

 # Load environment variables from .env file
@@ -15,8 +15,8 @@ load_dotenv()
 def main():
    client = FoundryChatClient(
        project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
-        model=os.environ["MODEL_DEPLOYMENT_NAME"],
-        credential=AzureCliCredential(),
+        model=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
+        credential=DefaultAzureCredential(),
    )

    writer_agent = Agent(
@@ -1,11 +0,0 @@
-# Hosting agents with Foundry Hosting and the `responses` API
-
-This folder contains a list of samples that show how to host agents using the `responses` API and deploy them to Foundry Hosting.
-
-| Sample | Description |
-| --- | --- |
-| [01_basic](./01_basic) | A basic example of hosting an agent with the `responses` API and carrying on a multi-turn conversation. |
-| [02_local_tools](./02_local_tools) | An example of hosting an agent with the `responses` API and local tools including a function tool and a local shell tool. |
-| [03_remote_mcp](./03_remote_mcp) | An example of hosting an agent with the `responses` API and remote MCPs, including a GitHub MCP server and a Foundry Toolbox. |
-| [04_workflows](./04_workflows) | An example of hosting a workflow with the `responses` API. |
-| [using_deployed_agent.py](./using_deployed_agent.py) | An example of how to use the deployed agent in Agent Framework. |
@@ -1,50 +1,146 @@
 # Copyright (c) Microsoft. All rights reserved.

+from __future__ import annotations
+
 import asyncio
+import os
+from collections.abc import Mapping
+from typing import Any, cast

-from agent_framework import Agent, AgentResponse, AgentResponseUpdate, ResponseStream
-from agent_framework.openai import OpenAIChatClient
-from typing_extensions import Any
+from agent_framework import AgentSession
+from agent_framework.foundry import FoundryAgent
+from azure.ai.projects.aio import AIProjectClient
+from azure.ai.projects.models import VersionRefIndicator
+from azure.identity import AzureCliCredential
+from dotenv import load_dotenv
+
+load_dotenv()

 """
-This script demonstrates how to talk to a deployed agent using the OpenAIChatClient.
+This sample demonstrates how to connect to the deployed basic Foundry agent with
+`FoundryAgent`.
+
+The sample uses environment variables for configuration, which can be set in a .env file or in the environment directly:
+Environment variables:
+    FOUNDRY_PROJECT_ENDPOINT: Azure AI Foundry project endpoint.
+    FOUNDRY_AGENT_NAME: Hosted agent name.
+    FOUNDRY_AGENT_VERSION: Hosted agent version. Optional, defaults to latest if not specified.
+
+After you deploy one of the agents in this directory, you can run this sample
+to connect to it and have a conversation.
+
+Note: The `allow_preview=True` flag is required to connect to the new hosted
+agents, as this is a preview feature in Foundry.

-Depending on where you have deployed your agent (local or Foundry Hosting), you may
-need to change the base_url when initializing the OpenAIChatClient.
 """


-async def print_streaming_response(streaming_response: ResponseStream[AgentResponseUpdate, AgentResponse[Any]]) -> None:
-    async for chunk in streaming_response:
-        if chunk.text:
-            print(chunk.text, end="", flush=True)
+async def create_hosted_agent_session(
+    *,
+    agent: FoundryAgent,
+    project_client: AIProjectClient,
+    agent_name: str,
+    agent_version: str | None,
+    isolation_key: str,
+) -> AgentSession:
+    """Create a hosted-agent service session and wrap it in an AgentSession."""
+    create_session_kwargs: dict[str, Any] = {
+        "agent_name": agent_name,
+        "isolation_key": isolation_key,
+    }
+    resolved_agent_version = agent_version
+    if resolved_agent_version is None:
+        agent_details = await cast(Any, project_client.beta.agents).get(  # pyright: ignore[reportAttributeAccessIssue, reportUnknownMemberType]
+            agent_name=agent_name
+        )
+        versions = getattr(agent_details, "versions", None)
+        if not isinstance(versions, Mapping):
+            raise ValueError("Hosted agent details did not include a versions mapping.")
+        latest_version = getattr(cast(Any, versions.get("latest")), "version", None)
+        if not isinstance(latest_version, str) or not latest_version:
+            raise ValueError("Hosted agent details did not include a latest version string.")
+        resolved_agent_version = latest_version
+
+    create_session_kwargs["version_indicator"] = VersionRefIndicator(agent_version=resolved_agent_version)
+    service_session = await project_client.beta.agents.create_session(**create_session_kwargs)
+    agent_session_id = getattr(service_session, "agent_session_id", None)
+    if not isinstance(agent_session_id, str) or not agent_session_id:
+        raise ValueError("Hosted agent session creation did not return a non-empty agent_session_id.")
+
+    return agent.get_session(agent_session_id)


 async def main() -> None:
-    agent = Agent(client=OpenAIChatClient(base_url="http://localhost:8088"))
-    session = agent.create_session()
+    credential = AzureCliCredential()
+    project_endpoint = os.environ["FOUNDRY_PROJECT_ENDPOINT"]
+    agent_name = os.environ["FOUNDRY_AGENT_NAME"]
+    agent_version = os.getenv("FOUNDRY_AGENT_VERSION")
+    isolation_key = "my-isolation-key"

-    # First turn
-    query = "Hi!"
-    print(f"User: {query}")
-    print("Agent: ", end="", flush=True)
-    streaming_response = agent.run(query, session=session, stream=True)
-    await print_streaming_response(streaming_response)
+    project_client = AIProjectClient(
+        endpoint=project_endpoint,
+        credential=credential,
+        allow_preview=True,
+    )
+    async with (
+        project_client,
+        FoundryAgent(
+            project_client=project_client,
+            agent_name=agent_name,
+            agent_version=agent_version,
+            allow_preview=True,
+        ) as agent,
+    ):
+        session = await create_hosted_agent_session(
+            agent=agent,
+            project_client=project_client,
+            agent_name=agent_name,
+            agent_version=agent_version,
+            isolation_key=isolation_key,
+        )

-    # Second turn
-    query = "Your name is Javis. What can you do?"
-    print(f"\nUser: {query}")
-    print("Agent: ", end="", flush=True)
-    streaming_response = agent.run(query, session=session, stream=True)
-    await print_streaming_response(streaming_response)
+        try:
+            # 1. Send the first turn.
+            query = "Hi!"
+            print(f"User: {query}")
+            print("Agent: ", end="", flush=True)
+            async for chunk in agent.run(query, session=session, stream=True):
+                if chunk.text:
+                    print(chunk.text, end="", flush=True)

-    # Third turn
-    query = "What is your name?"
-    print(f"\nUser: {query}")
-    print("Agent: ", end="", flush=True)
-    streaming_response = agent.run(query, session=session, stream=True)
-    await print_streaming_response(streaming_response)
+            # 2. Continue the conversation with the same deployed agent session.
+            query = "Your name is Javis. What can you do?"
+            print(f"\nUser: {query}")
+            print("Agent: ", end="", flush=True)
+            async for chunk in agent.run(query, session=session, stream=True):
+                if chunk.text:
+                    print(chunk.text, end="", flush=True)
+
+            # 3. Ask a follow-up question in the same session.
+            query = "What is your name?"
+            print(f"\nUser: {query}")
+            print("Agent: ", end="", flush=True)
+            async for chunk in agent.run(query, session=session, stream=True):
+                if chunk.text:
+                    print(chunk.text, end="", flush=True)
+        finally:
+            if session.service_session_id is not None:
+                await project_client.beta.agents.delete_session(
+                    agent_name=agent_name,
+                    session_id=session.service_session_id,
+                    isolation_key=isolation_key,
+                )


 if __name__ == "__main__":
    asyncio.run(main())
+
+"""
+Sample output:
+User: Hi!
+Agent: Hello! How can I help you today?
+User: Your name is Javis. What can you do?
+Agent: I can answer questions and help with tasks using the instructions configured on the deployed agent.
+User: What is your name?
+Agent: My name is Javis.
+"""