chore: import upstream snapshot with attribution

python/samples/04-hosting/container/hyperlight_codeact/.dockerignore

@@ -0,0 +1,6 @@
+.venv
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python

python/samples/04-hosting/container/hyperlight_codeact/.env.example

@@ -0,0 +1,2 @@
+FOUNDRY_PROJECT_ENDPOINT="..."
+AZURE_AI_MODEL_DEPLOYMENT_NAME="..."

python/samples/04-hosting/container/hyperlight_codeact/Dockerfile

@@ -0,0 +1,36 @@
+# Build this image with the repository's `python/` directory as the build context so
+# the in-tree agent-framework packages can be installed from source. From the repo root:
+#
+#   docker build \
+#     -f python/samples/04-hosting/foundry-hosted-agents/responses/08_hyperlight_codeact/Dockerfile \
+#     -t <acr>.azurecr.io/<image>:<tag> \
+#     python/
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Copy the in-tree agent-framework packages we need. Order matters for editable
+# installs because of inter-package dependencies; we install in dependency order
+# below. Hyperlight backends are platform gated, so we install them via pip
+# resolution rather than copying the wheels.
+COPY packages/core /opt/af/core
+COPY packages/openai /opt/af/openai
+COPY packages/foundry /opt/af/foundry
+COPY packages/foundry_hosting /opt/af/foundry_hosting
+COPY packages/hyperlight /opt/af/hyperlight
+
+# Copy just the sample we care about into the user agent location.
+COPY samples/04-hosting/foundry-hosted-agents/responses/08_hyperlight_codeact/ /app/user_agent/
+WORKDIR /app/user_agent
+
+RUN pip install --no-cache-dir --upgrade pip \
+    && pip install --no-cache-dir /opt/af/core \
+    && pip install --no-cache-dir /opt/af/openai \
+    && pip install --no-cache-dir /opt/af/foundry \
+    && pip install --no-cache-dir /opt/af/foundry_hosting \
+    && pip install --no-cache-dir /opt/af/hyperlight \
+    && if grep -Eq '^[[:space:]]*[^#[:space:]]' requirements.txt; then pip install --no-cache-dir -r requirements.txt; fi
+
+EXPOSE 8088
+
+CMD ["python", "main.py"]

python/samples/04-hosting/container/hyperlight_codeact/README.md

@@ -0,0 +1,85 @@
+# What this sample demonstrates
+
+An [Agent Framework](https://github.com/microsoft/agent-framework) agent that
+runs Python in a [Hyperlight](https://github.com/hyperlight-dev/hyperlight)
+WebAssembly sandbox via the **CodeAct** pattern, hosted using the **Responses
+protocol**. The model is only given a single `execute_code` tool. Local Python
+tools (`compute`, `fetch_data`) are registered on `HyperlightCodeActProvider`
+and are reachable from inside the sandbox via `call_tool(...)`, never as
+direct LLM tools. All of this can be run as a container, however not under all circumstances.
+
+> **⚠️ Foundry hosted-agent runtime support is in progress.**
+> Hyperlight requires a hypervisor (`/dev/kvm` on Linux, MSHV on Windows). The
+> default Foundry hosted-agent runtime does not currently expose a hypervisor
+> to the workload container, so deploying this sample as a Foundry hosted
+> agent will fail at runtime with
+> `Failed to create sandbox: ... No Hypervisor was found for Sandbox`.
+> The sample container itself works end-to-end when run locally with
+> `docker run --device=/dev/kvm ...` (see [Hypervisor requirement](#hypervisor-requirement)
+> below). We are working with the platform team to enable a hypervisor-capable
+> hosting target.
+
+## How It Works
+
+### Model integration
+
+The agent uses `FoundryChatClient` to talk to a Foundry-hosted model deployment.
+A `HyperlightCodeActProvider` is attached as a context provider, which on every
+run injects the `execute_code` tool plus the CodeAct instructions that teach the
+model how to author Python that calls `call_tool(...)` for sandbox-only tools.
+
+See [`main.py`](main.py) for the full implementation.
+
+### Agent hosting
+
+The agent is hosted with `ResponsesHostServer` from
+`agent-framework-foundry-hosting`, which exposes a REST endpoint compatible with
+the OpenAI Responses protocol.
+
+> The Hyperlight Wasm backend is currently published only for `linux/x86_64` and
+> `win32/AMD64` with Python `<3.14`. The hosted container runs `python:3.12-slim`
+> on linux/x86_64, which is supported.
+
+### Hypervisor requirement
+
+Hyperlight executes guest WebAssembly inside a micro-VM and **requires a
+hypervisor on the host**:
+
+- **Linux:** `/dev/kvm` must be present *and* the container must have access to
+  it (`docker run --device=/dev/kvm ...`).
+- **Windows:** the Microsoft Hypervisor Platform (MSHV) must be enabled.
+
+Without a hypervisor, sandbox creation fails with:
+
+```
+Failed to create sandbox: failed to build ProtoWasmSandbox: No Hypervisor was found for Sandbox
+```
+
+This affects hosted environments that don't expose `/dev/kvm` to the workload
+container (most managed PaaS, including the default Foundry hosted-agent
+runtime). To run this sample as a hosted agent you need a hosting target with
+nested virtualization and `/dev/kvm` device passthrough — for example an Azure
+VM, AKS nodes with KVM enabled, or Azure Container Instances configured for
+nested virt.
+
+## Running the Agent Host
+
+Follow the instructions in the
+[Running the Agent Host Locally](../../foundry-hosted-agents//README.md#running-the-agent-host-locally)
+section of the README in the Foundry Hosted Agent directory.
+
+## Interacting with the agent
+
+Send a POST request to the server with a JSON body containing an `"input"`
+field. The model should respond by calling `execute_code` with Python that uses
+`call_tool(...)` to reach the sandbox-only tools:
+
+```bash
+curl -X POST http://localhost:8088/responses \
+  -H "Content-Type: application/json" \
+  -d '{"input": "Fetch all users, find the admins, multiply 7 by 6, and print the users, admins and multiplication result. Use execute_code with call_tool(...)."}'
+```
+
+## Deploying the Agent to Foundry
+
+Deploying this container to Foundry will not work yet, as soon as it does, we will update this sample.

python/samples/04-hosting/container/hyperlight_codeact/agent.manifest.yaml

@@ -0,0 +1,24 @@
+name: agent-framework-agent-with-hyperlight-codeact-responses
+description: >
+  An Agent Framework agent with a Hyperlight CodeAct sandbox hosted by Foundry.
+metadata:
+  tags:
+    - Agent Framework
+    - AI Agent Hosting
+    - Azure AI AgentServer
+    - Responses Protocol
+    - Streaming
+    - Hyperlight CodeAct
+template:
+  name: agent-framework-agent-with-hyperlight-codeact-responses
+  kind: hosted
+  protocols:
+    - protocol: responses
+      version: 1.0.0
+  environment_variables:
+    - name: AZURE_AI_MODEL_DEPLOYMENT_NAME
+      value: "{{AZURE_AI_MODEL_DEPLOYMENT_NAME}}"
+resources:
+  - kind: model
+    id: gpt-4.1-mini
+    name: AZURE_AI_MODEL_DEPLOYMENT_NAME

python/samples/04-hosting/container/hyperlight_codeact/agent.yaml

@@ -0,0 +1,23 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/microsoft/AgentSchema/refs/heads/main/schemas/v1.0/ContainerAgent.yaml
+
+kind: hosted
+name: agent-framework-agent-with-hyperlight-codeact-responses
+description: |
+    An Agent Framework agent with a Hyperlight CodeAct sandbox hosted by Foundry.
+metadata:
+    tags:
+        - Agent Framework
+        - AI Agent Hosting
+        - Azure AI AgentServer
+        - Responses Protocol
+        - Streaming
+        - Hyperlight CodeAct
+protocols:
+    - protocol: responses
+      version: 1.0.0
+resources:
+    cpu: "1"
+    memory: 2Gi
+environment_variables:
+    - name: AZURE_AI_MODEL_DEPLOYMENT_NAME
+      value: gpt-4.1-mini

python/samples/04-hosting/container/hyperlight_codeact/call_server.py

@@ -0,0 +1,40 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "openai>=1.50,<3",
+#     "azure-identity>=1.19,<2",
+# ]
+# ///
+# Run with: uv run call_server.py
+
+# Copyright (c) Microsoft. All rights reserved.
+
+"""Call the deployed Hyperlight CodeAct Foundry hosted agent via the OpenAI client."""
+
+import os
+
+from azure.identity import AzureCliCredential
+from openai import OpenAI
+
+# Set FOUNDRY_AGENT_ENDPOINT to your deployed agent endpoint, e.g.
+#   https://<your-foundry-resource>.services.ai.azure.com/api/projects/<project>/agents/<agent-name>
+ENDPOINT = os.environ.get(
+    "FOUNDRY_AGENT_ENDPOINT",
+    "https://<your-foundry-resource>.services.ai.azure.com/api/projects/<project>/agents/<agent-name>",
+)
+SCOPE = "https://ai.azure.com/.default"
+PROMPT = (
+    "Fetch all users, find the admins, multiply 7 by 6, and print the users, "
+    "admins and multiplication result. Use execute_code with call_tool(...)."
+)
+
+
+def main() -> None:
+    token = AzureCliCredential().get_token(SCOPE).token
+    client = OpenAI(base_url=ENDPOINT, api_key=token, default_query={"api-version": "v1"})
+    response = client.responses.create(model="hosted-agent", input=PROMPT)
+    print(response.output_text)
+
+
+if __name__ == "__main__":
+    main()

python/samples/04-hosting/container/hyperlight_codeact/main.py

@@ -0,0 +1,89 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import asyncio
+import os
+from typing import Annotated, Any, Literal
+
+from agent_framework import Agent, tool
+from agent_framework.foundry import FoundryChatClient
+from agent_framework.hyperlight import HyperlightCodeActProvider
+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()
+
+
+@tool(approval_mode="never_require")
+def compute(
+    operation: Annotated[
+        Literal["add", "subtract", "multiply", "divide"],
+        "Math operation: add, subtract, multiply, or divide.",
+    ],
+    a: Annotated[float, "First numeric operand."],
+    b: Annotated[float, "Second numeric operand."],
+) -> float:
+    """Perform a math operation for sandboxed code."""
+    operations = {
+        "add": a + b,
+        "subtract": a - b,
+        "multiply": a * b,
+        "divide": a / b if b else float("inf"),
+    }
+    return operations[operation]
+
+
+@tool(approval_mode="never_require")
+async def fetch_data(
+    table: Annotated[str, "Name of the simulated table to query."],
+) -> list[dict[str, Any]]:
+    """Fetch records from a named table."""
+    await asyncio.sleep(0.5)
+    data: dict[str, list[dict[str, Any]]] = {
+        "users": [
+            {"id": 1, "name": "Alice", "role": "admin"},
+            {"id": 2, "name": "Bob", "role": "user"},
+            {"id": 3, "name": "Charlie", "role": "admin"},
+        ],
+        "products": [
+            {"id": 101, "name": "Widget", "price": 9.99},
+            {"id": 102, "name": "Gadget", "price": 19.99},
+        ],
+    }
+    return data.get(table, [])
+
+
+def main():
+    # 1. Create the Foundry chat client.
+    client = FoundryChatClient(
+        project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
+        model=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
+        credential=DefaultAzureCredential(),
+        function_invocation_configuration={"include_detailed_errors": True},
+    )
+
+    # 2. Register sandbox tools on a Hyperlight CodeAct provider. The model only
+    #    sees `execute_code`; `compute` and `fetch_data` are reachable from
+    #    inside the sandbox via `call_tool(...)`.
+    codeact = HyperlightCodeActProvider(
+        tools=[compute, fetch_data],
+        approval_mode="never_require",
+    )
+
+    # 3. Build the agent. History is managed by the hosting infrastructure, so
+    #    request the model not to persist server-side conversation state.
+    agent = Agent(
+        client=client,
+        instructions="You are a helpful assistant. Keep your answers brief.",
+        context_providers=[codeact],
+        default_options={"store": False},
+    )
+
+    # 4. Serve the agent over the Foundry Responses protocol.
+    server = ResponsesHostServer(agent)
+    server.run()
+
+
+if __name__ == "__main__":
+    main()

python/samples/04-hosting/container/hyperlight_codeact/requirements.txt

@@ -0,0 +1,3 @@
+# agent-framework, agent-framework-foundry-hosting, and agent-framework-hyperlight
+# are installed from local source by the Dockerfile (build context = python/).
+# Add any sample-only third-party deps here.