fix: resolve mypy redundant-cast errors while keeping pyright happy

Use cast(list[Any], x) with type: ignore[redundant-cast] comments to
satisfy both mypy (which considers casting Any redundant) and pyright
strict mode (which needs explicit casts to narrow Unknown types).

Also fix evaluator decorator check_name type annotation to be
explicitly str, resolving mypy str|Any|None mismatch.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

.github/actions/sample-validation-setup/action.yml

@@ -24,9 +24,7 @@ runs:
   using: "composite"
   steps:
     - name: Set up Node.js environment
-      uses: actions/setup-node@v6
-      with:
-        node-version: 22
+      uses: actions/setup-node@v4
 
     - name: Install Copilot CLI
       shell: bash

.github/actions/setup-local-mcp-server/action.yml

@@ -1,166 +0,0 @@
-name: Setup Local MCP Server
-description: Start and validate a local streamable HTTP MCP server for integration tests
-
-inputs:
-  fallback_url:
-    description: Existing LOCAL_MCP_URL value to keep as a fallback if local startup fails
-    required: false
-    default: ''
-  host:
-    description: Host interface to bind the local MCP server
-    required: false
-    default: '127.0.0.1'
-  port:
-    description: Port to bind the local MCP server
-    required: false
-    default: '8011'
-  mount_path:
-    description: Mount path for the local streamable HTTP MCP endpoint
-    required: false
-    default: '/mcp'
-
-outputs:
-  effective_url:
-    description: Local MCP URL when startup succeeds, otherwise the provided fallback URL
-    value: ${{ steps.start.outputs.effective_url }}
-  local_url:
-    description: URL of the local MCP server
-    value: ${{ steps.start.outputs.local_url }}
-  started:
-    description: Whether the local MCP server started and passed validation
-    value: ${{ steps.start.outputs.started }}
-  pid:
-    description: PID of the local MCP server process when startup succeeded
-    value: ${{ steps.start.outputs.pid }}
-
-runs:
-  using: composite
-  steps:
-    - name: Start and validate local MCP server
-      id: start
-      shell: bash
-      run: |
-        set -euo pipefail
-
-        host="${{ inputs.host }}"
-        port="${{ inputs.port }}"
-        mount_path="${{ inputs.mount_path }}"
-        fallback_url="${{ inputs.fallback_url }}"
-
-        if [[ ! "$mount_path" =~ ^/ ]]; then
-          mount_path="/$mount_path"
-        fi
-
-        local_url="http://${host}:${port}${mount_path}"
-        health_url="http://${host}:${port}/healthz"
-        log_file="$RUNNER_TEMP/local-mcp-server.log"
-        pid_file="$RUNNER_TEMP/local-mcp-server.pid"
-        rm -f "$log_file" "$pid_file"
-
-        server_pid="$(
-          python3 - "$GITHUB_WORKSPACE/python" "$log_file" "$host" "$port" "$mount_path" <<'PY'
-        from __future__ import annotations
-
-        import subprocess
-        import sys
-
-        workspace, log_file, host, port, mount_path = sys.argv[1:]
-
-        with open(log_file, "w", encoding="utf-8") as log:
-            process = subprocess.Popen(
-                [
-                    "uv",
-                    "run",
-                    "python",
-                    "scripts/local_mcp_streamable_http_server.py",
-                    "--host",
-                    host,
-                    "--port",
-                    port,
-                    "--mount-path",
-                    mount_path,
-                ],
-                cwd=workspace,
-                stdout=log,
-                stderr=subprocess.STDOUT,
-                start_new_session=True,
-            )
-
-        print(process.pid)
-        PY
-        )"
-        echo "$server_pid" > "$pid_file"
-
-        started=false
-        for _ in $(seq 1 30); do
-          if curl --silent --fail "$health_url" >/dev/null; then
-            started=true
-            break
-          fi
-          if ! kill -0 "$server_pid" 2>/dev/null; then
-            break
-          fi
-          sleep 1
-        done
-
-        if [[ "$started" == "true" ]]; then
-          if ! (
-            cd "$GITHUB_WORKSPACE/python"
-            LOCAL_MCP_URL="$local_url" uv run python - <<'PY'
-        from __future__ import annotations
-
-        import asyncio
-        import os
-
-        from agent_framework import Content, MCPStreamableHTTPTool
-
-
-        def result_to_text(result: str | list[Content]) -> str:
-            if isinstance(result, str):
-                return result
-            return "\n".join(content.text for content in result if content.type == "text" and content.text)
-
-
-        async def main() -> None:
-            tool = MCPStreamableHTTPTool(
-                name="local_ci_mcp",
-                url=os.environ["LOCAL_MCP_URL"],
-                approval_mode="never_require",
-            )
-
-            async with tool:
-                assert tool.functions, "Local MCP server did not expose any tools."
-                result = result_to_text(await tool.functions[0].invoke(query="What is Agent Framework?"))
-                assert result, "Local MCP server returned an empty response."
-
-
-        asyncio.run(main())
-        PY
-          ); then
-            started=false
-          fi
-        fi
-
-        effective_url="$local_url"
-        pid="$server_pid"
-
-        if [[ "$started" != "true" ]]; then
-          effective_url="$fallback_url"
-          pid=""
-          if kill -0 "$server_pid" 2>/dev/null; then
-            kill -TERM -- "-$server_pid" 2>/dev/null || kill -TERM "$server_pid" || true
-            sleep 1
-            kill -KILL -- "-$server_pid" 2>/dev/null || kill -KILL "$server_pid" || true
-          fi
-          echo "Local MCP server was unavailable; continuing with fallback LOCAL_MCP_URL."
-          if [[ -f "$log_file" ]]; then
-            tail -n 100 "$log_file" || true
-          fi
-        else
-          echo "Using local MCP server at $local_url"
-        fi
-
-        echo "started=$started" >> "$GITHUB_OUTPUT"
-        echo "local_url=$local_url" >> "$GITHUB_OUTPUT"
-        echo "effective_url=$effective_url" >> "$GITHUB_OUTPUT"
-        echo "pid=$pid" >> "$GITHUB_OUTPUT"

.github/scripts/stale_issue_pr_ping.py

@@ -1,216 +0,0 @@
-# Copyright (c) Microsoft. All rights reserved.
-
-"""Scan open issues and PRs labeled 'waiting-for-author' for stale follow-ups.
-
-Team members manually add the 'waiting-for-author' label when they need a
-response from the external author.  If the author hasn't replied within
-DAYS_THRESHOLD days of the last team comment, post a reminder and add the
-'requested-info' label to prevent duplicate pings.
-"""
-
-from __future__ import annotations
-
-import os
-import sys
-import time
-from datetime import datetime, timezone
-
-from github import Auth, Github, GithubException
-from github.Issue import Issue
-from github.IssueComment import IssueComment
-
-
-PING_COMMENT = (
-    "@{author}, friendly reminder — this issue is waiting on your response. "
-    "Please share any updates when you get a chance. (This is an automated message.)"
-)
-TRIGGER_LABEL = "waiting-for-author"
-PINGED_LABEL = "requested-info"
-
-
-def get_team_members(g: Github, org: str, team_slug: str) -> set[str]:
-    """Fetch active team member usernames."""
-    try:
-        org_obj = g.get_organization(org)
-        team = org_obj.get_team_by_slug(team_slug)
-        return {m.login for m in team.get_members()}
-    except GithubException as exc:
-        if exc.status in (403, 404):
-            print(
-                f"ERROR: Failed to fetch team members for {org}/{team_slug} "
-                f"(HTTP {exc.status}). Check that the token has the 'read:org' "
-                f"scope and that the team slug '{team_slug}' is correct."
-            )
-        else:
-            print(f"ERROR: Failed to fetch team members for {org}/{team_slug}: {exc}")
-        sys.exit(1)
-    except Exception as exc:
-        print(f"ERROR: Failed to fetch team members for {org}/{team_slug}: {exc}")
-        sys.exit(1)
-
-
-def find_last_team_comment(
-    comments: list[IssueComment], team_members: set[str]
-) -> IssueComment | None:
-    """Return the most recent comment from a team member, or None."""
-    for comment in reversed(comments):
-        if comment.user and comment.user.login in team_members:
-            return comment
-    return None
-
-
-def author_replied_after(
-    comments: list[IssueComment], author: str, after: datetime
-) -> bool:
-    """Check if the issue author commented after the given timestamp."""
-    for comment in comments:
-        if (
-            comment.user
-            and comment.user.login == author
-            and comment.created_at > after
-        ):
-            return True
-    return False
-
-
-def should_ping(
-    issue: Issue,
-    team_members: set[str],
-    days_threshold: int,
-    now: datetime,
-) -> bool:
-    """Determine whether this issue/PR should be pinged.
-
-    Only issues/PRs carrying the 'waiting-for-author' label are candidates.
-    """
-    author = issue.user.login
-
-    # Skip if the trigger label is not present
-    if not any(label.name == TRIGGER_LABEL for label in issue.labels):
-        return False
-    # Skip if author is a team member
-    if author in team_members:
-        return False
-
-    # Skip if already pinged
-    if any(label.name == PINGED_LABEL for label in issue.labels):
-        return False
-
-    # Skip if no comments at all
-    if issue.comments == 0:
-        return False
-
-    # Fetch comments once for both lookups
-    comments = list(issue.get_comments())
-
-    # Find last team member comment
-    last_team_comment = find_last_team_comment(comments, team_members)
-    if last_team_comment is None:
-        return False
-
-    # Skip if author replied after the last team comment
-    if author_replied_after(comments, author, last_team_comment.created_at):
-        return False
-
-    # Check if enough days have passed
-    days_since = (now - last_team_comment.created_at.astimezone(timezone.utc)).days
-    if days_since < days_threshold:
-        return False
-
-    return True
-
-
-def ping(issue: Issue, dry_run: bool) -> bool:
-    """Post a reminder comment and add the 'requested-info' label. Returns True on success."""
-    author = issue.user.login
-    kind = "PR" if issue.pull_request else "Issue"
-
-    if dry_run:
-        print(f"  [DRY RUN] Would ping {kind} #{issue.number} (@{author})")
-        return True
-
-    max_retries = 3
-    commented = False
-    labeled = False
-    for attempt in range(1, max_retries + 1):
-        try:
-            if not commented:
-                issue.create_comment(PING_COMMENT.format(author=author))
-                commented = True
-            if not labeled:
-                issue.add_to_labels(PINGED_LABEL)
-                labeled = True
-            print(f"  Pinged {kind} #{issue.number} (@{author})")
-            return True
-        except Exception as exc:
-            if attempt < max_retries:
-                wait = 2 ** attempt  # 2s, 4s
-                print(f"  WARN: Attempt {attempt}/{max_retries} failed for {kind} #{issue.number}: {exc}. Retrying in {wait}s...")
-                time.sleep(wait)
-            else:
-                print(f"  ERROR: Failed to ping {kind} #{issue.number} after {max_retries} attempts: {exc}")
-                return False
-
-
-def main() -> None:
-    token = os.environ.get("GITHUB_TOKEN")
-    if not token:
-        print("ERROR: GITHUB_TOKEN environment variable is required")
-        sys.exit(1)
-
-    repository = os.environ.get("GITHUB_REPOSITORY")
-    if not repository:
-        print("ERROR: GITHUB_REPOSITORY environment variable is required")
-        sys.exit(1)
-
-    team_slug = os.environ.get("TEAM_SLUG")
-    if not team_slug:
-        print("ERROR: TEAM_SLUG environment variable is required")
-        sys.exit(1)
-
-    days_threshold_raw = os.environ.get("DAYS_THRESHOLD", "4")
-    try:
-        days_threshold = int(days_threshold_raw)
-    except ValueError:
-        print(f"ERROR: DAYS_THRESHOLD must be a numeric value, got '{days_threshold_raw}'")
-        sys.exit(1)
-    dry_run = os.environ.get("DRY_RUN", "false").lower() == "true"
-
-    org = repository.split("/")[0]
-
-    if dry_run:
-        print("Running in DRY RUN mode — no comments or labels will be applied.\n")
-
-    g = Github(auth=Auth.Token(token))
-    repo = g.get_repo(repository)
-
-    print(f"Fetching team members for {org}/{team_slug}...")
-    team_members = get_team_members(g, org, team_slug)
-    print(f"Found {len(team_members)} team members.\n")
-
-    now = datetime.now(timezone.utc)
-    pinged = []
-    failed = []
-    scanned = 0
-
-    print(f"Scanning open issues and PRs labeled '{TRIGGER_LABEL}' (threshold: {days_threshold} days)...\n")
-
-    for issue in repo.get_issues(state="open", labels=[TRIGGER_LABEL]):
-        scanned += 1
-
-        if should_ping(issue, team_members, days_threshold, now):
-            if ping(issue, dry_run):
-                pinged.append(issue.number)
-            else:
-                failed.append(issue.number)
-
-    print(f"\nDone. Scanned {scanned} items, pinged {len(pinged)}, failed {len(failed)}.")
-    if pinged:
-        print(f"Pinged: {', '.join(f'#{n}' for n in pinged)}")
-    if failed:
-        print(f"Failed: {', '.join(f'#{n}' for n in failed)}")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

.github/tests/test_stale_issue_pr_ping.py

@@ -1,297 +0,0 @@
-# Copyright (c) Microsoft. All rights reserved.
-
-"""Tests for stale_issue_pr_ping.py."""
-
-from __future__ import annotations
-
-import os
-import sys
-from datetime import datetime, timezone, timedelta
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-# Ensure the script directory is importable
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "scripts"))
-
-from stale_issue_pr_ping import (
-    PINGED_LABEL,
-    PING_COMMENT,
-    TRIGGER_LABEL,
-    author_replied_after,
-    find_last_team_comment,
-    get_team_members,
-    main,
-    ping,
-    should_ping,
-)
-
-TEAM = {"alice", "bob"}
-NOW = datetime(2026, 3, 15, 12, 0, 0, tzinfo=timezone.utc)
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-def _make_comment(login: str | None, created_at: datetime) -> MagicMock:
-    """Create a mock IssueComment."""
-    c = MagicMock()
-    if login is None:
-        c.user = None
-    else:
-        c.user = MagicMock()
-        c.user.login = login
-    c.created_at = created_at
-    return c
-
-
-def _make_label(name: str) -> MagicMock:
-    lbl = MagicMock()
-    lbl.name = name
-    return lbl
-
-
-def _make_issue(
-    author: str = "external",
-    labels: list[str] | None = None,
-    comment_count: int = 1,
-    comments: list[MagicMock] | None = None,
-    pull_request: bool = False,
-    number: int = 42,
-) -> MagicMock:
-    issue = MagicMock()
-    issue.user = MagicMock()
-    issue.user.login = author
-    issue.number = number
-    # Default to having the trigger label, since the API query pre-filters.
-    if labels is None:
-        labels = [TRIGGER_LABEL]
-    issue.labels = [_make_label(n) for n in labels]
-    issue.comments = comment_count
-    issue.pull_request = MagicMock() if pull_request else None
-    if comments is not None:
-        issue.get_comments.return_value = comments
-    return issue
-
-
-# ---------------------------------------------------------------------------
-# find_last_team_comment
-# ---------------------------------------------------------------------------
-
-class TestFindLastTeamComment:
-    def test_returns_last_team_comment(self):
-        c1 = _make_comment("alice", datetime(2026, 3, 1, tzinfo=timezone.utc))
-        c2 = _make_comment("external", datetime(2026, 3, 2, tzinfo=timezone.utc))
-        c3 = _make_comment("bob", datetime(2026, 3, 3, tzinfo=timezone.utc))
-        assert find_last_team_comment([c1, c2, c3], TEAM) is c3
-
-    def test_returns_none_when_no_team_comments(self):
-        c1 = _make_comment("external", datetime(2026, 3, 1, tzinfo=timezone.utc))
-        assert find_last_team_comment([c1], TEAM) is None
-
-    def test_returns_none_for_empty_list(self):
-        assert find_last_team_comment([], TEAM) is None
-
-    def test_skips_deleted_user(self):
-        c1 = _make_comment(None, datetime(2026, 3, 1, tzinfo=timezone.utc))
-        c2 = _make_comment("alice", datetime(2026, 3, 2, tzinfo=timezone.utc))
-        assert find_last_team_comment([c1, c2], TEAM) is c2
-
-    def test_only_deleted_users(self):
-        c1 = _make_comment(None, datetime(2026, 3, 1, tzinfo=timezone.utc))
-        assert find_last_team_comment([c1], TEAM) is None
-
-
-# ---------------------------------------------------------------------------
-# author_replied_after
-# ---------------------------------------------------------------------------
-
-class TestAuthorRepliedAfter:
-    def test_author_replied(self):
-        after = datetime(2026, 3, 1, tzinfo=timezone.utc)
-        c1 = _make_comment("external", datetime(2026, 3, 2, tzinfo=timezone.utc))
-        assert author_replied_after([c1], "external", after) is True
-
-    def test_author_not_replied(self):
-        after = datetime(2026, 3, 5, tzinfo=timezone.utc)
-        c1 = _make_comment("external", datetime(2026, 3, 2, tzinfo=timezone.utc))
-        assert author_replied_after([c1], "external", after) is False
-
-    def test_different_user_replied(self):
-        after = datetime(2026, 3, 1, tzinfo=timezone.utc)
-        c1 = _make_comment("someone_else", datetime(2026, 3, 2, tzinfo=timezone.utc))
-        assert author_replied_after([c1], "external", after) is False
-
-    def test_deleted_user_comment(self):
-        after = datetime(2026, 3, 1, tzinfo=timezone.utc)
-        c1 = _make_comment(None, datetime(2026, 3, 2, tzinfo=timezone.utc))
-        assert author_replied_after([c1], "external", after) is False
-
-
-# ---------------------------------------------------------------------------
-# should_ping
-# ---------------------------------------------------------------------------
-
-class TestShouldPing:
-    def test_should_ping_stale_issue(self):
-        team_comment = _make_comment("alice", NOW - timedelta(days=5))
-        issue = _make_issue(comments=[team_comment], comment_count=1)
-        assert should_ping(issue, TEAM, 4, NOW) is True
-
-    def test_skip_team_member_author(self):
-        issue = _make_issue(author="alice", labels=[TRIGGER_LABEL], comment_count=1)
-        assert should_ping(issue, TEAM, 4, NOW) is False
-
-    def test_skip_already_pinged(self):
-        issue = _make_issue(labels=[TRIGGER_LABEL, PINGED_LABEL], comment_count=1)
-        assert should_ping(issue, TEAM, 4, NOW) is False
-
-    def test_skip_no_comments(self):
-        issue = _make_issue(comment_count=0)
-        assert should_ping(issue, TEAM, 4, NOW) is False
-
-    def test_skip_no_team_comment(self):
-        c = _make_comment("external", NOW - timedelta(days=5))
-        issue = _make_issue(comments=[c], comment_count=1)
-        assert should_ping(issue, TEAM, 4, NOW) is False
-
-    def test_skip_author_replied(self):
-        team_c = _make_comment("alice", NOW - timedelta(days=5))
-        author_c = _make_comment("external", NOW - timedelta(days=3))
-        issue = _make_issue(comments=[team_c, author_c], comment_count=2)
-        assert should_ping(issue, TEAM, 4, NOW) is False
-
-    def test_skip_not_enough_days(self):
-        team_comment = _make_comment("alice", NOW - timedelta(days=2))
-        issue = _make_issue(comments=[team_comment], comment_count=1)
-        assert should_ping(issue, TEAM, 4, NOW) is False
-
-    def test_aware_datetime_handled(self):
-        """Timezone-aware datetimes should not be mangled by astimezone."""
-        aware_dt = (NOW - timedelta(days=5)).replace(tzinfo=timezone.utc)
-        team_comment = _make_comment("alice", aware_dt)
-        issue = _make_issue(comments=[team_comment], comment_count=1)
-        assert should_ping(issue, TEAM, 4, NOW) is True
-
-    def test_naive_datetime_handled(self):
-        """Naive datetimes (pre-PyGithub 2.x) should be handled by astimezone."""
-        naive_dt = (NOW - timedelta(days=5)).replace(tzinfo=None)
-        team_comment = _make_comment("alice", naive_dt)
-        issue = _make_issue(comments=[team_comment], comment_count=1)
-        # astimezone on naive datetime treats it as local time; just verify no crash
-        should_ping(issue, TEAM, 4, NOW)
-
-
-# ---------------------------------------------------------------------------
-# ping
-# ---------------------------------------------------------------------------
-
-class TestPing:
-    def test_dry_run(self, capsys):
-        issue = _make_issue()
-        assert ping(issue, dry_run=True) is True
-        issue.create_comment.assert_not_called()
-        assert "DRY RUN" in capsys.readouterr().out
-
-    def test_success(self, capsys):
-        issue = _make_issue()
-        assert ping(issue, dry_run=False) is True
-        issue.create_comment.assert_called_once()
-        issue.add_to_labels.assert_called_once_with(PINGED_LABEL)
-
-    @patch("stale_issue_pr_ping.time.sleep")
-    def test_retry_on_failure(self, mock_sleep):
-        issue = _make_issue()
-        issue.create_comment.side_effect = [Exception("net error"), None]
-        assert ping(issue, dry_run=False) is True
-        assert issue.create_comment.call_count == 2
-        mock_sleep.assert_called_once()
-
-    @patch("stale_issue_pr_ping.time.sleep")
-    def test_idempotent_retry_skips_comment_on_label_failure(self, mock_sleep):
-        """If create_comment succeeds but add_to_labels fails, retry should not re-comment."""
-        issue = _make_issue()
-        issue.add_to_labels.side_effect = [Exception("label error"), None]
-        assert ping(issue, dry_run=False) is True
-        # Comment should only be created once even though there were 2 attempts
-        assert issue.create_comment.call_count == 1
-        assert issue.add_to_labels.call_count == 2
-
-    @patch("stale_issue_pr_ping.time.sleep")
-    def test_all_retries_fail(self, mock_sleep):
-        issue = _make_issue()
-        issue.create_comment.side_effect = Exception("permanent error")
-        assert ping(issue, dry_run=False) is False
-        assert issue.create_comment.call_count == 3
-
-
-# ---------------------------------------------------------------------------
-# get_team_members
-# ---------------------------------------------------------------------------
-
-class TestGetTeamMembers:
-    def test_success(self):
-        g = MagicMock()
-        member = MagicMock()
-        member.login = "alice"
-        g.get_organization.return_value.get_team_by_slug.return_value.get_members.return_value = [member]
-        assert get_team_members(g, "org", "my-team") == {"alice"}
-
-    def test_403_error_message(self, capsys):
-        from github import GithubException
-
-        g = MagicMock()
-        g.get_organization.return_value.get_team_by_slug.side_effect = GithubException(
-            403, {"message": "Forbidden"}, None
-        )
-        with pytest.raises(SystemExit):
-            get_team_members(g, "org", "my-team")
-        out = capsys.readouterr().out
-        assert "read:org" in out
-        assert "403" in out
-
-    def test_404_error_message(self, capsys):
-        from github import GithubException
-
-        g = MagicMock()
-        g.get_organization.return_value.get_team_by_slug.side_effect = GithubException(
-            404, {"message": "Not Found"}, None
-        )
-        with pytest.raises(SystemExit):
-            get_team_members(g, "org", "bad-slug")
-        out = capsys.readouterr().out
-        assert "read:org" in out
-        assert "bad-slug" in out
-
-    def test_generic_error(self, capsys):
-        g = MagicMock()
-        g.get_organization.side_effect = RuntimeError("boom")
-        with pytest.raises(SystemExit):
-            get_team_members(g, "org", "team")
-
-
-# ---------------------------------------------------------------------------
-# main – env var validation
-# ---------------------------------------------------------------------------
-
-class TestMain:
-    @patch.dict(os.environ, {
-        "GITHUB_TOKEN": "tok",
-        "GITHUB_REPOSITORY": "org/repo",
-        "TEAM_SLUG": "my-team",
-        "DAYS_THRESHOLD": "abc",
-    }, clear=True)
-    def test_invalid_days_threshold(self, capsys):
-        with pytest.raises(SystemExit):
-            main()
-        assert "numeric" in capsys.readouterr().out
-
-    @patch.dict(os.environ, {
-        "GITHUB_TOKEN": "tok",
-        "GITHUB_REPOSITORY": "org/repo",
-    }, clear=True)
-    def test_missing_team_slug(self, capsys):
-        with pytest.raises(SystemExit):
-            main()
-        assert "TEAM_SLUG" in capsys.readouterr().out

.github/workflows/python-check-coverage.py

@@ -41,7 +41,8 @@ ENFORCED_TARGETS: set[str] = {
     "packages.purview.agent_framework_purview",
     "packages.anthropic.agent_framework_anthropic",
     "packages.azure-ai-search.agent_framework_azure_ai_search",
-    "packages.openai.agent_framework_openai",
+    "packages.core.agent_framework.azure",
+    "packages.core.agent_framework.openai",
     # Individual files (if you want to enforce specific files instead of whole packages)
     "packages/core/agent_framework/observability.py",
     # Add more targets here as coverage improves

.github/workflows/python-integration-tests.yml

@@ -63,8 +63,6 @@ jobs:
       OPENAI_CHAT_MODEL_ID: ${{ vars.OPENAI__CHATMODELID }}
       OPENAI_RESPONSES_MODEL_ID: ${{ vars.OPENAI__RESPONSESMODELID }}
       OPENAI_EMBEDDINGS_MODEL_ID: ${{ vars.OPENAI_EMBEDDING_MODEL_ID }}
-      OPENAI_MODEL: ${{ vars.OPENAI__RESPONSESMODELID }}
-      OPENAI_EMBEDDING_MODEL: ${{ vars.OPENAI_EMBEDDING_MODEL_ID }}
       OPENAI_API_KEY: ${{ secrets.OPENAI__APIKEY }}
     defaults:
       run:
@@ -83,8 +81,8 @@ jobs:
       - name: Test with pytest (OpenAI integration)
         run: >
           uv run pytest --import-mode=importlib
-          packages/openai/tests
-          -m "integration and not azure"
+          packages/core/tests/openai
+          -m integration
           -n logical --dist worksteal
           --timeout=120 --session-timeout=900 --timeout_method thread
           --retries 2 --retry-delay 5
@@ -96,9 +94,8 @@ jobs:
     environment: integration
     timeout-minutes: 60
     env:
-      AZURE_OPENAI_CHAT_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__RESPONSESDEPLOYMENTNAME }}
+      AZURE_OPENAI_CHAT_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__CHATDEPLOYMENTNAME }}
       AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__RESPONSESDEPLOYMENTNAME }}
-      AZURE_OPENAI_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__RESPONSESDEPLOYMENTNAME }}
       AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__EMBEDDINGDEPLOYMENTNAME }}
       AZURE_OPENAI_ENDPOINT: ${{ vars.AZUREOPENAI__ENDPOINT }}
     defaults:
@@ -124,9 +121,7 @@ jobs:
       - name: Test with pytest (Azure OpenAI integration)
         run: >
           uv run pytest --import-mode=importlib
-          packages/openai/tests/openai/test_openai_chat_completion_client_azure.py
-          packages/openai/tests/openai/test_openai_chat_client_azure.py
-          packages/azure-ai/tests/azure_openai
+          packages/core/tests/azure
           -m integration
           -n logical --dist worksteal
           --timeout=120 --session-timeout=900 --timeout_method thread
@@ -156,13 +151,6 @@ jobs:
         with:
           python-version: ${{ env.UV_PYTHON }}
           os: ${{ runner.os }}
-      - name: Start local MCP server
-        id: local-mcp
-        uses: ./.github/actions/setup-local-mcp-server
-        with:
-          fallback_url: ${{ env.LOCAL_MCP_URL }}
-      - name: Prefer local MCP URL when available
-        run: echo "LOCAL_MCP_URL=${{ steps.local-mcp.outputs.effective_url }}" >> "$GITHUB_ENV"
       - name: Test with pytest (Anthropic, Ollama, MCP integration)
         run: >
           uv run pytest --import-mode=importlib
@@ -173,26 +161,6 @@ jobs:
           -n logical --dist worksteal
           --timeout=120 --session-timeout=900 --timeout_method thread
           --retries 2 --retry-delay 5
-      - name: Stop local MCP server
-        if: always()
-        shell: bash
-        run: |
-          set -euo pipefail
-          server_pid="${{ steps.local-mcp.outputs.pid }}"
-          if [[ -z "$server_pid" ]]; then
-            exit 0
-          fi
-          if ! kill -0 "$server_pid" 2>/dev/null; then
-            exit 0
-          fi
-          kill -TERM -- "-$server_pid" 2>/dev/null || kill -TERM "$server_pid" 2>/dev/null || true
-          for _ in $(seq 1 10); do
-            if ! kill -0 "$server_pid" 2>/dev/null; then
-              exit 0
-            fi
-            sleep 1
-          done
-          kill -KILL -- "-$server_pid" 2>/dev/null || kill -KILL "$server_pid" 2>/dev/null || true
 
   # Azure Functions + Durable Task integration tests
   python-tests-functions:
@@ -204,13 +172,10 @@ jobs:
       UV_PYTHON: "3.11"
       OPENAI_CHAT_MODEL_ID: ${{ vars.OPENAI__CHATMODELID }}
       OPENAI_RESPONSES_MODEL_ID: ${{ vars.OPENAI__RESPONSESMODELID }}
-      OPENAI_MODEL: ${{ vars.OPENAI__RESPONSESMODELID }}
       OPENAI_API_KEY: ${{ secrets.OPENAI__APIKEY }}
-      OPENAI_EMBEDDING_MODEL: ${{ vars.OPENAI_EMBEDDING_MODEL_ID }}
+      AZURE_OPENAI_CHAT_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__CHATDEPLOYMENTNAME }}
+      AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__RESPONSESDEPLOYMENTNAME }}
       AZURE_OPENAI_ENDPOINT: ${{ vars.AZUREOPENAI__ENDPOINT }}
-      AZURE_OPENAI_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__RESPONSESDEPLOYMENTNAME }}
-      FOUNDRY_MODEL: ${{ vars.AZUREAI__DEPLOYMENTNAME }}
-      FOUNDRY_PROJECT_ENDPOINT: ${{ secrets.AZUREAI__ENDPOINT }}
       FUNCTIONS_WORKER_RUNTIME: "python"
       DURABLE_TASK_SCHEDULER_CONNECTION_STRING: "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None"
       AzureWebJobsStorage: "UseDevelopmentStorage=true"
@@ -244,8 +209,7 @@ jobs:
           packages/durabletask/tests/integration_tests
           -m integration
           -n logical --dist worksteal
-          -x
-          --timeout=360 --session-timeout=900 --timeout_method thread
+          --timeout=120 --session-timeout=900 --timeout_method thread
           --retries 2 --retry-delay 5
 
   # Azure AI integration tests
@@ -257,8 +221,6 @@ jobs:
     env:
       AZURE_AI_PROJECT_ENDPOINT: ${{ secrets.AZUREAI__ENDPOINT }}
       AZURE_AI_MODEL_DEPLOYMENT_NAME: ${{ vars.AZUREAI__DEPLOYMENTNAME }}
-      FOUNDRY_PROJECT_ENDPOINT: ${{ secrets.AZUREAI__ENDPOINT }}
-      FOUNDRY_MODEL: ${{ vars.AZUREAI__DEPLOYMENTNAME }}
       LOCAL_MCP_URL: ${{ vars.LOCAL_MCP__URL }}
     defaults:
       run:
@@ -282,9 +244,7 @@ jobs:
           subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
       - name: Test with pytest
         timeout-minutes: 15
-        run: |
-          uv run --directory packages/azure-ai poe integration-tests -n logical --dist worksteal --timeout=120 --session-timeout=900 --timeout_method thread --retries 2 --retry-delay 5
-          uv run --directory packages/foundry poe integration-tests -n logical --dist worksteal --timeout=120 --session-timeout=900 --timeout_method thread --retries 2 --retry-delay 5
+        run: uv run --directory packages/azure-ai poe integration-tests -n logical --dist worksteal --timeout=120 --session-timeout=900 --timeout_method thread --retries 2 --retry-delay 5
 
   # Azure Cosmos integration tests
   python-tests-cosmos:

.github/workflows/python-merge-tests.yml

@@ -47,9 +47,6 @@ jobs:
           filters: |
             python:
               - 'python/**'
-              - '.github/actions/setup-local-mcp-server/**'
-              - '.github/workflows/python-merge-tests.yml'
-              - '.github/workflows/python-integration-tests.yml'
             core:
               - 'python/packages/core/agent_framework/_*.py'
               - 'python/packages/core/agent_framework/_workflows/**'
@@ -57,30 +54,20 @@ jobs:
               - 'python/packages/core/agent_framework/observability.py'
             openai:
               - 'python/packages/core/agent_framework/openai/**'
-              - 'python/packages/openai/**'
-              - 'python/samples/**/providers/openai/**'
+              - 'python/packages/core/tests/openai/**'
             azure:
-              - 'python/packages/openai/**'
               - 'python/packages/core/agent_framework/azure/**'
-              - 'python/packages/azure-ai/agent_framework_azure_ai/_deprecated_azure_openai.py'
-              - 'python/packages/azure-ai/tests/azure_openai/**'
-              - 'python/samples/**/providers/azure/openai_chat_completion_client_azure*.py'
+              - 'python/packages/core/tests/azure/**'
             misc:
               - 'python/packages/anthropic/**'
               - 'python/packages/ollama/**'
               - 'python/packages/core/agent_framework/_mcp.py'
               - 'python/packages/core/tests/core/test_mcp.py'
-              - 'python/scripts/local_mcp_streamable_http_server.py'
-              - '.github/actions/setup-local-mcp-server/**'
-              - '.github/workflows/python-merge-tests.yml'
-              - '.github/workflows/python-integration-tests.yml'
             functions:
               - 'python/packages/azurefunctions/**'
               - 'python/packages/durabletask/**'
             azure-ai:
               - 'python/packages/azure-ai/**'
-              - 'python/packages/foundry/**'
-              - 'python/samples/**/providers/foundry/**'
             cosmos:
               - 'python/packages/azure-cosmos/**'
       # run only if 'python' files were changed
@@ -144,8 +131,6 @@ jobs:
       OPENAI_CHAT_MODEL_ID: ${{ vars.OPENAI__CHATMODELID }}
       OPENAI_RESPONSES_MODEL_ID: ${{ vars.OPENAI__RESPONSESMODELID }}
       OPENAI_EMBEDDINGS_MODEL_ID: ${{ vars.OPENAI_EMBEDDING_MODEL_ID }}
-      OPENAI_MODEL: ${{ vars.OPENAI__RESPONSESMODELID }}
-      OPENAI_EMBEDDING_MODEL: ${{ vars.OPENAI_EMBEDDING_MODEL_ID }}
       OPENAI_API_KEY: ${{ secrets.OPENAI__APIKEY }}
     defaults:
       run:
@@ -161,8 +146,8 @@ jobs:
       - name: Test with pytest (OpenAI integration)
         run: >
           uv run pytest --import-mode=importlib
-          packages/openai/tests
-          -m "integration and not azure"
+          packages/core/tests/openai
+          -m integration
           -n logical --dist worksteal
           --timeout=120 --session-timeout=900 --timeout_method thread
           --retries 2 --retry-delay 5
@@ -195,9 +180,8 @@ jobs:
     runs-on: ubuntu-latest
     environment: integration
     env:
-      AZURE_OPENAI_CHAT_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__RESPONSESDEPLOYMENTNAME }}
+      AZURE_OPENAI_CHAT_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__CHATDEPLOYMENTNAME }}
       AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__RESPONSESDEPLOYMENTNAME }}
-      AZURE_OPENAI_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__RESPONSESDEPLOYMENTNAME }}
       AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__EMBEDDINGDEPLOYMENTNAME }}
       AZURE_OPENAI_ENDPOINT: ${{ vars.AZUREOPENAI__ENDPOINT }}
     defaults:
@@ -221,9 +205,7 @@ jobs:
       - name: Test with pytest (Azure OpenAI integration)
         run: >
           uv run pytest --import-mode=importlib
-          packages/openai/tests/openai/test_openai_chat_completion_client_azure.py
-          packages/openai/tests/openai/test_openai_chat_client_azure.py
-          packages/azure-ai/tests/azure_openai
+          packages/core/tests/azure
           -m integration
           -n logical --dist worksteal
           --timeout=120 --session-timeout=900 --timeout_method thread
@@ -271,13 +253,6 @@ jobs:
         with:
           python-version: ${{ env.UV_PYTHON }}
           os: ${{ runner.os }}
-      - name: Start local MCP server
-        id: local-mcp
-        uses: ./.github/actions/setup-local-mcp-server
-        with:
-          fallback_url: ${{ env.LOCAL_MCP_URL }}
-      - name: Prefer local MCP URL when available
-        run: echo "LOCAL_MCP_URL=${{ steps.local-mcp.outputs.effective_url }}" >> "$GITHUB_ENV"
       - name: Test with pytest (Anthropic, Ollama, MCP integration)
         run: >
           uv run pytest --import-mode=importlib
@@ -289,26 +264,6 @@ jobs:
           --timeout=120 --session-timeout=900 --timeout_method thread
           --retries 2 --retry-delay 5
         working-directory: ./python
-      - name: Stop local MCP server
-        if: always()
-        shell: bash
-        run: |
-          set -euo pipefail
-          server_pid="${{ steps.local-mcp.outputs.pid }}"
-          if [[ -z "$server_pid" ]]; then
-            exit 0
-          fi
-          if ! kill -0 "$server_pid" 2>/dev/null; then
-            exit 0
-          fi
-          kill -TERM -- "-$server_pid" 2>/dev/null || kill -TERM "$server_pid" 2>/dev/null || true
-          for _ in $(seq 1 10); do
-            if ! kill -0 "$server_pid" 2>/dev/null; then
-              exit 0
-            fi
-            sleep 1
-          done
-          kill -KILL -- "-$server_pid" 2>/dev/null || kill -KILL "$server_pid" 2>/dev/null || true
       - name: Surface failing tests
         if: always()
         uses: pmeier/pytest-results-action@v0.7.2
@@ -335,13 +290,10 @@ jobs:
       UV_PYTHON: "3.11"
       OPENAI_CHAT_MODEL_ID: ${{ vars.OPENAI__CHATMODELID }}
       OPENAI_RESPONSES_MODEL_ID: ${{ vars.OPENAI__RESPONSESMODELID }}
-      OPENAI_MODEL: ${{ vars.OPENAI__RESPONSESMODELID }}
       OPENAI_API_KEY: ${{ secrets.OPENAI__APIKEY }}
-      OPENAI_EMBEDDING_MODEL: ${{ vars.OPENAI_EMBEDDING_MODEL_ID }}
+      AZURE_OPENAI_CHAT_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__CHATDEPLOYMENTNAME }}
+      AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__RESPONSESDEPLOYMENTNAME }}
       AZURE_OPENAI_ENDPOINT: ${{ vars.AZUREOPENAI__ENDPOINT }}
-      AZURE_OPENAI_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__RESPONSESDEPLOYMENTNAME }}
-      FOUNDRY_MODEL: ${{ vars.AZUREAI__DEPLOYMENTNAME }}
-      FOUNDRY_PROJECT_ENDPOINT: ${{ secrets.AZUREAI__ENDPOINT }}
       FUNCTIONS_WORKER_RUNTIME: "python"
       DURABLE_TASK_SCHEDULER_CONNECTION_STRING: "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None"
       AzureWebJobsStorage: "UseDevelopmentStorage=true"
@@ -373,8 +325,7 @@ jobs:
           packages/durabletask/tests/integration_tests
           -m integration
           -n logical --dist worksteal
-          -x
-          --timeout=360 --session-timeout=900 --timeout_method thread
+          --timeout=120 --session-timeout=900 --timeout_method thread
           --retries 2 --retry-delay 5
         working-directory: ./python
       - name: Surface failing tests
@@ -401,8 +352,6 @@ jobs:
     env:
       AZURE_AI_PROJECT_ENDPOINT: ${{ secrets.AZUREAI__ENDPOINT }}
       AZURE_AI_MODEL_DEPLOYMENT_NAME: ${{ vars.AZUREAI__DEPLOYMENTNAME }}
-      FOUNDRY_PROJECT_ENDPOINT: ${{ secrets.AZUREAI__ENDPOINT }}
-      FOUNDRY_MODEL: ${{ vars.AZUREAI__DEPLOYMENTNAME }}
       LOCAL_MCP_URL: ${{ vars.LOCAL_MCP__URL }}
     defaults:
       run:
@@ -424,9 +373,7 @@ jobs:
           subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
       - name: Test with pytest
         timeout-minutes: 15
-        run: |
-          uv run --directory packages/azure-ai poe integration-tests -n logical --dist worksteal --timeout=120 --session-timeout=900 --timeout_method thread --retries 2 --retry-delay 5
-          uv run --directory packages/foundry poe integration-tests -n logical --dist worksteal --timeout=120 --session-timeout=900 --timeout_method thread --retries 2 --retry-delay 5
+        run: uv run --directory packages/azure-ai poe integration-tests -n logical --dist worksteal --timeout=120 --session-timeout=900 --timeout_method thread --retries 2 --retry-delay 5
         working-directory: ./python
       - name: Test Azure AI samples
         timeout-minutes: 10

.github/workflows/python-sample-validation.yml

@@ -41,13 +41,6 @@ jobs:
           azure-subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
           os: ${{ runner.os }}
 
-      - name: Create .env for samples
-        run: |
-          echo "AZURE_AI_PROJECT_ENDPOINT=$AZURE_AI_PROJECT_ENDPOINT" >> .env
-          echo "AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME=$AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME" >> .env
-          echo "AZURE_OPENAI_ENDPOINT=$AZURE_OPENAI_ENDPOINT" >> .env
-          echo "AZURE_OPENAI_CHAT_DEPLOYMENT_NAME=$AZURE_OPENAI_CHAT_DEPLOYMENT_NAME" >> .env
-
       - name: Run sample validation
         run: |
           cd scripts && uv run python -m sample_validation --subdir 01-get-started --save-report --report-name 01-get-started
@@ -57,7 +50,7 @@ jobs:
         if: always()
         with:
           name: validation-report-01-get-started
-          path: python/samples/sample_validation/reports/
+          path: python/scripts/sample_validation/reports/
 
   validate-02-agents:
     name: Validate 02-agents
@@ -71,14 +64,10 @@ jobs:
       AZURE_OPENAI_ENDPOINT: ${{ vars.AZUREOPENAI__ENDPOINT }}
       AZURE_OPENAI_CHAT_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__CHATDEPLOYMENTNAME }}
       AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__RESPONSESDEPLOYMENTNAME }}
-      AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__EMBEDDINGDEPLOYMENTNAME }}
       # OpenAI configuration
       OPENAI_API_KEY: ${{ secrets.OPENAI__APIKEY }}
       OPENAI_CHAT_MODEL_ID: ${{ vars.OPENAI__CHATMODELID }}
       OPENAI_RESPONSES_MODEL_ID: ${{ vars.OPENAI__RESPONSESMODELID }}
-      # GitHub MCP
-      GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}
-      OPENAI_MODEL: ${{ vars.OPENAI__RESPONSESMODELID }}
       # Observability
       ENABLE_INSTRUMENTATION: "true"
     defaults:
@@ -95,420 +84,16 @@ jobs:
           azure-subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
           os: ${{ runner.os }}
 
-      - name: Create .env for samples
-        run: |
-          echo "AZURE_AI_PROJECT_ENDPOINT=$AZURE_AI_PROJECT_ENDPOINT" >> .env
-          echo "AZURE_AI_MODEL_DEPLOYMENT_NAME=$AZURE_AI_MODEL_DEPLOYMENT_NAME" >> .env
-          echo "AZURE_OPENAI_ENDPOINT=$AZURE_OPENAI_ENDPOINT" >> .env
-          echo "AZURE_OPENAI_CHAT_DEPLOYMENT_NAME=$AZURE_OPENAI_CHAT_DEPLOYMENT_NAME" >> .env
-          echo "AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME=$AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME" >> .env
-          echo "AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME=$AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME" >> .env
-          echo "OPENAI_API_KEY=$OPENAI_API_KEY" >> .env
-          echo "OPENAI_CHAT_MODEL_ID=$OPENAI_CHAT_MODEL_ID" >> .env
-          echo "OPENAI_RESPONSES_MODEL_ID=$OPENAI_RESPONSES_MODEL_ID" >> .env
-          echo "GITHUB_PAT=$GITHUB_PAT" >> .env
-
       - name: Run sample validation
         run: |
-          cd scripts && uv run python -m sample_validation --subdir 02-agents --exclude providers --save-report --report-name 02-agents
+          cd scripts && uv run python -m sample_validation --subdir 02-agents --save-report --report-name 02-agents
 
       - name: Upload validation report
         uses: actions/upload-artifact@v7
         if: always()
         with:
           name: validation-report-02-agents
-          path: python/samples/sample_validation/reports/
-
-  validate-02-agents-openai:
-    name: Validate 02-agents/providers/openai
-    runs-on: ubuntu-latest
-    environment: integration
-    env:
-      OPENAI_API_KEY: ${{ secrets.OPENAI__APIKEY }}
-      OPENAI_CHAT_MODEL_ID: ${{ vars.OPENAI__CHATMODELID }}
-      OPENAI_RESPONSES_MODEL_ID: ${{ vars.OPENAI__RESPONSESMODELID }}
-    defaults:
-      run:
-        working-directory: python
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Setup environment
-        uses: ./.github/actions/sample-validation-setup
-        with:
-          azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
-          azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
-          azure-subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-          os: ${{ runner.os }}
-
-      - name: Create .env for samples
-        run: |
-          echo "OPENAI_API_KEY=$OPENAI_API_KEY" >> .env
-          echo "OPENAI_CHAT_MODEL_ID=$OPENAI_CHAT_MODEL_ID" >> .env
-          echo "OPENAI_RESPONSES_MODEL_ID=$OPENAI_RESPONSES_MODEL_ID" >> .env
-
-      - name: Run sample validation
-        run: |
-          cd scripts && uv run python -m sample_validation --subdir 02-agents/providers/openai --save-report --report-name 02-agents-openai
-
-      - name: Upload validation report
-        uses: actions/upload-artifact@v7
-        if: always()
-        with:
-          name: validation-report-02-agents-openai
-          path: python/samples/sample_validation/reports/
-
-  validate-02-agents-azure-openai:
-    name: Validate 02-agents/providers/azure_openai
-    runs-on: ubuntu-latest
-    environment: integration
-    env:
-      AZURE_AI_PROJECT_ENDPOINT: ${{ vars.AZURE_AI_PROJECT_ENDPOINT }}
-      AZURE_OPENAI_ENDPOINT: ${{ vars.AZUREOPENAI__ENDPOINT }}
-      AZURE_OPENAI_CHAT_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__CHATDEPLOYMENTNAME }}
-      AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__RESPONSESDEPLOYMENTNAME }}
-    defaults:
-      run:
-        working-directory: python
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Setup environment
-        uses: ./.github/actions/sample-validation-setup
-        with:
-          azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
-          azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
-          azure-subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-          os: ${{ runner.os }}
-
-      - name: Create .env for samples
-        run: |
-          echo "AZURE_AI_PROJECT_ENDPOINT=$AZURE_AI_PROJECT_ENDPOINT" >> .env
-          echo "AZURE_OPENAI_ENDPOINT=$AZURE_OPENAI_ENDPOINT" >> .env
-          echo "AZURE_OPENAI_CHAT_DEPLOYMENT_NAME=$AZURE_OPENAI_CHAT_DEPLOYMENT_NAME" >> .env
-          echo "AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME=$AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME" >> .env
-
-      - name: Run sample validation
-        run: |
-          cd scripts && uv run python -m sample_validation --subdir 02-agents/providers/azure_openai --save-report --report-name 02-agents-azure-openai
-
-      - name: Upload validation report
-        uses: actions/upload-artifact@v7
-        if: always()
-        with:
-          name: validation-report-02-agents-azure-openai
-          path: python/samples/sample_validation/reports/
-
-  validate-02-agents-azure-ai:
-    name: Validate 02-agents/providers/azure_ai
-    runs-on: ubuntu-latest
-    environment: integration
-    env:
-      AZURE_AI_PROJECT_ENDPOINT: ${{ vars.AZURE_AI_PROJECT_ENDPOINT }}
-      AZURE_AI_MODEL_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__RESPONSESDEPLOYMENTNAME }}
-      AZURE_AI_CHAT_MODEL_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__CHATDEPLOYMENTNAME }}
-      AZURE_AI_EMBEDDING_MODEL_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__EMBEDDINGDEPLOYMENTNAME }}
-      BING_CONNECTION_ID: ${{ secrets.BING_CONNECTION_ID }}
-    defaults:
-      run:
-        working-directory: python
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Setup environment
-        uses: ./.github/actions/sample-validation-setup
-        with:
-          azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
-          azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
-          azure-subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-          os: ${{ runner.os }}
-
-      - name: Create .env for samples
-        run: |
-          echo "AZURE_AI_PROJECT_ENDPOINT=$AZURE_AI_PROJECT_ENDPOINT" >> .env
-          echo "AZURE_AI_MODEL_DEPLOYMENT_NAME=$AZURE_AI_MODEL_DEPLOYMENT_NAME" >> .env
-          echo "AZURE_AI_CHAT_MODEL_DEPLOYMENT_NAME=$AZURE_AI_CHAT_MODEL_DEPLOYMENT_NAME" >> .env
-          echo "AZURE_AI_EMBEDDING_MODEL_DEPLOYMENT_NAME=$AZURE_AI_EMBEDDING_MODEL_DEPLOYMENT_NAME" >> .env
-          echo "BING_CONNECTION_ID=$BING_CONNECTION_ID" >> .env
-
-      - name: Run sample validation
-        run: |
-          cd scripts && uv run python -m sample_validation --subdir 02-agents/providers/azure_ai --save-report --report-name 02-agents-azure-ai
-
-      - name: Upload validation report
-        uses: actions/upload-artifact@v7
-        if: always()
-        with:
-          name: validation-report-02-agents-azure-ai
-          path: python/samples/sample_validation/reports/
-
-  validate-02-agents-azure-ai-agent:
-    name: Validate 02-agents/providers/azure_ai_agent
-    runs-on: ubuntu-latest
-    environment: integration
-    env:
-      AZURE_AI_PROJECT_ENDPOINT: ${{ vars.AZURE_AI_PROJECT_ENDPOINT }}
-      AZURE_AI_MODEL_DEPLOYMENT_NAME: ${{ vars.AZUREOPENAI__RESPONSESDEPLOYMENTNAME }}
-    defaults:
-      run:
-        working-directory: python
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Setup environment
-        uses: ./.github/actions/sample-validation-setup
-        with:
-          azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
-          azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
-          azure-subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-          os: ${{ runner.os }}
-
-      - name: Create .env for samples
-        run: |
-          echo "AZURE_AI_PROJECT_ENDPOINT=$AZURE_AI_PROJECT_ENDPOINT" >> .env
-          echo "AZURE_AI_MODEL_DEPLOYMENT_NAME=$AZURE_AI_MODEL_DEPLOYMENT_NAME" >> .env
-
-      - name: Run sample validation
-        run: |
-          cd scripts && uv run python -m sample_validation --subdir 02-agents/providers/azure_ai_agent --save-report --report-name 02-agents-azure-ai-agent
-
-      - name: Upload validation report
-        uses: actions/upload-artifact@v7
-        if: always()
-        with:
-          name: validation-report-02-agents-azure-ai-agent
-          path: python/samples/sample_validation/reports/
-
-  validate-02-agents-anthropic:
-    name: Validate 02-agents/providers/anthropic
-    runs-on: ubuntu-latest
-    environment: integration
-    env:
-      ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-      ANTHROPIC_CHAT_MODEL_ID: ${{ vars.ANTHROPIC_CHAT_MODEL_ID }}
-    defaults:
-      run:
-        working-directory: python
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Setup environment
-        uses: ./.github/actions/sample-validation-setup
-        with:
-          azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
-          azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
-          azure-subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-          os: ${{ runner.os }}
-
-      - name: Create .env for samples
-        run: |
-          echo "ANTHROPIC_API_KEY=$ANTHROPIC_API_KEY" >> .env
-          echo "ANTHROPIC_CHAT_MODEL_ID=$ANTHROPIC_CHAT_MODEL_ID" >> .env
-
-      - name: Run sample validation
-        run: |
-          cd scripts && uv run python -m sample_validation --subdir 02-agents/providers/anthropic --save-report --report-name 02-agents-anthropic
-
-      - name: Upload validation report
-        uses: actions/upload-artifact@v7
-        if: always()
-        with:
-          name: validation-report-02-agents-anthropic
-          path: python/samples/sample_validation/reports/
-
-  validate-02-agents-github-copilot:
-    name: Validate 02-agents/providers/github_copilot
-    runs-on: ubuntu-latest
-    environment: integration
-    defaults:
-      run:
-        working-directory: python
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Setup environment
-        uses: ./.github/actions/sample-validation-setup
-        with:
-          azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
-          azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
-          azure-subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-          os: ${{ runner.os }}
-
-      - name: Run sample validation
-        run: |
-          cd scripts && uv run python -m sample_validation --subdir 02-agents/providers/github_copilot --save-report --report-name 02-agents-github-copilot
-
-      - name: Upload validation report
-        uses: actions/upload-artifact@v7
-        if: always()
-        with:
-          name: validation-report-02-agents-github-copilot
-          path: python/samples/sample_validation/reports/
-
-  validate-02-agents-amazon:
-    name: Validate 02-agents/providers/amazon
-    if: false # Temporarily disabled - requires AWS credentials
-    runs-on: ubuntu-latest
-    environment: integration
-    env:
-      BEDROCK_CHAT_MODEL_ID: ${{ vars.BEDROCK__CHATMODELID }}
-    defaults:
-      run:
-        working-directory: python
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Setup environment
-        uses: ./.github/actions/sample-validation-setup
-        with:
-          azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
-          azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
-          azure-subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-          os: ${{ runner.os }}
-
-      - name: Run sample validation
-        run: |
-          cd scripts && uv run python -m sample_validation --subdir 02-agents/providers/amazon --save-report --report-name 02-agents-amazon
-
-      - name: Upload validation report
-        uses: actions/upload-artifact@v7
-        if: always()
-        with:
-          name: validation-report-02-agents-amazon
-          path: python/samples/sample_validation/reports/
-
-  validate-02-agents-ollama:
-    name: Validate 02-agents/providers/ollama
-    if: false # Temporarily disabled - requires local Ollama server
-    runs-on: ubuntu-latest
-    environment: integration
-    env:
-      OLLAMA_MODEL: ${{ vars.OLLAMA__MODEL }}
-    defaults:
-      run:
-        working-directory: python
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Setup environment
-        uses: ./.github/actions/sample-validation-setup
-        with:
-          azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
-          azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
-          azure-subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-          os: ${{ runner.os }}
-
-      - name: Run sample validation
-        run: |
-          cd scripts && uv run python -m sample_validation --subdir 02-agents/providers/ollama --save-report --report-name 02-agents-ollama
-
-      - name: Upload validation report
-        uses: actions/upload-artifact@v7
-        if: always()
-        with:
-          name: validation-report-02-agents-ollama
-          path: python/samples/sample_validation/reports/
-
-  validate-02-agents-foundry-local:
-    name: Validate 02-agents/providers/foundry_local
-    if: false # Temporarily disabled - requires local Foundry setup
-    runs-on: ubuntu-latest
-    environment: integration
-    defaults:
-      run:
-        working-directory: python
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Setup environment
-        uses: ./.github/actions/sample-validation-setup
-        with:
-          azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
-          azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
-          azure-subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-          os: ${{ runner.os }}
-
-      - name: Run sample validation
-        run: |
-          cd scripts && uv run python -m sample_validation --subdir 02-agents/providers/foundry_local --save-report --report-name 02-agents-foundry-local
-
-      - name: Upload validation report
-        uses: actions/upload-artifact@v7
-        if: always()
-        with:
-          name: validation-report-02-agents-foundry-local
-          path: python/samples/sample_validation/reports/
-
-  validate-02-agents-copilotstudio:
-    name: Validate 02-agents/providers/copilotstudio
-    if: false # Temporarily disabled - requires Copilot Studio setup
-    runs-on: ubuntu-latest
-    environment: integration
-    env:
-      COPILOTSTUDIOAGENT__ENVIRONMENTID: ${{ secrets.COPILOTSTUDIOAGENT__ENVIRONMENTID }}
-      COPILOTSTUDIOAGENT__SCHEMANAME: ${{ secrets.COPILOTSTUDIOAGENT__SCHEMANAME }}
-      COPILOTSTUDIOAGENT__TENANTID: ${{ secrets.COPILOTSTUDIOAGENT__TENANTID }}
-      COPILOTSTUDIOAGENT__AGENTAPPID: ${{ secrets.COPILOTSTUDIOAGENT__AGENTAPPID }}
-    defaults:
-      run:
-        working-directory: python
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Setup environment
-        uses: ./.github/actions/sample-validation-setup
-        with:
-          azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
-          azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
-          azure-subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-          os: ${{ runner.os }}
-
-      - name: Create .env for samples
-        run: |
-          echo "COPILOTSTUDIOAGENT__ENVIRONMENTID=$COPILOTSTUDIOAGENT__ENVIRONMENTID" >> .env
-          echo "COPILOTSTUDIOAGENT__SCHEMANAME=$COPILOTSTUDIOAGENT__SCHEMANAME" >> .env
-          echo "COPILOTSTUDIOAGENT__TENANTID=$COPILOTSTUDIOAGENT__TENANTID" >> .env
-          echo "COPILOTSTUDIOAGENT__AGENTAPPID=$COPILOTSTUDIOAGENT__AGENTAPPID" >> .env
-
-      - name: Run sample validation
-        run: |
-          cd scripts && uv run python -m sample_validation --subdir 02-agents/providers/copilotstudio --save-report --report-name 02-agents-copilotstudio
-
-      - name: Upload validation report
-        uses: actions/upload-artifact@v7
-        if: always()
-        with:
-          name: validation-report-02-agents-copilotstudio
-          path: python/samples/sample_validation/reports/
-
-  validate-02-agents-custom:
-    name: Validate 02-agents/providers/custom
-    runs-on: ubuntu-latest
-    environment: integration
-    defaults:
-      run:
-        working-directory: python
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Setup environment
-        uses: ./.github/actions/sample-validation-setup
-        with:
-          azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
-          azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
-          azure-subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-          os: ${{ runner.os }}
-
-      - name: Run sample validation
-        run: |
-          cd scripts && uv run python -m sample_validation --subdir 02-agents/providers/custom --save-report --report-name 02-agents-custom
-
-      - name: Upload validation report
-        uses: actions/upload-artifact@v7
-        if: always()
-        with:
-          name: validation-report-02-agents-custom
-          path: python/samples/sample_validation/reports/
+          path: python/scripts/sample_validation/reports/
 
   validate-03-workflows:
     name: Validate 03-workflows
@@ -536,14 +121,6 @@ jobs:
           azure-subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
           os: ${{ runner.os }}
 
-      - name: Create .env for samples
-        run: |
-          echo "AZURE_AI_PROJECT_ENDPOINT=$AZURE_AI_PROJECT_ENDPOINT" >> .env
-          echo "AZURE_AI_MODEL_DEPLOYMENT_NAME=$AZURE_AI_MODEL_DEPLOYMENT_NAME" >> .env
-          echo "AZURE_OPENAI_ENDPOINT=$AZURE_OPENAI_ENDPOINT" >> .env
-          echo "AZURE_OPENAI_CHAT_DEPLOYMENT_NAME=$AZURE_OPENAI_CHAT_DEPLOYMENT_NAME" >> .env
-          echo "AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME=$AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME" >> .env
-
       - name: Run sample validation
         run: |
           cd scripts && uv run python -m sample_validation --subdir 03-workflows --save-report --report-name 03-workflows
@@ -553,11 +130,11 @@ jobs:
         if: always()
         with:
           name: validation-report-03-workflows
-          path: python/samples/sample_validation/reports/
+          path: python/scripts/sample_validation/reports/
 
   validate-04-hosting:
     name: Validate 04-hosting
-    if: false # Temporarily disabled because of sample complexity
+    if: false  # Temporarily disabled because of sample complexity
     runs-on: ubuntu-latest
     environment: integration
     env:
@@ -592,11 +169,11 @@ jobs:
         if: always()
         with:
           name: validation-report-04-hosting
-          path: python/samples/sample_validation/reports/
+          path: python/scripts/sample_validation/reports/
 
   validate-05-end-to-end:
     name: Validate 05-end-to-end
-    if: false # Temporarily disabled because of sample complexity
+    if: false  # Temporarily disabled because of sample complexity
     runs-on: ubuntu-latest
     environment: integration
     env:
@@ -636,7 +213,7 @@ jobs:
         if: always()
         with:
           name: validation-report-05-end-to-end
-          path: python/samples/sample_validation/reports/
+          path: python/scripts/sample_validation/reports/
 
   validate-autogen-migration:
     name: Validate autogen-migration
@@ -653,7 +230,6 @@ jobs:
       OPENAI_API_KEY: ${{ secrets.OPENAI__APIKEY }}
       OPENAI_CHAT_MODEL_ID: ${{ vars.OPENAI__CHATMODELID }}
       OPENAI_RESPONSES_MODEL_ID: ${{ vars.OPENAI__RESPONSESMODELID }}
-      OPENAI_MODEL: ${{ vars.OPENAI__RESPONSESMODELID }}
     defaults:
       run:
         working-directory: python
@@ -668,16 +244,6 @@ jobs:
           azure-subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
           os: ${{ runner.os }}
 
-      - name: Create .env for samples
-        run: |
-          echo "AZURE_AI_PROJECT_ENDPOINT=$AZURE_AI_PROJECT_ENDPOINT" >> .env
-          echo "AZURE_AI_MODEL_DEPLOYMENT_NAME=$AZURE_AI_MODEL_DEPLOYMENT_NAME" >> .env
-          echo "AZURE_OPENAI_ENDPOINT=$AZURE_OPENAI_ENDPOINT" >> .env
-          echo "AZURE_OPENAI_CHAT_DEPLOYMENT_NAME=$AZURE_OPENAI_CHAT_DEPLOYMENT_NAME" >> .env
-          echo "OPENAI_API_KEY=$OPENAI_API_KEY" >> .env
-          echo "OPENAI_CHAT_MODEL_ID=$OPENAI_CHAT_MODEL_ID" >> .env
-          echo "OPENAI_RESPONSES_MODEL_ID=$OPENAI_RESPONSES_MODEL_ID" >> .env
-
       - name: Run sample validation
         run: |
           cd scripts && uv run python -m sample_validation --subdir autogen-migration --save-report --report-name autogen-migration
@@ -687,7 +253,7 @@ jobs:
         if: always()
         with:
           name: validation-report-autogen-migration
-          path: python/samples/sample_validation/reports/
+          path: python/scripts/sample_validation/reports/
 
   validate-semantic-kernel-migration:
     name: Validate semantic-kernel-migration
@@ -705,7 +271,6 @@ jobs:
       OPENAI_API_KEY: ${{ secrets.OPENAI__APIKEY }}
       OPENAI_CHAT_MODEL_ID: ${{ vars.OPENAI__CHATMODELID }}
       OPENAI_RESPONSES_MODEL_ID: ${{ vars.OPENAI__RESPONSESMODELID }}
-      OPENAI_MODEL: ${{ vars.OPENAI__RESPONSESMODELID }}
       # Copilot Studio
       COPILOTSTUDIOAGENT__ENVIRONMENTID: ${{ secrets.COPILOTSTUDIOAGENT__ENVIRONMENTID }}
       COPILOTSTUDIOAGENT__SCHEMANAME: ${{ secrets.COPILOTSTUDIOAGENT__SCHEMANAME }}
@@ -725,21 +290,6 @@ jobs:
           azure-subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
           os: ${{ runner.os }}
 
-      - name: Create .env for samples
-        run: |
-          echo "AZURE_AI_PROJECT_ENDPOINT=$AZURE_AI_PROJECT_ENDPOINT" >> .env
-          echo "AZURE_AI_MODEL_DEPLOYMENT_NAME=$AZURE_AI_MODEL_DEPLOYMENT_NAME" >> .env
-          echo "AZURE_OPENAI_ENDPOINT=$AZURE_OPENAI_ENDPOINT" >> .env
-          echo "AZURE_OPENAI_CHAT_DEPLOYMENT_NAME=$AZURE_OPENAI_CHAT_DEPLOYMENT_NAME" >> .env
-          echo "AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME=$AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME" >> .env
-          echo "OPENAI_API_KEY=$OPENAI_API_KEY" >> .env
-          echo "OPENAI_CHAT_MODEL_ID=$OPENAI_CHAT_MODEL_ID" >> .env
-          echo "OPENAI_RESPONSES_MODEL_ID=$OPENAI_RESPONSES_MODEL_ID" >> .env
-          echo "COPILOTSTUDIOAGENT__ENVIRONMENTID=$COPILOTSTUDIOAGENT__ENVIRONMENTID" >> .env
-          echo "COPILOTSTUDIOAGENT__SCHEMANAME=$COPILOTSTUDIOAGENT__SCHEMANAME" >> .env
-          echo "COPILOTSTUDIOAGENT__TENANTID=$COPILOTSTUDIOAGENT__TENANTID" >> .env
-          echo "COPILOTSTUDIOAGENT__AGENTAPPID=$COPILOTSTUDIOAGENT__AGENTAPPID" >> .env
-
       - name: Run sample validation
         run: |
           cd scripts && uv run python -m sample_validation --subdir semantic-kernel-migration --save-report --report-name semantic-kernel-migration
@@ -749,69 +299,4 @@ jobs:
         if: always()
         with:
           name: validation-report-semantic-kernel-migration
-          path: python/samples/sample_validation/reports/
-
-  aggregate-results:
-    name: Aggregate Results
-    runs-on: ubuntu-latest
-    if: always()
-    needs:
-      - validate-01-get-started
-      - validate-02-agents
-      - validate-02-agents-openai
-      - validate-02-agents-azure-openai
-      - validate-02-agents-azure-ai
-      - validate-02-agents-azure-ai-agent
-      - validate-02-agents-anthropic
-      - validate-02-agents-github-copilot
-      - validate-02-agents-amazon
-      - validate-02-agents-ollama
-      - validate-02-agents-foundry-local
-      - validate-02-agents-copilotstudio
-      - validate-02-agents-custom
-      - validate-03-workflows
-      - validate-04-hosting
-      - validate-05-end-to-end
-      - validate-autogen-migration
-      - validate-semantic-kernel-migration
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Download all validation reports
-        uses: actions/download-artifact@v7
-        with:
-          pattern: validation-report-*
-          path: reports/
-          merge-multiple: true
-
-      - name: Restore validation history
-        id: cache-restore
-        uses: actions/cache/restore@v4
-        with:
-          path: validation-history/
-          key: validation-history-${{ github.run_id }}
-          restore-keys: |
-            validation-history-
-
-      - name: Aggregate results and generate trend report
-        run: |
-          python3 python/scripts/sample_validation/aggregate.py \
-            reports/ \
-            validation-history/history.json \
-            trend-report.md
-
-      - name: Write trend report to job summary
-        run: cat trend-report.md >> "$GITHUB_STEP_SUMMARY"
-
-      - name: Save validation history
-        uses: actions/cache/save@v4
-        with:
-          path: validation-history/
-          key: validation-history-${{ github.run_id }}
-
-      - name: Upload trend report
-        uses: actions/upload-artifact@v7
-        if: always()
-        with:
-          name: validation-trend-report
-          path: trend-report.md
+          path: python/scripts/sample_validation/reports/

.github/workflows/python-test-coverage-report.yml

@@ -21,7 +21,7 @@ jobs:
     steps:
       - uses: actions/checkout@v6
       - name: Download coverage report
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v7
         with:
           github-token: ${{ secrets.GH_ACTIONS_PR_WRITE }}
           run-id: ${{ github.event.workflow_run.id }}

.github/workflows/stale-issue-pr-ping.yml

@@ -1,49 +0,0 @@
-name: Stale issue and PR ping
-
-on:
-  schedule:
-    - cron: '0 0 * * *'  # Midnight UTC daily
-  workflow_dispatch:
-    inputs:
-      days_threshold:
-        description: 'Days of silence before pinging the author'
-        required: false
-        default: '4'
-      dry_run:
-        description: 'Log what would be pinged without taking action'
-        required: false
-        default: 'false'
-        type: choice
-        options:
-          - 'false'
-          - 'true'
-
-concurrency:
-  group: stale-issue-pr-ping
-  cancel-in-progress: true
-
-jobs:
-  ping_stale:
-    name: "Ping stale issues and PRs"
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      issues: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v6
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.13'
-
-      - name: Install dependencies
-        run: pip install PyGithub==2.6.0
-
-      - name: Run stale issue/PR ping
-        run: python .github/scripts/stale_issue_pr_ping.py
-        env:
-          GITHUB_TOKEN: ${{ secrets.GH_ACTIONS_PR_WRITE }}
-          TEAM_SLUG: ${{ secrets.DEVELOPER_TEAM }}
-          DAYS_THRESHOLD: ${{ github.event.inputs.days_threshold || '4' }}
-          DRY_RUN: ${{ github.event.inputs.dry_run || 'false' }}

docs/decisions/0020-foundry-evals-integration.md

@@ -1,815 +0,0 @@
----
-status: accepted
-contact: bentho
-date: 2026-02-27
-deciders: bentho, markwallace-microsoft, westey-m
-consulted: Pratyush Mishra, Shivam Shrivastava, Manni Arora (Centrica eval scenario)
-informed: Agent Framework team, Foundry Evals team
----
-
-# Agent Evaluation Architecture with Azure AI Foundry Integration
-
-## Context and Problem Statement
-
-Azure AI Foundry provides a rich evaluation service for AI agents — built-in evaluators for agent behavior (task adherence, intent resolution), tool usage (tool call accuracy, tool selection), quality (coherence, fluency, relevance), and safety (violence, self-harm, prohibited actions). Results are viewable in the Foundry portal with dashboards and comparison views.
-
-However, using Foundry Evals with an agent-framework agent today requires significant manual effort. Developers must:
-
-1. Transform agent-framework's `Message`/`Content` types into the OpenAI-style agent message schema that Foundry evaluators expect
-2. Map tool definitions from agent-framework's `FunctionTool` format to evaluator-compatible schemas
-3. Manually wire up the correct Foundry data source type (`azure_ai_traces`, `jsonl`, `azure_ai_target_completions`, etc.) depending on their scenario
-4. Handle App Insights trace ID queries, response ID collection, and eval polling
-
-Additionally, evaluation is a concern that extends beyond any single provider. Developers may want to use local evaluators (LLM-as-judge, regex, keyword matching), third-party evaluation libraries, or multiple providers in combination. The architecture must support this without creating a Foundry-specific lock-in at the API level.
-
-### Functional Requirements for Agent Evaluation
-
-- **Single agents and workflows.** Evaluate both individual agent responses and multi-agent workflow results, with per-agent breakdown to pinpoint underperformance.
-- **One-shot and multi-turn conversations.** Capture full conversation trajectories — including tool calls and results — not just final query/response pairs.
-- **Conversation factoring.** Support splitting conversations into query/response in multiple ways (last turn, full trajectory, per-turn) because different factorings measure different things.
-- **Multiple providers, mix and match.** Run Foundry LLM-as-judge evaluators alongside fast local checks and custom evaluators on the same data, without restructuring code.
-- **Third-party extensibility.** Any evaluation library can participate by implementing the `Evaluator` protocol (Python) or `IAgentEvaluator` interface (.NET). No predetermined list of supported libraries — the protocol is intentionally simple (`evaluate(items) → results`) so that wrappers for libraries like DeepEval, RAGAS, or Promptfoo are straightforward to write.
-- **Bring your own evaluator.** Creating a custom evaluator should be as simple as writing a function.
-- **Evaluate without re-running.** Evaluate existing responses from logs or previous runs without invoking the agent again.
-
-## Decision Drivers
-
-- **Zero-friction evaluation**: Developers should go from "I have an agent" to "I have eval results" with minimal code.
-- **Provider-agnostic API**: Core evaluation capabilities must not be tied to any specific provider. Provider configuration should be separate from the evaluation call.
-- **Lowest concept count**: Introduce the fewest possible new types, abstractions, and APIs for developers to learn.
-- **Leverage existing knowledge**: The framework already knows which agents exist, what tools they have, and what conversations occurred. Evals should use this automatically rather than requiring the developer to re-specify it.
-- **Foundry-native results**: When using Foundry, results should be viewable in the Foundry portal with dashboards and comparison views.
-- **Progressive disclosure**: Simple scenarios should be near-zero code. Advanced scenarios should build on the same primitives.
-- **Cross-language parity**: Design must be implementable in both Python and .NET.
-
-## Considered Options
-
-1. **Provider-specific functions** — Build Foundry-specific helper functions (`evaluate_agent()`, etc.) directly in the Azure package. All eval functions take Foundry connection parameters.
-2. **Evaluator protocol with shared orchestration** — Define a provider-agnostic `Evaluator` protocol in the base agent library (`agent_framework` in Python, `Microsoft.Agents.AI` in .NET). Orchestration functions live alongside it. Providers implement the protocol.
-3. **Full eval framework** — Build comprehensive eval infrastructure including custom evaluator definitions, scoring profiles, and reporting inside agent-framework.
-
-## Decision Outcome
-
-Proposed option: "Evaluator protocol with shared orchestration", because it delivers the low-friction developer experience, supports multiple providers without API changes, and keeps the concept count low.
-
-### Usage Examples
-
-#### Evaluate an agent
-
-The agent is invoked once per query by default. For statistically meaningful evaluation, provide multiple diverse queries. For measuring **consistency** (does the same query produce reliable results?), use `num_repetitions` to run each query N times independently:
-
-**Python:**
-
-```python
-evals = FoundryEvals(
-    project_client=client,
-    model_deployment="gpt-4o",
-    evaluators=[FoundryEvals.RELEVANCE, FoundryEvals.COHERENCE],
-)
-
-results = await evaluate_agent(
-    agent=my_agent,
-    queries=[
-        "What's the weather in Seattle?",
-        "Plan a weekend trip to Portland",
-        "What restaurants are near Pike Place?",
-    ],
-    evaluators=evals,
-)
-for r in results:
-    r.assert_passed()
-```
-
-**C#:**
-
-```csharp
-var evals = new FoundryEvals(chatConfiguration, FoundryEvals.Relevance, FoundryEvals.Coherence);
-
-AgentEvaluationResults results = await agent.EvaluateAsync(
-    new[] {
-        "What's the weather in Seattle?",
-        "Plan a weekend trip to Portland",
-        "What restaurants are near Pike Place?",
-    },
-    evals);
-
-results.AssertAllPassed();
-```
-
-`evaluate_agent` returns one `EvalResults` per evaluator. Each result contains per-item scores with the evaluated response for auditing:
-
-```
-# results[0] (FoundryEvals)
-EvalResults(status="completed", passed=3, failed=0, total=3)
-  items[0]: EvalItemResult(
-    query="What's the weather in Seattle?",
-    response="It's currently 72°F and sunny in Seattle.",
-    scores={"relevance": 5, "coherence": 5})
-  items[1]: EvalItemResult(
-    query="Plan a weekend trip to Portland",
-    response="Here's a 2-day Portland itinerary...",
-    scores={"relevance": 4, "coherence": 5})
-  items[2]: EvalItemResult(
-    query="What restaurants are near Pike Place?",
-    response="Top restaurants near Pike Place Market: ...",
-    scores={"relevance": 5, "coherence": 4})
-```
-
-#### Measure consistency with repetitions
-
-Run each query multiple times to detect non-deterministic behavior:
-
-**Python:**
-
-```python
-results = await evaluate_agent(
-    agent=my_agent,
-    queries=["What's the weather in Seattle?"],
-    evaluators=evals,
-    num_repetitions=3,  # each query runs 3 times independently
-)
-# results contain 3 items (1 query × 3 repetitions)
-```
-
-**C#:**
-
-```csharp
-AgentEvaluationResults results = await agent.EvaluateAsync(
-    new[] { "What's the weather in Seattle?" },
-    evals,
-    numRepetitions: 3);  // each query runs 3 times independently
-// results contain 3 items (1 query × 3 repetitions)
-```
-
-#### Evaluate a response you already have
-
-When you already have agent responses, pass them directly to skip re-running the agent. Each query is paired with its corresponding response:
-
-**Python:**
-
-```python
-queries = ["What's the weather?", "What's the capital of France?"]
-responses = [await agent.run([Message("user", [q])]) for q in queries]
-
-results = await evaluate_agent(
-    responses=responses,
-    evaluators=evals,
-)
-```
-
-**C#:**
-
-```csharp
-var queries = new[] { "What's the weather?" };
-var responses = new List<AgentResponse>();
-foreach (var q in queries)
-    responses.Add(await agent.RunAsync(new[] { new ChatMessage(ChatRole.User, q) }));
-
-AgentEvaluationResults results = await agent.EvaluateAsync(
-    responses: responses,
-    evals);
-```
-
-Each `AgentResponse` already contains the conversation (query + response), so the evaluator extracts query/response from the conversation. When you pass `responses` without `queries`, the conversation is the source of truth.
-
-#### Evaluate with conversation split strategies
-
-By default, evaluators see only the last turn (final user message → final assistant response). For multi-turn conversations, you can control how the conversation is factored for evaluation:
-
-**Python:**
-
-```python
-results = await evaluate_agent(
-    agent=agent,
-    queries=["Plan a 3-day trip to Paris"],
-    evaluators=evals,
-    conversation_split=ConversationSplit.FULL,      # evaluate entire trajectory
-)
-
-# Or per-turn: each user→assistant exchange scored independently
-results = await evaluate_agent(
-    agent=agent,
-    queries=["Plan a 3-day trip to Paris"],
-    evaluators=evals,
-    conversation_split=ConversationSplit.PER_TURN,
-)
-```
-
-**C#:**
-
-```csharp
-// Full conversation as context
-AgentEvaluationResults results = await agent.EvaluateAsync(
-    new[] { "Plan a 3-day trip to Paris" },
-    evals,
-    splitter: ConversationSplitters.Full);
-
-// Per-turn splitting
-var items = EvalItem.PerTurnItems(conversation);  // one EvalItem per user turn
-var results = await evals.EvaluateAsync(items);
-```
-
-With `PER_TURN`, a 3-turn conversation produces 3 scored items:
-
-```
-EvalResults(status="completed", passed=3, failed=0, total=3)
-  items[0]: query="Plan a 3-day trip to Paris"    scores={"relevance": 5}
-  items[1]: query="What about restaurants?"        scores={"relevance": 4}
-  items[2]: query="Make it budget-friendly"        scores={"relevance": 5}
-```
-
-#### Evaluate a multi-agent workflow
-
-**Python:**
-
-```python
-result = await workflow.run("Plan a trip to Paris")
-eval_results = await evaluate_workflow(
-    workflow=workflow,
-    workflow_result=result,
-    evaluators=evals,
-)
-
-for r in eval_results:
-    print(f"  overall: {r.passed}/{r.total}")
-    for name, sub in r.sub_results.items():
-        print(f"    {name}: {sub.passed}/{sub.total}")
-```
-
-**C#:**
-
-```csharp
-WorkflowRunResult result = await workflow.RunAsync("Plan a trip to Paris");
-
-IReadOnlyList<AgentEvaluationResults> evalResults = await result.EvaluateAsync(evals);
-
-foreach (var r in evalResults)
-{
-    Console.WriteLine($"  overall: {r.Passed}/{r.Total}");
-    foreach (var (name, sub) in r.SubResults)
-        Console.WriteLine($"    {name}: {sub.Passed}/{sub.Total}");
-}
-```
-
-Workflows return one result per evaluator, with sub-results per agent in the workflow:
-
-```
-EvalResults(status="completed", passed=2, failed=0, total=2)
-  sub_results:
-    "planner":  EvalResults(passed=1, total=1)
-    "researcher": EvalResults(passed=1, total=1)
-```
-
-#### Mix multiple providers
-
-**Python:**
-
-```python
-@evaluator
-def is_helpful(response: str) -> bool:
-    return len(response.split()) > 10
-
-foundry = FoundryEvals(
-    project_client=client,
-    model_deployment="gpt-4o",
-    evaluators=[FoundryEvals.RELEVANCE, FoundryEvals.COHERENCE],
-)
-
-results = await evaluate_agent(
-    agent=agent,
-    queries=queries,
-    evaluators=[is_helpful, keyword_check("weather"), foundry],
-)
-```
-
-**C#:**
-
-```csharp
-IReadOnlyList<AgentEvaluationResults> results = await agent.EvaluateAsync(
-    queries,
-    evaluators: new IAgentEvaluator[]
-    {
-        new LocalEvaluator(
-            EvalChecks.KeywordCheck("weather"),
-            FunctionEvaluator.Create("is_helpful", (string r) => r.Split(' ').Length > 10)),
-        new FoundryEvals(chatConfiguration, FoundryEvals.Relevance, FoundryEvals.Coherence),
-    });
-```
-
-Multiple evaluators return one result each — `results[0]` is the local evaluator, `results[1]` is Foundry.
-
-#### Custom function evaluators
-
-**Python:**
-
-```python
-@evaluator
-def mentions_city(response: str, expected_output: str) -> bool:
-    return expected_output.lower() in response.lower()
-
-@evaluator
-def used_tools(conversation: list, tools: list) -> float:
-    # ... scoring logic
-    return score
-
-local = LocalEvaluator(mentions_city, used_tools)
-```
-
-`@evaluator` uses **parameter name injection** — the function's parameter names determine what data it receives from the `EvalItem`. Supported names: `query`, `response`, `expected`, `expected_tool_calls`, `conversation`, `tools`, `context`. Any combination is valid.
-
-**C#:**
-
-```csharp
-var local = new LocalEvaluator(
-    FunctionEvaluator.Create("mentions_city",
-        (EvalItem item) => item.ExpectedOutput != null
-            && item.Response.Contains(item.ExpectedOutput, StringComparison.OrdinalIgnoreCase)),
-    FunctionEvaluator.Create("is_concise",
-        (string response) => response.Split(' ').Length < 500));
-```
-
-## What To Build
-
-### Core: Evaluator Protocol
-
-A runtime-checkable protocol that any evaluation provider implements:
-
-```python
-@runtime_checkable
-class Evaluator(Protocol):
-    name: str
-
-    async def evaluate(
-        self, items: Sequence[EvalItem], *, eval_name: str = "Agent Framework Eval"
-    ) -> EvalResults: ...
-```
-
-The protocol is minimal — just `name` and `evaluate()`.
-
-### Core: EvalItem
-
-Provider-agnostic data format for items to evaluate:
-
-```python
-@dataclass
-class ExpectedToolCall:
-    name: str                                    # Tool/function name
-    arguments: dict[str, Any] | None = None      # None = don't check args
-
-@dataclass
-class EvalItem:
-    conversation: list[Message]               # Single source of truth
-    tools: list[FunctionTool] | None = None   # Agent's available tools
-    context: str | None = None
-    expected_output: str | None = None          # Ground-truth for comparison
-    expected_tool_calls: list[ExpectedToolCall] | None = None
-    split_strategy: ConversationSplitter | None = None
-
-    query: str       # property — derived from conversation split
-    response: str    # property — derived from conversation split
-```
-
-`conversation` is the single source of truth. `query` and `response` are derived properties — splitting the conversation at the last user message (default) and extracting text from each side. Changing the `split_strategy` consistently changes all derived values.
-
-`tools` provides typed `FunctionTool` objects — including MCP tools, which are automatically extracted after agent runs.
-
-### Internal: AgentEvalConverter
-
-Internal class that converts agent-framework types to `EvalItem`. Used by `evaluate_agent()` and `evaluate_workflow()` — not part of the public API:
-
-| Agent Framework | Eval Format |
-|---|---|
-| `Content.function_call` | `tool_call` in OpenAI chat format |
-| `Content.function_result` | `tool_result` in OpenAI chat format |
-| `FunctionTool` | `{name, description, parameters}` schema |
-| `Message` history | `conversation` list + `query`/`response` extraction |
-
-### Core: EvalResults
-
-Rich result type with convenience properties for CI integration:
-
-```python
-results.all_passed          # bool: no failures or errors (recursive for workflow)
-results.passed              # int: passing count
-results.failed              # int: failure count
-results.total               # int: total = passed + failed + errored
-results.items               # list[EvalItemResult]: per-item detail with query, response, and scores
-results.error               # str | None: error details on failure
-results.sub_results         # dict: per-agent breakdown (workflow evals)
-results.report_url          # str | None: portal link (Foundry)
-results.assert_passed()     # raises AssertionError with details
-```
-
-### Core: Orchestration Functions
-
-Provider-agnostic functions that extract data and delegate to evaluators:
-
-| Function | What it does |
-|---|---|
-| `evaluate_agent()` | Runs agent against test queries (or evaluates pre-existing `responses=`), converts to `EvalItem`s, passes to evaluator. Accepts optional `expected_output=` for ground-truth comparison, `expected_tool_calls=` for tool-correctness evaluation, and `num_repetitions=` for consistency measurement |
-| `evaluate_workflow()` | Extracts per-agent data from `WorkflowRunResult`, evaluates each agent and overall output. Per-agent breakdown in `sub_results`. Also accepts `num_repetitions=` |
-
-### Core: Conversation Split Strategies
-
-Multi-turn conversations must be split into query (input) and response (output) halves for evaluation. How you split determines *what you're evaluating*:
-
-**Last-turn split** — split at the last user message. Everything up to and including it is the query context; the agent's subsequent actions are the response:
-
-```
-conversation: user1 → assistant1 → user2 → assistant2(tool) → tool_result → assistant3
-query_messages:    [user1, assistant1, user2]
-response_messages: [assistant2(tool), tool_result, assistant3]
-```
-
-This evaluates: "Given all the context so far, did the agent answer the latest question well?" Best for response quality at a specific point in the conversation.
-
-**Full-conversation split** — the first user message is the query; everything after is the response:
-
-```
-query_messages:    [user1]
-response_messages: [assistant1, user2, assistant2(tool), tool_result, assistant3]
-```
-
-This evaluates: "Given the original request, did the entire conversation trajectory serve the user?" Best for task completion and overall conversation quality.
-
-**Per-turn split** — produces N eval items from an N-turn conversation. Each turn is evaluated with its cumulative context:
-
-```
-item 1: query = [user1],                        response = [assistant1]
-item 2: query = [user1, assistant1, user2],      response = [assistant2(tool), tool_result, assistant3]
-```
-
-This evaluates each response independently. Best for fine-grained analysis and pinpointing where a conversation goes wrong.
-
-These factorings produce different scores for the same conversation. The framework ships all three as built-in strategies, defaulting to last-turn. Developers can also provide a custom splitter — a function (Python) or `IConversationSplitter` implementation (.NET) — and override the strategy at the call site or per evaluator.
-
-### Azure AI: FoundryEvals
-
-`Evaluator` implementation backed by Azure AI Foundry:
-
-```python
-class FoundryEvals:
-    def __init__(self, *, project_client=None, openai_client=None,
-                 model_deployment: str, evaluators=None, ...)
-    async def evaluate(self, items, *, eval_name) -> EvalResults
-```
-
-**Smart auto-detection in `evaluate()`:**
-- Default evaluators: relevance, coherence, task_adherence
-- Auto-adds `tool_call_accuracy` when items have tools/`tool_definitions`
-- Filters out tool evaluators for items without tools
-
-### Azure AI: FoundryEvals Constants
-
-```python
-from agent_framework_azure_ai import FoundryEvals
-
-evaluators = [FoundryEvals.RELEVANCE, FoundryEvals.TOOL_CALL_ACCURACY]
-```
-
-Categories: Agent behavior, Tool usage, Quality, Safety.
-
-### Azure AI: Foundry-Specific Functions
-
-| Function | What it does |
-|---|---|
-| `evaluate_traces()` | Evaluate from stored response IDs or OTel traces |
-| `evaluate_foundry_target()` | Evaluate a Foundry-registered agent or deployment |
-
-### Core: LocalEvaluator and Function Evaluators
-
-`LocalEvaluator` implements the `Evaluator` protocol for fast, API-free evaluation. It runs check functions locally — useful for inner-loop development, CI smoke tests, and combining with cloud-based evaluators.
-
-Built-in checks:
-- `keyword_check(*keywords)` — response must contain specified keywords
-- `tool_called_check(*tool_names)` — agent must have called specified tools
-- `tool_calls_present` — all `expected_tool_calls` names appear in conversation (unordered, extras OK)
-- `tool_call_args_match` — expected tool calls match on name + arguments (subset match on args)
-
-Custom function evaluators use `@evaluator` to wrap plain Python functions. The function's **parameter names** determine what data it receives from the `EvalItem`:
-
-```python
-from agent_framework import evaluator, LocalEvaluator
-
-# Tier 1: Simple check — just query + response
-@evaluator
-def is_concise(response: str) -> bool:
-    return len(response.split()) < 500
-
-# Tier 2: Ground truth — compare against expected output
-@evaluator
-def mentions_city(response: str, expected_output: str) -> bool:
-    return expected_output.lower() in response.lower()
-
-# Tier 3: Full context — inspect conversation and tools
-@evaluator
-def used_tools(conversation: list, tools: list) -> float:
-    # ... scoring logic
-    return score
-
-local = LocalEvaluator(is_concise, mentions_city, used_tools)
-```
-
-Supported parameters: `query`, `response`, `expected`, `expected_tool_calls`, `conversation`, `tools`, `context`.
-Return types: `bool`, `float` (≥0.5 = pass), `dict` with `score` or `passed` key, or `CheckResult`.
-
-Async functions are handled automatically — `@evaluator` detects `async def` and produces the right wrapper.
-
-### Example: GAIA Benchmark
-
-[GAIA](https://huggingface.co/gaia-benchmark) tests real-world multi-step tasks with known expected answers. Each task has a question and a ground-truth answer, with optional file attachments. The framework accommodates GAIA's knobs (difficulty levels, file inputs, multi-step tool use) through the existing `EvalItem` fields:
-
-```python
-from datasets import load_dataset
-from agent_framework import evaluate_agent, evaluator, LocalEvaluator
-
-gaia = load_dataset("gaia-benchmark/GAIA", "2023_level1", split="test")
-
-@evaluator
-def exact_match(response: str, expected_output: str) -> bool:
-    return expected_output.strip().lower() in response.strip().lower()
-
-# Simple path — evaluate_agent handles running + expected_output stamping
-results = await evaluate_agent(
-    agent=agent,
-    queries=[task["Question"] for task in gaia],
-    expected_output=[task["Final answer"] for task in gaia],
-    evaluators=LocalEvaluator(exact_match),
-)
-```
-
-### Package Location
-
-- Core types and orchestration: `agent_framework._eval`, `agent_framework._local_eval` (Python), `Microsoft.Agents.AI` (.NET)
-- Foundry provider: `agent_framework_azure_ai._foundry_evals` (Python), `Microsoft.Agents.AI.AzureAI` (.NET)
-- Azure-AI re-exports core types for convenience (Python)
-
-## Known Limitations
-
-1. **Tool evaluators require query + agent**: Tool evaluators need tool definition schemas. When using these evaluators with `evaluate_agent(responses=...)`, provide `queries=` and pass an agent with tool definitions.
-2. **`model_deployment` always required**: Could potentially be inferred from the Foundry project configuration.
-
-## Open Questions
-
-1. **Red teaming non-registered agents**: Requires Foundry API support for callback-based flows.
-2. **Datasets with expected outputs**: A dataset abstraction for pre-populating `expected_output` values across eval runs is a natural next step but not yet designed.
-3. **Multi-modal evaluation**: The `conversation` field on `EvalItem` already stores full `Message`/`Content` (Python) and `ChatMessage` (.NET) objects, which can represent multi-modal content (images, audio, structured data). Evaluators that accept the full `EvalItem` or `conversation` parameter can access this content today. However, the convenience shortcuts — `query`/`response` string projections and the `FunctionEvaluator` string overloads — are text-only. Multi-modal-aware evaluators should use the full-item path (`Func<EvalItem, CheckResult>` in .NET, `conversation: list` parameter in Python).
-
-## .NET Implementation Design
-
-### Key Difference: MEAI Ecosystem
-
-Unlike Python, the .NET ecosystem already has `Microsoft.Extensions.AI.Evaluation` (v10.3.0) providing:
-
-- `IEvaluator` — per-item evaluation of `(messages, chatResponse) → EvaluationResult`
-- `CompositeEvaluator` — combines multiple evaluators
-- Quality evaluators — `RelevanceEvaluator`, `CoherenceEvaluator`, `GroundednessEvaluator`
-- Safety evaluators — `ContentHarmEvaluator`, `ProtectedMaterialEvaluator`
-- Metric types — `NumericMetric`, `BooleanMetric`, `StringMetric`
-
-The .NET integration uses MEAI's `IEvaluator` directly — no new evaluator interface. Our contribution is the **orchestration layer**: extension methods that run agents, extract data, call `IEvaluator` per item, and aggregate results.
-
-### Architecture
-
-```
-┌──────────────────────────────────────────────────────────────┐
-│  Developer Code                                              │
-│  agent.EvaluateAsync(queries, evaluator)                     │
-│  run.EvaluateAsync(evaluator)                                │
-└────────────────┬─────────────────────────────────────────────┘
-                 │
-┌────────────────▼─────────────────────────────────────────────┐
-│  Orchestration Layer (Microsoft.Agents.AI)                   │
-│  AgentEvaluationExtensions — runs agents, extracts data,     │
-│  calls IEvaluator per item, aggregates into                  │
-│  AgentEvaluationResults                                      │
-└────────────────┬─────────────────────────────────────────────┘
-                 │ IEvaluator (MEAI)
-                 │
-     ┌───────────┼────────────┐
-     │           │            │
- ┌───▼───-┐  ┌───▼────┐  ┌────▼──────────┐
- │ MEAI   │  │ Local  │  │ Foundry       │
- │ Quality│  │ Checks │  │ (cloud batch) │
- │ Safety │  │ Lambdas│  │               │
- └────────┘  └────────┘  └───────────────┘
-```
-
-All evaluators implement MEAI's `IEvaluator`. The orchestration layer doesn't need to know which kind — it calls `EvaluateAsync(messages, chatResponse)` per item on all of them. `FoundryEvals` handles batching internally (buffers items, submits once, returns per-item results).
-
-### .NET Core Types
-
-**No new evaluator interface.** Use MEAI's `IEvaluator` directly.
-
-**`AgentEvaluationResults`** — The only new type. Aggregates per-item MEAI `EvaluationResult`s across a batch of queries:
-
-```csharp
-public class AgentEvaluationResults
-{
-    public string Provider { get; init; }
-    public string? ReportUrl { get; init; }
-
-    // Per-item — standard MEAI EvaluationResult, unchanged
-    public IReadOnlyList<EvaluationResult> Items { get; init; }
-
-    // Aggregate pass/fail derived from metric interpretations
-    public int Passed { get; }
-    public int Failed { get; }
-    public int Total { get; }
-    public bool AllPassed { get; }
-
-    // Workflow: per-agent breakdown
-    public IReadOnlyDictionary<string, AgentEvaluationResults>? SubResults { get; init; }
-
-    public void AssertAllPassed(string? message = null);
-}
-```
-
-### .NET Evaluator Implementations
-
-All implement MEAI's `IEvaluator`:
-
-**`LocalEvaluator`** — Runs lambda checks locally, returns `BooleanMetric` per check:
-
-```csharp
-var local = new LocalEvaluator(
-    FunctionEvaluator.Create("is_concise",
-        (string response) => response.Split().Length < 500),
-    EvalChecks.KeywordCheck("weather"),
-    EvalChecks.ToolCalledCheck("get_weather"));
-```
-
-**MEAI evaluators** — Used directly, no adapter needed:
-
-```csharp
-var quality = new CompositeEvaluator(
-    new RelevanceEvaluator(),
-    new CoherenceEvaluator());
-```
-
-**`FoundryEvals`** — Implements `IEvaluator` but batches internally. On first call, buffers the item. On the last item (or when explicitly flushed), submits the batch to Foundry and distributes per-item results:
-
-```csharp
-var foundry = new FoundryEvals(projectClient, "gpt-4o");
-```
-
-### .NET Orchestration: Extension Methods
-
-```csharp
-public static class AgentEvaluationExtensions
-{
-    // Evaluate an agent against test queries
-    public static Task<AgentEvaluationResults> EvaluateAsync(
-        this AIAgent agent,
-        IEnumerable<string> queries,
-        IEvaluator evaluator,
-        ChatConfiguration? chatConfiguration = null,
-        IEnumerable<string>? expectedOutput = null,
-        CancellationToken cancellationToken = default);
-
-    // Evaluate pre-existing responses (without re-running the agent)
-    public static Task<AgentEvaluationResults> EvaluateAsync(
-        this AIAgent agent,
-        AgentResponse responses,
-        IEvaluator evaluator,
-        IEnumerable<string>? queries = null,
-        ChatConfiguration? chatConfiguration = null,
-        IEnumerable<string>? expectedOutput = null,
-        CancellationToken cancellationToken = default);
-
-    // Evaluate with multiple evaluators (one result per evaluator)
-    public static Task<IReadOnlyList<AgentEvaluationResults>> EvaluateAsync(
-        this AIAgent agent,
-        IEnumerable<string> queries,
-        IEnumerable<IEvaluator> evaluators,
-        ChatConfiguration? chatConfiguration = null,
-        IEnumerable<string>? expectedOutput = null,
-        CancellationToken cancellationToken = default);
-
-    // Evaluate a workflow run with per-agent breakdown
-    public static Task<AgentEvaluationResults> EvaluateAsync(
-        this Run run,
-        IEvaluator evaluator,
-        ChatConfiguration? chatConfiguration = null,
-        bool includeOverall = true,
-        bool includePerAgent = true,
-        CancellationToken cancellationToken = default);
-}
-```
-
-**Usage:**
-
-```csharp
-// MEAI evaluators — just works
-var results = await agent.EvaluateAsync(
-    queries: ["What's the weather?"],
-    evaluator: new RelevanceEvaluator(),
-    chatConfiguration: new ChatConfiguration(evalClient));
-
-// Local checks
-var results = await agent.EvaluateAsync(
-    queries: ["What's the weather?"],
-    evaluator: new LocalEvaluator(
-        EvalChecks.KeywordCheck("weather")));
-
-// Foundry cloud
-var results = await agent.EvaluateAsync(
-    queries: ["What's the weather?"],
-    evaluator: new FoundryEvals(projectClient, "gpt-4o"));
-
-// Evaluate existing response (without re-running the agent)
-var response = await agent.RunAsync("What's the weather?");
-var results = await agent.EvaluateAsync(
-    responses: response,
-    queries: ["What's the weather?"],
-    evaluator: new FoundryEvals(projectClient, "gpt-4o"));
-
-// Mixed — one result per evaluator
-var results = await agent.EvaluateAsync(
-    queries: ["What's the weather?"],
-    evaluators: [
-        new LocalEvaluator(EvalChecks.KeywordCheck("weather")),
-        new RelevanceEvaluator(),
-        new FoundryEvals(projectClient, "gpt-4o")
-    ],
-    chatConfiguration: new ChatConfiguration(evalClient));
-
-// Workflow with per-agent breakdown
-Run run = await workflowRunner.RunAsync(workflow, "Plan a trip");
-var results = await run.EvaluateAsync(
-    evaluator: new FoundryEvals(projectClient, "gpt-4o"));
-```
-
-### .NET Function Evaluators
-
-Typed factory overloads (C# equivalent of Python's `@evaluator`):
-
-```csharp
-public static class FunctionEvaluator
-{
-    public static EvalCheck Create(string name, Func<string, bool> check);           // response only
-    public static EvalCheck Create(string name, Func<string, string?, bool> check);  // expectedOutput
-    public static EvalCheck Create(string name, Func<EvalItem, bool> check);         // full item
-    public static EvalCheck Create(string name, Func<EvalItem, CheckResult> check);  // full control
-    public static EvalCheck Create(string name, Func<string, Task<bool>> check);     // async
-}
-```
-
-`EvalItem` is a lightweight record used only by `FunctionEvaluator` and `LocalEvaluator` to pass context to check functions. It is not part of the `IEvaluator` interface:
-
-```csharp
-public record ExpectedToolCall(string Name, IReadOnlyDictionary<string, object>? Arguments = null);
-
-public sealed class EvalItem
-{
-    public EvalItem(string query, string response, IReadOnlyList<ChatMessage> conversation);
-
-    public string Query { get; }
-    public string Response { get; }
-    public IReadOnlyList<ChatMessage> Conversation { get; }
-    public IReadOnlyList<AITool>? Tools { get; set; }
-    public string? ExpectedOutput { get; set; }
-    public IReadOnlyList<ExpectedToolCall>? ExpectedToolCalls { get; set; }
-    public string? Context { get; set; }
-    public IConversationSplitter? Splitter { get; set; }
-}
-```
-
-### Workflow Data Extraction (.NET)
-
-`run.EvaluateAsync()` walks `Run.OutgoingEvents` via LINQ:
-
-1. Pair `ExecutorInvokedEvent` / `ExecutorCompletedEvent` by `ExecutorId`
-2. Extract `AgentResponseEvent` for per-agent `ChatResponse`
-3. Call `evaluator.EvaluateAsync()` per invocation
-4. Group by `ExecutorId` for per-agent `SubResults`
-5. Use final workflow output for overall eval
-
-### .NET Package Structure
-
-| Package | Contents |
-|---------|----------|
-| `Microsoft.Agents.AI` | `IAgentEvaluator`, `AgentEvaluationResults`, `LocalEvaluator`, `FunctionEvaluator`, `EvalChecks`, `EvalItem`, `ExpectedToolCall`, `AgentEvaluationExtensions` |
-| `Microsoft.Agents.AI.AzureAI` | `FoundryEvals` (provider + constants) |
-
-### Python ↔ .NET Mapping
-
-| Python | .NET |
-|--------|------|
-| `Evaluator` protocol | `IAgentEvaluator` (our interface; MEAI provides `IEvaluator` for per-item scoring) |
-| `EvalItem` dataclass | `EvalItem` class |
-| `EvalResults` | `AgentEvaluationResults` |
-| `EvalItemResult` / `EvalScoreResult` | MEAI `EvaluationResult` / `EvaluationMetric` (reused) |
-| `LocalEvaluator` | `LocalEvaluator` (implements `IAgentEvaluator`) |
-| `@evaluator` | `FunctionEvaluator.Create()` overloads |
-| `keyword_check()` / `tool_called_check()` | `EvalChecks.KeywordCheck()` / `EvalChecks.ToolCalledCheck()` |
-| `tool_calls_present` / `tool_call_args_match` | (custom `FunctionEvaluator` — same pattern) |
-| `ExpectedToolCall` dataclass | `ExpectedToolCall` record |
-| `FoundryEvals` | `FoundryEvals` (implements `IAgentEvaluator`, includes evaluator name constants) |
-| `evaluate_agent()` | `agent.EvaluateAsync(queries, evaluator)` extension method |
-| `evaluate_agent(responses=)` | `agent.EvaluateAsync(responses, evaluator)` extension method |
-| `evaluate_workflow()` | `run.EvaluateAsync()` extension method |
-
-## More Information
-
-- [Foundry Evals documentation](https://learn.microsoft.com/azure/ai-foundry/concepts/evaluation-approach-gen-ai) — Azure AI Foundry evaluation overview

docs/decisions/0021-provider-leading-clients.md

@@ -1,72 +0,0 @@
----
-status: accepted
-contact: eavanvalkenburg
-date: 2026-03-20
-deciders: eavanvalkenburg, sphenry, chetantoshnival
-consulted: taochenosu, moonbox3, dmytrostruk, giles17, alliscode
----
-
-# Provider-Leading Client Design & OpenAI Package Extraction
-
-## Context and Problem Statement
-
-The `agent-framework-core` package currently bundles OpenAI and Azure OpenAI client implementations along with their dependencies (`openai`, `azure-identity`, `azure-ai-projects`, `packaging`). This makes core heavier than necessary for users who don't use OpenAI, and it conflates the core abstractions with a specific provider implementation. Additionally, the current class naming (`OpenAIResponsesClient`, `OpenAIChatClient`) is based on the underlying OpenAI API names rather than what users actually want to do, making discoverability harder for newcomers.
-
-## Decision Drivers
-
-- **Lightweight core**: Core should only contain abstractions, middleware infrastructure, and telemetry — no provider-specific code or dependencies.
-- **Discoverability-first**: Import namespaces should guide users to the right client. `from agent_framework.openai import ...` should surface all OpenAI-related clients; `from agent_framework.azure import ...` should surface Foundry, Azure AI, and other Azure-specific classes.
-- **Provider-leading naming**: The primary client name should reflect the provider, not the underlying API. The Responses API is now the recommended default for OpenAI, so its client should be called `OpenAIChatClient` (not `OpenAIResponsesClient`).
-- **Clean separation of concerns**: Azure-specific deprecated wrappers belong in the azure-ai package, not in the OpenAI package.
-
-## Considered Options
-
-- **Keep OpenAI in core**: Simpler but keeps core heavy; doesn't help discoverability.
-- **Extract OpenAI with Azure wrappers in the OpenAI package**: Keeps Azure OpenAI wrappers alongside OpenAI code, but pollutes the OpenAI package with Azure concerns.
-- **Extract OpenAI, place Azure wrappers in azure-ai**: Clean separation; the OpenAI package has zero Azure dependencies; deprecated Azure wrappers live in a single file in azure-ai for easy future deletion.
-
-## Decision Outcome
-
-Chosen option: "Extract OpenAI, place Azure wrappers in azure-ai", because it achieves the lightest core, cleanest OpenAI package, and the most maintainable deprecation path.
-
-Key changes:
-
-1. **New `agent-framework-openai` package** with dependencies on `agent-framework-core`, `openai`, and `packaging` only.
-2. **Class renames**: `OpenAIResponsesClient` → `OpenAIChatClient` (Responses API), `OpenAIChatClient` → `OpenAIChatCompletionClient` (Chat Completions API). Old names remain as deprecated aliases.
-3. **Deprecated classes**: `OpenAIAssistantsClient`, all `AzureOpenAI*Client` classes, `AzureAIClient`, `AzureAIAgentClient`, and `AzureAIProjectAgentProvider` are marked deprecated.
-4. **New `FoundryChatClient`** in azure-ai for Azure AI Foundry Responses API access, built on `RawFoundryChatClient(RawOpenAIChatClient)`.
-5. **All deprecated `AzureOpenAI*` classes** consolidated into a single file (`_deprecated_azure_openai.py`) in the azure-ai package for clean future deletion.
-6. **Core's `agent_framework.openai` and `agent_framework.azure` namespaces** become lazy-loading gateways, preserving backward-compatible import paths while removing hard dependencies.
-7. **Unified `model` parameter** replaces `model_id` (OpenAI), `deployment_name` (Azure OpenAI), and `model_deployment_name` (Azure AI) across all client constructors. The term `model` is intentionally generic: it naturally maps to an OpenAI model name *and* to an Azure OpenAI deployment name, making it straightforward to use `OpenAIChatClient` with either OpenAI or Azure OpenAI backends (via `AsyncAzureOpenAI`). Environment variables are similarly unified (e.g., `OPENAI_MODEL` instead of separate `OPENAI_RESPONSES_MODEL_ID` / `OPENAI_CHAT_MODEL_ID`).
-8. **`FoundryAgent`** replaces the pattern of `Agent(client=AzureAIClient(...))` for connecting to pre-configured agents in Azure AI Foundry (PromptAgents and HostedAgents). The underlying `RawFoundryAgentChatClient` is an implementation detail — most users interact only with `FoundryAgent`. `AzureAIAgentClient` is separately deprecated as it refers to the V1 Agents Service API. See below for design rationale.
-
-### Foundry Agent Design: `FoundryAgentClient` vs `FoundryAgent`
-
-The existing `AzureAIClient` combines two concerns: CRUD lifecycle management (creating/deleting agents on the service) and runtime communication (sending messages via the Responses API). The new design removes CRUD entirely — users connect to agents that already exist in Foundry.
-
-**Two approaches were considered:**
-
-**Option A — `FoundryAgentClient` only (public ChatClient):**
-Users compose `Agent(client=FoundryAgentClient(...), tools=[...])`. This follows the universal `Agent(client=X)` pattern used by every other provider. However, a "client" that wraps a named remote agent (with `agent_name` as a constructor param) is semantically odd — clients typically wrap a model endpoint, not a specific agent.
-
-**Option B — `FoundryAgent` (Agent subclass) + private `_FoundryAgentChatClient` and public `RawFoundryAgentChatClient`:**
-Users write `FoundryAgent(agent_name="my-agent", ...)` for the common case. Internally, `FoundryAgent` creates a `_FoundryAgentChatClient` and passes it to the standard `Agent` base class. For advanced customization, users pass `client_type=RawFoundryAgentChatClient` (or a custom subclass) to control the client middleware layers. The `Agent(client=RawFoundryAgentChatClient(...))` composition pattern still works for users who prefer it.
-
-**Chosen option: Option B**, because:
-- The common case (`FoundryAgent(...)`) is a single object with no boilerplate.
-- `client_type=` gives full control over client middleware without parameter duplication — the agent forwards connection params to the client internally.
-- `RawFoundryAgent(RawAgent)` and `FoundryAgent(Agent)` mirror the established `RawAgent`/`Agent` pattern.
-- Runtime validation (only `FunctionTool` allowed) lives in `RawFoundryAgentChatClient._prepare_options`, ensuring it applies regardless of how the client is used — through `FoundryAgent`, `Agent(client=...)`, or any custom composition.
-
-**Public classes:**
-- `RawFoundryAgentChatClient(RawOpenAIChatClient)` — Responses API client that injects agent reference and validates tools. Extension point for custom client middleware.
-- `RawFoundryAgent(RawAgent)` — Agent without agent-level middleware/telemetry.
-- `FoundryAgent(AgentTelemetryLayer, AgentMiddlewareLayer, RawFoundryAgent)` — Recommended production agent.
-
-**Internal (private):**
-- `_FoundryAgentChatClient` — Full client with function invocation, chat middleware, and telemetry layers. Created automatically by `FoundryAgent`; users customize via `client_type=RawFoundryAgentChatClient` or a custom subclass.
-
-**Deprecated:**
-- `AzureAIClient` — replaced by `FoundryAgent` (which uses `FoundryAgentClient` internally).
-- `AzureAIAgentClient` — refers to V1 Agents Service API, no direct replacement.
-- `AzureAIProjectAgentProvider` — replaced by `FoundryAgent`.

dotnet/Directory.Packages.props

@@ -19,10 +19,11 @@
     <PackageVersion Include="Aspire.Microsoft.Azure.Cosmos" Version="$(AspireAppHostSdkVersion)" />
     <PackageVersion Include="CommunityToolkit.Aspire.OllamaSharp" Version="13.0.0" />
     <!-- Azure.* -->
-    <PackageVersion Include="Azure.AI.Projects" Version="2.0.0-beta.2" />
-    <PackageVersion Include="Azure.AI.Agents.Persistent" Version="1.2.0-beta.10" />
-    <PackageVersion Include="Azure.AI.OpenAI" Version="2.9.0-beta.1" />
-    <PackageVersion Include="Azure.Identity" Version="1.19.0" />
+    <PackageVersion Include="Azure.AI.Projects" Version="2.0.0-beta.1" />
+    <PackageVersion Include="Azure.AI.Projects.OpenAI" Version="2.0.0-beta.1" />
+    <PackageVersion Include="Azure.AI.Agents.Persistent" Version="1.2.0-beta.8" />
+    <PackageVersion Include="Azure.AI.OpenAI" Version="2.8.0-beta.1" />
+    <PackageVersion Include="Azure.Identity" Version="1.17.1" />
     <PackageVersion Include="Azure.Monitor.OpenTelemetry.Exporter" Version="1.4.0" />
     <!-- Google Gemini  -->
     <PackageVersion Include="Google.GenAI" Version="0.11.0" />
@@ -39,12 +40,12 @@
     <PackageVersion Include="System.CodeDom" Version="10.0.0" />
     <PackageVersion Include="System.Collections.Immutable" Version="10.0.1" />
     <PackageVersion Include="System.CommandLine" Version="2.0.0-rc.2.25502.107" />
-    <PackageVersion Include="System.Diagnostics.DiagnosticSource" Version="10.0.4" />
+    <PackageVersion Include="System.Diagnostics.DiagnosticSource" Version="10.0.3" />
     <PackageVersion Include="System.Linq.AsyncEnumerable" Version="10.0.4" />
     <PackageVersion Include="System.Net.Http.Json" Version="10.0.0" />
-    <PackageVersion Include="System.Net.ServerSentEvents" Version="10.0.4" />
-    <PackageVersion Include="System.Text.Json" Version="10.0.4" />
-    <PackageVersion Include="System.Threading.Channels" Version="10.0.4" />
+    <PackageVersion Include="System.Net.ServerSentEvents" Version="10.0.3" />
+    <PackageVersion Include="System.Text.Json" Version="10.0.3" />
+    <PackageVersion Include="System.Threading.Channels" Version="10.0.3" />
     <PackageVersion Include="System.Threading.Tasks.Extensions" Version="4.6.3" />
     <PackageVersion Include="System.Net.Security" Version="4.3.2" />
     <!-- OpenTelemetry -->
@@ -63,25 +64,24 @@
     <PackageVersion Include="Microsoft.AspNetCore.OpenApi" Version="10.0.0" />
     <PackageVersion Include="Swashbuckle.AspNetCore.SwaggerUI" Version="10.0.0" />
     <!-- Microsoft.Extensions.* -->
-    <PackageVersion Include="Microsoft.Extensions.AI" Version="10.4.0" />
-    <PackageVersion Include="Microsoft.Extensions.AI.Abstractions" Version="10.4.0" />
-    <PackageVersion Include="Microsoft.Extensions.AI.Evaluation" Version="10.4.0" />
-    <PackageVersion Include="Microsoft.Extensions.AI.Evaluation.Quality" Version="10.4.0" />
+    <PackageVersion Include="Microsoft.Extensions.AI" Version="10.3.0" />
+    <PackageVersion Include="Microsoft.Extensions.AI.Abstractions" Version="10.3.0" />
+    <PackageVersion Include="Microsoft.Extensions.AI.Evaluation" Version="10.3.0" />
+    <PackageVersion Include="Microsoft.Extensions.AI.Evaluation.Quality" Version="10.3.0" />
     <PackageVersion Include="Microsoft.Extensions.AI.Evaluation.Safety" Version="10.3.0-preview.1.26109.11" />
-    <PackageVersion Include="Microsoft.Extensions.AI.OpenAI" Version="10.4.0" />
+    <PackageVersion Include="Microsoft.Extensions.AI.OpenAI" Version="10.3.0" />
     <PackageVersion Include="Microsoft.Extensions.Caching.Memory" Version="10.0.0" />
-    <PackageVersion Include="Microsoft.Extensions.Compliance.Abstractions" Version="10.4.0" />
     <PackageVersion Include="Microsoft.Extensions.Configuration" Version="10.0.0" />
     <PackageVersion Include="Microsoft.Extensions.Configuration.Binder" Version="10.0.0" />
     <PackageVersion Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="10.0.0" />
     <PackageVersion Include="Microsoft.Extensions.Configuration.Json" Version="10.0.0" />
     <PackageVersion Include="Microsoft.Extensions.Configuration.UserSecrets" Version="10.0.0" />
     <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="10.0.0" />
-    <PackageVersion Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="10.0.4" />
+    <PackageVersion Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="10.0.3" />
     <PackageVersion Include="Microsoft.Extensions.Hosting" Version="10.0.0" />
     <PackageVersion Include="Microsoft.Extensions.Http.Resilience" Version="10.0.0" />
     <PackageVersion Include="Microsoft.Extensions.Logging" Version="10.0.0" />
-    <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.4" />
+    <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.3" />
     <PackageVersion Include="Microsoft.Extensions.Logging.Console" Version="10.0.0" />
     <PackageVersion Include="Microsoft.Extensions.ServiceDiscovery" Version="10.0.0" />
     <PackageVersion Include="Microsoft.Extensions.VectorData.Abstractions" Version="9.7.0" />
@@ -111,9 +111,9 @@
     <PackageVersion Include="Microsoft.ML.OnnxRuntimeGenAI" Version="0.10.0" />
     <PackageVersion Include="Microsoft.ML.Tokenizers" Version="2.0.0" />
     <PackageVersion Include="OllamaSharp" Version="5.4.8" />
-    <PackageVersion Include="OpenAI" Version="2.9.1" />
+    <PackageVersion Include="OpenAI" Version="2.8.0" />
     <!-- Identity -->
-    <PackageVersion Include="Microsoft.Identity.Client.Extensions.Msal" Version="4.83.1" />
+    <PackageVersion Include="Microsoft.Identity.Client.Extensions.Msal" Version="4.78.0" />
     <!-- Workflows -->
     <PackageVersion Include="Microsoft.Agents.ObjectModel" Version="2026.2.4.1" />
     <PackageVersion Include="Microsoft.Agents.ObjectModel.Json" Version="2026.2.4.1" />

dotnet/agent-framework-dotnet.slnx

@@ -57,7 +57,6 @@
     <Project Path="samples/02-agents/Agents/Agent_Step16_Declarative/Agent_Step16_Declarative.csproj" />
     <Project Path="samples/02-agents/Agents/Agent_Step17_AdditionalAIContext/Agent_Step17_AdditionalAIContext.csproj" />
     <Project Path="samples/02-agents/Agents/Agent_Step18_CompactionPipeline/Agent_Step18_CompactionPipeline.csproj" />
-    <Project Path="samples/02-agents/Agents/Agent_Step19_InFunctionLoopCheckpointing/Agent_Step19_InFunctionLoopCheckpointing.csproj" />
   </Folder>
   <Folder Name="/Samples/02-agents/DeclarativeAgents/">
     <Project Path="samples/02-agents/DeclarativeAgents/ChatClient/DeclarativeChatClientAgents.csproj" />
@@ -310,6 +309,7 @@
     <Project Path="samples/05-end-to-end/HostedAgents/AgentWithHostedMCP/AgentWithHostedMCP.csproj" />
     <Project Path="samples/05-end-to-end/HostedAgents/AgentWithLocalTools/AgentWithLocalTools.csproj" />
     <Project Path="samples/05-end-to-end/HostedAgents/AgentWithTextSearchRag/AgentWithTextSearchRag.csproj" />
+    <Project Path="samples/05-end-to-end/HostedAgents/AgentWithTools/AgentWithTools.csproj" />
     <Project Path="samples/05-end-to-end/HostedAgents/FoundryMultiAgent/FoundryMultiAgent.csproj" />
     <Project Path="samples/05-end-to-end/HostedAgents/FoundrySingleAgent/FoundrySingleAgent.csproj" />
   </Folder>
@@ -453,10 +453,6 @@
     <File Path="src/Shared/Samples/TextOutputHelperExtensions.cs" />
     <File Path="src/Shared/Samples/XunitLogger.cs" />
   </Folder>
-  <Folder Name="/Solution Items/src/Shared/Redaction/">
-    <File Path="src/Shared/Redaction/README.md" />
-    <File Path="src/Shared/Redaction/ReplacingRedactor.cs" />
-  </Folder>
   <Folder Name="/Solution Items/src/Shared/Throw/">
     <File Path="src/Shared/Throw/README.md" />
     <File Path="src/Shared/Throw/Throw.cs" />

dotnet/eng/MSBuild/Shared.props

@@ -29,7 +29,4 @@
   <ItemGroup Condition="'$(InjectSharedDiagnosticIds)' == 'true'">
     <Compile Include="$(MSBuildThisFileDirectory)\..\..\src\Shared\DiagnosticIds\*.cs" LinkBase="Shared\DiagnosticIds" />
   </ItemGroup>
-  <ItemGroup Condition="'$(InjectSharedRedaction)' == 'true'">
-    <Compile Include="$(MSBuildThisFileDirectory)\..\..\src\Shared\Redaction\*.cs" LinkBase="Shared\Redaction" />
-  </ItemGroup>
 </Project>

dotnet/samples/02-agents/AGUI/Step04_HumanInLoop/Client/Program.cs

@@ -59,14 +59,14 @@ while ((input = Console.ReadLine()) != null && !input.Equals("exit", StringCompa
             {
                 switch (content)
                 {
-                    case ToolApprovalRequestContent approvalRequest when approvalRequest.ToolCall is FunctionCallContent fcc:
-                        DisplayApprovalRequest(approvalRequest, fcc);
+                    case FunctionApprovalRequestContent approvalRequest:
+                        DisplayApprovalRequest(approvalRequest);
 
-                        Console.Write($"\nApprove '{fcc.Name}'? (yes/no): ");
+                        Console.Write($"\nApprove '{approvalRequest.FunctionCall.Name}'? (yes/no): ");
                         string? userInput = Console.ReadLine();
                         bool approved = userInput?.ToUpperInvariant() is "YES" or "Y";
 
-                        ToolApprovalResponseContent approvalResponse = approvalRequest.CreateResponse(approved);
+                        FunctionApprovalResponseContent approvalResponse = approvalRequest.CreateResponse(approved);
 
                         if (approvalRequest.AdditionalProperties != null)
                         {
@@ -128,19 +128,19 @@ while ((input = Console.ReadLine()) != null && !input.Equals("exit", StringCompa
 }
 
 #pragma warning disable MEAI001
-static void DisplayApprovalRequest(ToolApprovalRequestContent approvalRequest, FunctionCallContent fcc)
+static void DisplayApprovalRequest(FunctionApprovalRequestContent approvalRequest)
 {
     Console.ForegroundColor = ConsoleColor.Yellow;
     Console.WriteLine();
     Console.WriteLine("============================================================");
     Console.WriteLine("APPROVAL REQUIRED");
     Console.WriteLine("============================================================");
-    Console.WriteLine($"Function: {fcc.Name}");
+    Console.WriteLine($"Function: {approvalRequest.FunctionCall.Name}");
 
-    if (fcc.Arguments != null)
+    if (approvalRequest.FunctionCall.Arguments != null)
     {
         Console.WriteLine("Arguments:");
-        foreach (var arg in fcc.Arguments)
+        foreach (var arg in approvalRequest.FunctionCall.Arguments)
         {
             Console.WriteLine($"  {arg.Key} = {arg.Value}");
         }

dotnet/samples/02-agents/AGUI/Step04_HumanInLoop/Client/ServerFunctionApprovalClientAgent.cs

@@ -9,7 +9,7 @@ using ServerFunctionApproval;
 
 /// <summary>
 /// A delegating agent that handles server function approval requests and responses.
-/// Transforms between ToolApprovalRequestContent/ToolApprovalResponseContent
+/// Transforms between FunctionApprovalRequestContent/FunctionApprovalResponseContent
 /// and the server's request_approval tool call pattern.
 /// </summary>
 internal sealed class ServerFunctionApprovalClientAgent : DelegatingAIAgent
@@ -50,14 +50,14 @@ internal sealed class ServerFunctionApprovalClientAgent : DelegatingAIAgent
     }
 
 #pragma warning disable MEAI001 // Type is for evaluation purposes only
-    private static FunctionResultContent ConvertApprovalResponseToToolResult(ToolApprovalResponseContent approvalResponse, JsonSerializerOptions jsonOptions)
+    private static FunctionResultContent ConvertApprovalResponseToToolResult(FunctionApprovalResponseContent approvalResponse, JsonSerializerOptions jsonOptions)
     {
         return new FunctionResultContent(
-            callId: approvalResponse.RequestId,
+            callId: approvalResponse.Id,
             result: JsonSerializer.SerializeToElement(
                 new ApprovalResponse
                 {
-                    ApprovalId = approvalResponse.RequestId,
+                    ApprovalId = approvalResponse.Id,
                     Approved = approvalResponse.Approved
                 },
                 jsonOptions));
@@ -89,7 +89,7 @@ internal sealed class ServerFunctionApprovalClientAgent : DelegatingAIAgent
     {
         List<ChatMessage>? result = null;
 
-        Dictionary<string, ToolApprovalRequestContent> approvalRequests = [];
+        Dictionary<string, FunctionApprovalRequestContent> approvalRequests = [];
         for (var messageIndex = 0; messageIndex < messages.Count; messageIndex++)
         {
             var message = messages[messageIndex];
@@ -102,21 +102,21 @@ internal sealed class ServerFunctionApprovalClientAgent : DelegatingAIAgent
                 var content = message.Contents[contentIndex];
 
                 // Handle pending approval requests (transform to tool call)
-                if (content is ToolApprovalRequestContent approvalRequest &&
+                if (content is FunctionApprovalRequestContent approvalRequest &&
                     approvalRequest.AdditionalProperties?.TryGetValue("original_function", out var originalFunction) == true &&
                     originalFunction is FunctionCallContent original)
                 {
-                    approvalRequests[approvalRequest.RequestId] = approvalRequest;
+                    approvalRequests[approvalRequest.Id] = approvalRequest;
                     transformedContents ??= CopyContentsUpToIndex(message.Contents, contentIndex);
                     transformedContents.Add(original);
                 }
                 // Handle pending approval responses (transform to tool result)
-                else if (content is ToolApprovalResponseContent approvalResponse &&
-                    approvalRequests.TryGetValue(approvalResponse.RequestId, out var correspondingRequest))
+                else if (content is FunctionApprovalResponseContent approvalResponse &&
+                    approvalRequests.TryGetValue(approvalResponse.Id, out var correspondingRequest))
                 {
                     transformedContents ??= CopyContentsUpToIndex(message.Contents, contentIndex);
                     transformedContents.Add(ConvertApprovalResponseToToolResult(approvalResponse, jsonSerializerOptions));
-                    approvalRequests.Remove(approvalResponse.RequestId);
+                    approvalRequests.Remove(approvalResponse.Id);
                     correspondingRequest.AdditionalProperties?.Remove("original_function");
                 }
                 // Skip historical approval content
@@ -198,8 +198,8 @@ internal sealed class ServerFunctionApprovalClientAgent : DelegatingAIAgent
                 var functionCallArgs = (Dictionary<string, object?>?)approvalRequest.FunctionArguments?
                     .Deserialize(jsonSerializerOptions.GetTypeInfo(typeof(Dictionary<string, object?>)));
 
-                var approvalRequestContent = new ToolApprovalRequestContent(
-                    requestId: approvalRequest.ApprovalId,
+                var approvalRequestContent = new FunctionApprovalRequestContent(
+                    id: approvalRequest.ApprovalId,
                     new FunctionCallContent(
                         callId: approvalRequest.ApprovalId,
                         name: approvalRequest.FunctionName,

dotnet/samples/02-agents/AGUI/Step04_HumanInLoop/Server/ServerFunctionApprovalServerAgent.cs

@@ -9,7 +9,7 @@ using ServerFunctionApproval;
 
 /// <summary>
 /// A delegating agent that handles function approval requests on the server side.
-/// Transforms between ToolApprovalRequestContent/ToolApprovalResponseContent
+/// Transforms between FunctionApprovalRequestContent/FunctionApprovalResponseContent
 /// and the request_approval tool call pattern for client communication.
 /// </summary>
 internal sealed class ServerFunctionApprovalAgent : DelegatingAIAgent
@@ -50,7 +50,7 @@ internal sealed class ServerFunctionApprovalAgent : DelegatingAIAgent
     }
 
 #pragma warning disable MEAI001 // Type is for evaluation purposes only
-    private static ToolApprovalRequestContent ConvertToolCallToApprovalRequest(FunctionCallContent toolCall, JsonSerializerOptions jsonSerializerOptions)
+    private static FunctionApprovalRequestContent ConvertToolCallToApprovalRequest(FunctionCallContent toolCall, JsonSerializerOptions jsonSerializerOptions)
     {
         if (toolCall.Name != "request_approval" || toolCall.Arguments == null)
         {
@@ -67,15 +67,15 @@ internal sealed class ServerFunctionApprovalAgent : DelegatingAIAgent
             throw new InvalidOperationException("Failed to deserialize approval request from tool call");
         }
 
-        return new ToolApprovalRequestContent(
-            requestId: request.ApprovalId,
+        return new FunctionApprovalRequestContent(
+            id: request.ApprovalId,
             new FunctionCallContent(
                 callId: request.ApprovalId,
                 name: request.FunctionName,
                 arguments: request.FunctionArguments));
     }
 
-    private static ToolApprovalResponseContent ConvertToolResultToApprovalResponse(FunctionResultContent result, ToolApprovalRequestContent approval, JsonSerializerOptions jsonSerializerOptions)
+    private static FunctionApprovalResponseContent ConvertToolResultToApprovalResponse(FunctionResultContent result, FunctionApprovalRequestContent approval, JsonSerializerOptions jsonSerializerOptions)
     {
         var approvalResponse = result.Result is JsonElement je ?
             (ApprovalResponse?)je.Deserialize(jsonSerializerOptions.GetTypeInfo(typeof(ApprovalResponse))) :
@@ -121,7 +121,7 @@ internal sealed class ServerFunctionApprovalAgent : DelegatingAIAgent
         // Track approval ID to original call ID mapping
         _ = new Dictionary<string, string>();
 #pragma warning disable MEAI001 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
-        Dictionary<string, ToolApprovalRequestContent> trackedRequestApprovalToolCalls = new(); // Remote approvals
+        Dictionary<string, FunctionApprovalRequestContent> trackedRequestApprovalToolCalls = new(); // Remote approvals
         for (int messageIndex = 0; messageIndex < messages.Count; messageIndex++)
         {
             var message = messages[messageIndex];
@@ -181,10 +181,11 @@ internal sealed class ServerFunctionApprovalAgent : DelegatingAIAgent
         {
             var content = update.Contents[i];
 #pragma warning disable MEAI001 // Type is for evaluation purposes only
-            if (content is ToolApprovalRequestContent request && request.ToolCall is FunctionCallContent functionCall)
+            if (content is FunctionApprovalRequestContent request)
             {
                 updatedContents ??= [.. update.Contents];
-                var approvalId = request.RequestId;
+                var functionCall = request.FunctionCall;
+                var approvalId = request.Id;
 
                 var approvalData = new ApprovalRequest
                 {

dotnet/samples/02-agents/AgentProviders/Agent_With_AzureAIAgentsPersistent/Program.cs

@@ -1,7 +1,5 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-#pragma warning disable CS0618 // Type or member is obsolete - sample uses deprecated PersistentAgentsClientExtensions
-
 // This sample shows how to create and use a simple AI agent with Azure Foundry Agents as the backend.
 
 using Azure.AI.Agents.Persistent;

dotnet/samples/02-agents/AgentProviders/Agent_With_AzureAIProject/Program.cs

@@ -3,7 +3,7 @@
 // This sample shows how to create and use a AI agents with Azure Foundry Agents as the backend.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 

dotnet/samples/02-agents/AgentProviders/Agent_With_AzureOpenAIResponses/Program.cs

@@ -17,8 +17,8 @@ var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT
 AIAgent agent = new AzureOpenAIClient(
     new Uri(endpoint),
     new DefaultAzureCredential())
-     .GetResponsesClient()
-     .AsAIAgent(model: deploymentName, instructions: "You are good at telling jokes.", name: "Joker");
+     .GetResponsesClient(deploymentName)
+     .AsAIAgent(instructions: "You are good at telling jokes.", name: "Joker");
 
 // Invoke the agent and output the text result.
 Console.WriteLine(await agent.RunAsync("Tell me a joke about a pirate."));
@@ -29,8 +29,8 @@ Console.WriteLine(await agent.RunAsync("Tell me a joke about a pirate."));
 AIAgent agentStoreFalse = new AzureOpenAIClient(
     new Uri(endpoint),
     new DefaultAzureCredential())
-     .GetResponsesClient()
-     .AsIChatClientWithStoredOutputDisabled(model: deploymentName)
+     .GetResponsesClient(deploymentName)
+     .AsIChatClientWithStoredOutputDisabled()
      .AsAIAgent(instructions: "You are good at telling jokes.", name: "Joker");
 
 // Invoke the agent and output the text result.

dotnet/samples/02-agents/AgentProviders/Agent_With_OpenAIResponses/Program.cs

@@ -11,8 +11,8 @@ var model = Environment.GetEnvironmentVariable("OPENAI_CHAT_MODEL_NAME") ?? "gpt
 
 AIAgent agent = new OpenAIClient(
     apiKey)
-     .GetResponsesClient()
-     .AsAIAgent(model: model, instructions: "You are good at telling jokes.", name: "Joker");
+     .GetResponsesClient(model)
+     .AsAIAgent(instructions: "You are good at telling jokes.", name: "Joker");
 
 // Invoke the agent and output the text result.
 Console.WriteLine(await agent.RunAsync("Tell me a joke about a pirate."));

dotnet/samples/02-agents/AgentSkills/Agent_Step01_BasicSkills/Program.cs

@@ -23,7 +23,7 @@ var skillsProvider = new FileAgentSkillsProvider(skillPath: Path.Combine(AppCont
 
 // --- Agent Setup ---
 AIAgent agent = new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential())
-    .GetResponsesClient()
+    .GetResponsesClient(deploymentName)
     .AsAIAgent(new ChatClientAgentOptions
     {
         Name = "SkillsAgent",
@@ -32,8 +32,7 @@ AIAgent agent = new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredent
             Instructions = "You are a helpful assistant.",
         },
         AIContextProviders = [skillsProvider],
-    },
-    model: deploymentName);
+    });
 
 // --- Example 1: Expense policy question (loads FAQ resource) ---
 Console.WriteLine("Example 1: Checking expense policy FAQ");

dotnet/samples/02-agents/AgentWithOpenAI/Agent_OpenAI_Step02_Reasoning/Program.cs

@@ -10,8 +10,8 @@ var apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY") ?? throw new I
 var model = Environment.GetEnvironmentVariable("OPENAI_CHAT_MODEL_NAME") ?? "gpt-5";
 
 var client = new OpenAIClient(apiKey)
-        .GetResponsesClient()
-        .AsIChatClient(model).AsBuilder()
+        .GetResponsesClient(model)
+        .AsIChatClient().AsBuilder()
         .ConfigureOptions(o =>
         {
             o.Reasoning = new()

dotnet/samples/02-agents/AgentWithOpenAI/Agent_OpenAI_Step04_CreateFromOpenAIResponseClient/OpenAIResponseClientAgent.cs

@@ -20,21 +20,19 @@ public class OpenAIResponseClientAgent : DelegatingAIAgent
     /// <param name="instructions">Optional instructions for the agent.</param>
     /// <param name="name">Optional name for the agent.</param>
     /// <param name="description">Optional description for the agent.</param>
-    /// <param name="model">Optional default model ID to use for requests. Required when using a plain <see cref="ResponsesClient"/> (not via Azure OpenAI).</param>
     /// <param name="loggerFactory">Optional instance of <see cref="ILoggerFactory"/></param>
     public OpenAIResponseClientAgent(
         ResponsesClient client,
         string? instructions = null,
         string? name = null,
         string? description = null,
-        string? model = null,
         ILoggerFactory? loggerFactory = null) :
         this(client, new()
         {
             Name = name,
             Description = description,
             ChatOptions = new ChatOptions() { Instructions = instructions },
-        }, model, loggerFactory)
+        }, loggerFactory)
     {
     }
 
@@ -43,11 +41,10 @@ public class OpenAIResponseClientAgent : DelegatingAIAgent
     /// </summary>
     /// <param name="client">Instance of <see cref="ResponsesClient"/></param>
     /// <param name="options">Options to create the agent.</param>
-    /// <param name="model">Optional default model ID to use for requests. Required when using a plain <see cref="ResponsesClient"/> (not via Azure OpenAI).</param>
     /// <param name="loggerFactory">Optional instance of <see cref="ILoggerFactory"/></param>
     public OpenAIResponseClientAgent(
-        ResponsesClient client, ChatClientAgentOptions options, string? model = null, ILoggerFactory? loggerFactory = null) :
-        base(new ChatClientAgent((client ?? throw new ArgumentNullException(nameof(client))).AsIChatClient(model), options, loggerFactory))
+        ResponsesClient client, ChatClientAgentOptions options, ILoggerFactory? loggerFactory = null) :
+        base(new ChatClientAgent((client ?? throw new ArgumentNullException(nameof(client))).AsIChatClient(), options, loggerFactory))
     {
     }
 

dotnet/samples/02-agents/AgentWithOpenAI/Agent_OpenAI_Step04_CreateFromOpenAIResponseClient/Program.cs

@@ -10,10 +10,10 @@ var apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY") ?? throw new I
 var model = Environment.GetEnvironmentVariable("OPENAI_CHAT_MODEL_NAME") ?? "gpt-4o-mini";
 
 // Create a ResponsesClient directly from OpenAIClient
-ResponsesClient responseClient = new OpenAIClient(apiKey).GetResponsesClient();
+ResponsesClient responseClient = new OpenAIClient(apiKey).GetResponsesClient(model);
 
 // Create an agent directly from the ResponsesClient using OpenAIResponseClientAgent
-OpenAIResponseClientAgent agent = new(responseClient, instructions: "You are good at telling jokes.", name: "Joker", model: model);
+OpenAIResponseClientAgent agent = new(responseClient, instructions: "You are good at telling jokes.", name: "Joker");
 
 ResponseItem userMessage = ResponseItem.CreateUserMessageItem("Tell me a joke about a pirate.");
 

dotnet/samples/02-agents/AgentWithOpenAI/Agent_OpenAI_Step05_Conversation/Program.cs

@@ -22,7 +22,7 @@ OpenAIClient openAIClient = new(apiKey);
 ConversationClient conversationClient = openAIClient.GetConversationClient();
 
 // Create an agent directly from the ResponsesClient using OpenAIResponseClientAgent
-ChatClientAgent agent = new(openAIClient.GetResponsesClient().AsIChatClient(model), instructions: "You are a helpful assistant.", name: "ConversationAgent");
+ChatClientAgent agent = new(openAIClient.GetResponsesClient(model).AsIChatClient(), instructions: "You are a helpful assistant.", name: "ConversationAgent");
 
 ClientResult createConversationResult = await conversationClient.CreateConversationAsync(BinaryContent.Create(BinaryData.FromString("{}")));
 

dotnet/samples/02-agents/Agents/Agent_Step01_UsingFunctionToolsWithApprovals/Program.cs

@@ -36,11 +36,11 @@ AIAgent agent = new AzureOpenAIClient(
 // For simplicity, we are assuming here that only function approvals are pending.
 AgentSession session = await agent.CreateSessionAsync();
 AgentResponse response = await agent.RunAsync("What is the weather like in Amsterdam?", session);
-List<ToolApprovalRequestContent> approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<ToolApprovalRequestContent>().ToList();
+List<FunctionApprovalRequestContent> approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<FunctionApprovalRequestContent>().ToList();
 
 // For streaming use:
 // var updates = await agent.RunStreamingAsync("What is the weather like in Amsterdam?", session).ToListAsync();
-// approvalRequests = updates.SelectMany(x => x.Contents).OfType<ToolApprovalRequestContent>().ToList();
+// approvalRequests = updates.SelectMany(x => x.Contents).OfType<FunctionApprovalRequestContent>().ToList();
 
 while (approvalRequests.Count > 0)
 {
@@ -48,18 +48,18 @@ while (approvalRequests.Count > 0)
     List<ChatMessage> userInputResponses = approvalRequests
         .ConvertAll(functionApprovalRequest =>
         {
-            Console.WriteLine($"The agent would like to invoke the following function, please reply Y to approve: Name {((FunctionCallContent)functionApprovalRequest.ToolCall).Name}");
+            Console.WriteLine($"The agent would like to invoke the following function, please reply Y to approve: Name {functionApprovalRequest.FunctionCall.Name}");
             return new ChatMessage(ChatRole.User, [functionApprovalRequest.CreateResponse(Console.ReadLine()?.Equals("Y", StringComparison.OrdinalIgnoreCase) ?? false)]);
         });
 
     // Pass the user input responses back to the agent for further processing.
     response = await agent.RunAsync(userInputResponses, session);
 
-    approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<ToolApprovalRequestContent>().ToList();
+    approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<FunctionApprovalRequestContent>().ToList();
 
     // For streaming use:
     // updates = await agent.RunStreamingAsync(userInputResponses, session).ToListAsync();
-    // approvalRequests = updates.SelectMany(x => x.Contents).OfType<ToolApprovalRequestContent>().ToList();
+    // approvalRequests = updates.SelectMany(x => x.Contents).OfType<FunctionApprovalRequestContent>().ToList();
 }
 
 Console.WriteLine($"\nAgent: {response}");

dotnet/samples/02-agents/Agents/Agent_Step07_AsMcpTool/Agent_Step07_AsMcpTool.csproj

@@ -10,14 +10,14 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Azure.AI.Projects" />
+    <PackageReference Include="Azure.AI.Agents.Persistent" />
     <PackageReference Include="Azure.Identity" />
     <PackageReference Include="Microsoft.Extensions.Hosting" />
     <PackageReference Include="ModelContextProtocol" />
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI.Persistent\Microsoft.Agents.AI.AzureAI.Persistent.csproj" />
   </ItemGroup>
   
 </Project>

dotnet/samples/02-agents/Agents/Agent_Step07_AsMcpTool/Program.cs

@@ -2,7 +2,7 @@
 
 // This sample shows how to expose an AI agent as an MCP tool.
 
-using Azure.AI.Projects;
+using Azure.AI.Agents.Persistent;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.DependencyInjection;
@@ -15,15 +15,18 @@ var deploymentName = Environment.GetEnvironmentVariable("AZURE_AI_MODEL_DEPLOYME
 // WARNING: DefaultAzureCredential is convenient for development but requires careful consideration in production.
 // In production, consider using a specific credential (e.g., ManagedIdentityCredential) to avoid
 // latency issues, unintended credential probing, and potential security risks from fallback mechanisms.
-var aiProjectClient = new AIProjectClient(new Uri(endpoint), new DefaultAzureCredential());
+var persistentAgentsClient = new PersistentAgentsClient(endpoint, new DefaultAzureCredential());
 
-// Create a server side agent and expose it as an AIAgent.
-AIAgent agent = await aiProjectClient.CreateAIAgentAsync(
+// Create a server side persistent agent
+var agentMetadata = await persistentAgentsClient.Administration.CreateAgentAsync(
     model: deploymentName,
     instructions: "You are good at telling jokes, and you always start each joke with 'Aye aye, captain!'.",
     name: "Joker",
     description: "An agent that tells jokes.");
 
+// Retrieve the server side persistent agent as an AIAgent.
+AIAgent agent = await persistentAgentsClient.GetAIAgentAsync(agentMetadata.Value.Id);
+
 // Convert the agent to an AIFunction and then to an MCP tool.
 // The agent name and description will be used as the mcp tool name and description.
 McpServerTool tool = McpServerTool.Create(agent.AsAIFunction());

dotnet/samples/02-agents/Agents/Agent_Step10_BackgroundResponsesWithToolsAndPersistence/Program.cs

@@ -25,9 +25,8 @@ var stateStore = new Dictionary<string, JsonElement?>();
 AIAgent agent = new AzureOpenAIClient(
     new Uri(endpoint),
     new DefaultAzureCredential())
-     .GetResponsesClient()
+     .GetResponsesClient(deploymentName)
      .AsAIAgent(
-        model: deploymentName,
         name: "SpaceNovelWriter",
         instructions: "You are a space novel writer. Always research relevant facts and generate character profiles for the main characters before writing novels." +
                       "Write complete chapters without asking for approval or feedback. Do not ask the user about tone, style, pace, or format preferences - just write the novel based on the request.",

dotnet/samples/02-agents/Agents/Agent_Step11_Middleware/Program.cs

@@ -246,7 +246,7 @@ async Task<AgentResponse> ConsolePromptingApprovalMiddleware(IEnumerable<ChatMes
     AgentResponse response = await innerAgent.RunAsync(messages, session, options, cancellationToken);
 
     // For simplicity, we are assuming here that only function approvals are pending.
-    List<ToolApprovalRequestContent> approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<ToolApprovalRequestContent>().ToList();
+    List<FunctionApprovalRequestContent> approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<FunctionApprovalRequestContent>().ToList();
 
     while (approvalRequests.Count > 0)
     {
@@ -255,13 +255,13 @@ async Task<AgentResponse> ConsolePromptingApprovalMiddleware(IEnumerable<ChatMes
         response.Messages = approvalRequests
             .ConvertAll(functionApprovalRequest =>
             {
-                Console.WriteLine($"The agent would like to invoke the following function, please reply Y to approve: Name {((FunctionCallContent)functionApprovalRequest.ToolCall).Name}");
+                Console.WriteLine($"The agent would like to invoke the following function, please reply Y to approve: Name {functionApprovalRequest.FunctionCall.Name}");
                 return new ChatMessage(ChatRole.User, [functionApprovalRequest.CreateResponse(Console.ReadLine()?.Equals("Y", StringComparison.OrdinalIgnoreCase) ?? false)]);
             });
 
         response = await innerAgent.RunAsync(response.Messages, session, options, cancellationToken);
 
-        approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<ToolApprovalRequestContent>().ToList();
+        approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<FunctionApprovalRequestContent>().ToList();
     }
 
     return response;

dotnet/samples/02-agents/Agents/Agent_Step14_BackgroundResponses/Program.cs

@@ -16,8 +16,8 @@ var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT
 AIAgent agent = new AzureOpenAIClient(
     new Uri(endpoint),
     new DefaultAzureCredential())
-     .GetResponsesClient()
-     .AsAIAgent(model: deploymentName);
+     .GetResponsesClient(deploymentName)
+     .AsAIAgent();
 
 // Enable background responses (only supported by OpenAI Responses at this time).
 AgentRunOptions options = new() { AllowBackgroundResponses = true };

dotnet/samples/02-agents/Agents/Agent_Step15_DeepResearch/Program.cs

@@ -1,7 +1,5 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-#pragma warning disable CS0618 // Type or member is obsolete - sample uses deprecated PersistentAgentsClientExtensions
-
 // This sample shows how to create an Azure AI Foundry Agent with the Deep Research Tool.
 
 using Azure.AI.Agents.Persistent;

dotnet/samples/02-agents/Agents/Agent_Step19_InFunctionLoopCheckpointing/Agent_Step19_InFunctionLoopCheckpointing.csproj

@@ -1,20 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFrameworks>net10.0</TargetFrameworks>
-
-    <Nullable>enable</Nullable>
-    <ImplicitUsings>enable</ImplicitUsings>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Azure.AI.OpenAI" />
-    <PackageReference Include="Azure.Identity" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
-  </ItemGroup>
-
-</Project>

dotnet/samples/02-agents/Agents/Agent_Step19_InFunctionLoopCheckpointing/Program.cs

@@ -1,226 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-// This sample demonstrates how the ChatClientAgent persists chat history after each individual
-// call to the AI service.
-// When an agent uses tools, FunctionInvokingChatClient may loop multiple times
-// (service call → tool execution → service call), and intermediate messages (tool calls and
-// results) are persisted after each service call. This allows you to inspect or recover them
-// even if the process is interrupted mid-loop, but may also result in chat history that is not
-// yet finalized (e.g., tool calls without results) being persisted, which may be undesirable in some cases.
-//
-// To opt into end-of-run persistence instead (atomic run semantics), set
-// PersistChatHistoryAtEndOfRun = true on ChatClientAgentOptions.
-//
-// The sample runs two multi-turn conversations: one using non-streaming (RunAsync) and one
-// using streaming (RunStreamingAsync), to demonstrate correct behavior in both modes.
-
-using System.ComponentModel;
-using Azure.AI.OpenAI;
-using Azure.Identity;
-using Microsoft.Agents.AI;
-using Microsoft.Extensions.AI;
-using OpenAI.Responses;
-
-var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
-var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
-var store = Environment.GetEnvironmentVariable("AZURE_OPENAI_RESPONSES_STORE") ?? "false";
-
-// WARNING: DefaultAzureCredential is convenient for development but requires careful consideration in production.
-// In production, consider using a specific credential (e.g., ManagedIdentityCredential) to avoid
-// latency issues, unintended credential probing, and potential security risks from fallback mechanisms.
-AzureOpenAIClient openAIClient = new(new Uri(endpoint), new DefaultAzureCredential());
-
-// Define multiple tools so the model makes several tool calls in a single run.
-[Description("Get the current weather for a city.")]
-static string GetWeather([Description("The city name.")] string city) =>
-    city.ToUpperInvariant() switch
-    {
-        "SEATTLE" => "Seattle: 55°F, cloudy with light rain.",
-        "NEW YORK" => "New York: 72°F, sunny and warm.",
-        "LONDON" => "London: 48°F, overcast with fog.",
-        "DUBLIN" => "Dublin: 43°F, overcast with fog.",
-        _ => $"{city}: weather data not available."
-    };
-
-[Description("Get the current time in a city.")]
-static string GetTime([Description("The city name.")] string city) =>
-    city.ToUpperInvariant() switch
-    {
-        "SEATTLE" => "Seattle: 9:00 AM PST",
-        "NEW YORK" => "New York: 12:00 PM EST",
-        "LONDON" => "London: 5:00 PM GMT",
-        "DUBLIN" => "Dublin: 5:00 PM GMT",
-        _ => $"{city}: time data not available."
-    };
-
-// Create the agent — per-service-call persistence is the default behavior.
-// The in-memory ChatHistoryProvider is used by default when the service does not require service stored chat
-// history, so for those cases, we can inspect the chat history via session.TryGetInMemoryChatHistory().
-IChatClient chatClient = string.Equals(store, "TRUE", StringComparison.OrdinalIgnoreCase) ?
-    openAIClient.GetResponsesClient().AsIChatClient(deploymentName) :
-    openAIClient.GetResponsesClient().AsIChatClientWithStoredOutputDisabled(deploymentName);
-AIAgent agent = chatClient.AsAIAgent(
-    new ChatClientAgentOptions
-    {
-        Name = "WeatherAssistant",
-        ChatOptions = new()
-        {
-            Instructions = "You are a helpful assistant. When asked about multiple cities, call the appropriate tool for each city.",
-            Tools = [AIFunctionFactory.Create(GetWeather), AIFunctionFactory.Create(GetTime)]
-        },
-    });
-
-await RunNonStreamingAsync();
-await RunStreamingAsync();
-
-async Task RunNonStreamingAsync()
-{
-    int lastChatHistorySize = 0;
-    string lastConversationId = string.Empty;
-
-    Console.ForegroundColor = ConsoleColor.Yellow;
-    Console.WriteLine("\n=== Non-Streaming Mode ===");
-    Console.ResetColor();
-
-    AgentSession session = await agent.CreateSessionAsync();
-
-    // First turn — ask about multiple cities so the model calls tools.
-    const string Prompt = "What's the weather and time in Seattle, New York, and London?";
-    PrintUserMessage(Prompt);
-
-    var response = await agent.RunAsync(Prompt, session);
-    PrintAgentResponse(response.Text);
-    PrintChatHistory(session, "After run", ref lastChatHistorySize, ref lastConversationId);
-
-    // Second turn — follow-up to verify chat history is correct.
-    const string FollowUp1 = "And Dublin?";
-    PrintUserMessage(FollowUp1);
-
-    response = await agent.RunAsync(FollowUp1, session);
-    PrintAgentResponse(response.Text);
-    PrintChatHistory(session, "After second run", ref lastChatHistorySize, ref lastConversationId);
-
-    // Third turn — follow-up to verify chat history is correct.
-    const string FollowUp2 = "Which city is the warmest?";
-    PrintUserMessage(FollowUp2);
-
-    response = await agent.RunAsync(FollowUp2, session);
-    PrintAgentResponse(response.Text);
-    PrintChatHistory(session, "After third run", ref lastChatHistorySize, ref lastConversationId);
-}
-
-async Task RunStreamingAsync()
-{
-    int lastChatHistorySize = 0;
-    string lastConversationId = string.Empty;
-
-    Console.ForegroundColor = ConsoleColor.Yellow;
-    Console.WriteLine("\n=== Streaming Mode ===");
-    Console.ResetColor();
-
-    AgentSession session = await agent.CreateSessionAsync();
-
-    // First turn — ask about multiple cities so the model calls tools.
-    const string Prompt = "What's the weather and time in Seattle, New York, and London?";
-    PrintUserMessage(Prompt);
-
-    Console.ForegroundColor = ConsoleColor.Cyan;
-    Console.Write("\n[Agent] ");
-    Console.ResetColor();
-
-    await foreach (var update in agent.RunStreamingAsync(Prompt, session))
-    {
-        Console.Write(update);
-
-        // During streaming we should be able to see updates to the chat history
-        // before the full run completes, as each service call is made and persisted.
-        PrintChatHistory(session, "During run", ref lastChatHistorySize, ref lastConversationId);
-    }
-
-    Console.WriteLine();
-    PrintChatHistory(session, "After run", ref lastChatHistorySize, ref lastConversationId);
-
-    // Second turn — follow-up to verify chat history is correct.
-    const string FollowUp1 = "And Dublin?";
-    PrintUserMessage(FollowUp1);
-
-    Console.ForegroundColor = ConsoleColor.Cyan;
-    Console.Write("\n[Agent] ");
-    Console.ResetColor();
-
-    await foreach (var update in agent.RunStreamingAsync(FollowUp1, session))
-    {
-        Console.Write(update);
-
-        // During streaming we should be able to see updates to the chat history
-        // before the full run completes, as each service call is made and persisted.
-        PrintChatHistory(session, "During second run", ref lastChatHistorySize, ref lastConversationId);
-    }
-
-    Console.WriteLine();
-    PrintChatHistory(session, "After second run", ref lastChatHistorySize, ref lastConversationId);
-
-    // Third turn — follow-up to verify chat history is correct.
-    const string FollowUp2 = "Which city is the warmest?";
-    PrintUserMessage(FollowUp2);
-
-    Console.ForegroundColor = ConsoleColor.Cyan;
-    Console.Write("\n[Agent] ");
-    Console.ResetColor();
-
-    await foreach (var update in agent.RunStreamingAsync(FollowUp2, session))
-    {
-        Console.Write(update);
-
-        // During streaming we should be able to see updates to the chat history
-        // before the full run completes, as each service call is made and persisted.
-        PrintChatHistory(session, "During third run", ref lastChatHistorySize, ref lastConversationId);
-    }
-
-    Console.WriteLine();
-    PrintChatHistory(session, "After third run", ref lastChatHistorySize, ref lastConversationId);
-}
-
-void PrintUserMessage(string message)
-{
-    Console.ForegroundColor = ConsoleColor.Cyan;
-    Console.Write("\n[User] ");
-    Console.ResetColor();
-    Console.WriteLine(message);
-}
-
-void PrintAgentResponse(string? text)
-{
-    Console.ForegroundColor = ConsoleColor.Cyan;
-    Console.Write("\n[Agent] ");
-    Console.ResetColor();
-    Console.WriteLine(text);
-}
-
-// Helper to print the current chat history from the session.
-void PrintChatHistory(AgentSession session, string label, ref int lastChatHistorySize, ref string lastConversationId)
-{
-    if (session.TryGetInMemoryChatHistory(out var history) && history.Count != lastChatHistorySize)
-    {
-        Console.ForegroundColor = ConsoleColor.DarkGray;
-        Console.WriteLine($"\n  [{label} — Chat history: {history.Count} message(s)]");
-        foreach (var msg in history)
-        {
-            var preview = msg.Text?.Length > 80 ? msg.Text[..80] + "…" : msg.Text;
-            var contentTypes = string.Join(", ", msg.Contents.Select(c => c.GetType().Name));
-            Console.WriteLine($"    {msg.Role,-12} | {(string.IsNullOrWhiteSpace(preview) ? $"[{contentTypes}]" : preview)}");
-        }
-
-        Console.ResetColor();
-
-        lastChatHistorySize = history.Count;
-    }
-
-    if (session is ChatClientAgentSession ccaSession && ccaSession.ConversationId is not null && ccaSession.ConversationId != lastConversationId)
-    {
-        Console.ForegroundColor = ConsoleColor.DarkGray;
-        Console.WriteLine($"  [{label} — Conversation ID: {ccaSession.ConversationId}]");
-        Console.ResetColor();
-        lastConversationId = ccaSession.ConversationId;
-    }
-}

dotnet/samples/02-agents/Agents/Agent_Step19_InFunctionLoopCheckpointing/README.md

@@ -1,63 +0,0 @@
-# In-Function-Loop Checkpointing
-
-This sample demonstrates how `ChatClientAgent` persists chat history after each individual call to the AI service by default. This per-service-call persistence ensures intermediate progress is saved during the function invocation loop.
-
-## What This Sample Shows
-
-When an agent uses tools, the `FunctionInvokingChatClient` loops multiple times (service call → tool execution → service call → …). By default, chat history is persisted after each service call via the `ChatHistoryPersistingChatClient` decorator:
-
-- A `ChatHistoryPersistingChatClient` decorator is automatically inserted into the chat client pipeline
-- After each service call, the decorator notifies the `ChatHistoryProvider` (and any `AIContextProvider` instances) with the new messages
-- Only **new** messages are sent to providers on each notification — messages that were already persisted in an earlier call within the same run are deduplicated automatically
-
-To opt into end-of-run persistence instead (atomic run semantics), set `PersistChatHistoryAtEndOfRun = true` on `ChatClientAgentOptions`. In that mode, the decorator marks messages with metadata rather than persisting them immediately, and `ChatClientAgent` persists only the marked messages at the end of the run.
-
-Per-service-call persistence is useful for:
-- **Crash recovery** — if the process is interrupted mid-loop, the intermediate tool calls and results are already persisted
-- **Observability** — you can inspect the chat history while the agent is still running (e.g., during streaming)
-- **Long-running tool loops** — agents with many sequential tool calls benefit from incremental persistence
-
-## How It Works
-
-The sample asks the agent about the weather and time in three cities. The model calls the `GetWeather` and `GetTime` tools for each city, resulting in multiple service calls within a single `RunStreamingAsync` invocation. After the run completes, the sample prints the full chat history to show all the intermediate messages that were persisted along the way.
-
-### Pipeline Architecture
-
-```
-ChatClientAgent
-  └─ FunctionInvokingChatClient    (handles tool call loop)
-       └─ ChatHistoryPersistingChatClient  (persists after each service call)
-            └─ Leaf IChatClient            (Azure OpenAI)
-```
-
-## Prerequisites
-
-- .NET 10 SDK or later
-- Azure OpenAI service endpoint and model deployment
-- Azure CLI installed and authenticated
-
-**Note**: This sample uses `DefaultAzureCredential`. Sign in with `az login` before running. For production, prefer a specific credential such as `ManagedIdentityCredential`. For more information, see the [Azure CLI authentication documentation](https://learn.microsoft.com/cli/azure/authenticate-azure-cli-interactively).
-
-## Environment Variables
-
-```powershell
-$env:AZURE_OPENAI_ENDPOINT="https://your-resource.openai.azure.com/"  # Required
-$env:AZURE_OPENAI_DEPLOYMENT_NAME="gpt-4o-mini"                       # Optional, defaults to gpt-4o-mini
-```
-
-## Running the Sample
-
-```powershell
-cd dotnet/samples/02-agents/Agents/Agent_Step19_InFunctionLoopCheckpointing
-dotnet run
-```
-
-## Expected Behavior
-
-The sample runs two conversation turns:
-
-1. **First turn** — asks about weather and time in three cities. The model calls `GetWeather` and `GetTime` tools (potentially in parallel or sequentially), then provides a summary. The chat history dump after the run shows all the intermediate tool call and result messages.
-
-2. **Second turn** — asks a follow-up question ("Which city is the warmest?") that uses the persisted conversation context. The chat history dump shows the full accumulated conversation.
-
-The chat history printout uses `session.TryGetInMemoryChatHistory()` to inspect the in-memory storage.

dotnet/samples/02-agents/Agents/README.md

@@ -45,7 +45,6 @@ Before you begin, ensure you have the following prerequisites:
 |[Declarative agent](./Agent_Step16_Declarative/)|This sample demonstrates how to declaratively define an agent.|
 |[Providing additional AI Context to an agent using multiple AIContextProviders](./Agent_Step17_AdditionalAIContext/)|This sample demonstrates how to inject additional AI context into a ChatClientAgent using multiple custom AIContextProvider components that are attached to the agent.|
 |[Using compaction pipeline with an agent](./Agent_Step18_CompactionPipeline/)|This sample demonstrates how to use a compaction pipeline to efficiently limit the size of the conversation history for an agent.|
-|[In-function-loop checkpointing](./Agent_Step19_InFunctionLoopCheckpointing/)|This sample demonstrates how to persist chat history after each service call during a tool-calling loop, enabling crash recovery and mid-run observability.|
 
 ## Running the samples from the console
 

dotnet/samples/02-agents/FoundryAgents/FoundryAgents_Step01.1_Basics/Program.cs

@@ -3,7 +3,7 @@
 // This sample shows how to create and use AI agents with Azure Foundry Agents as the backend.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 

dotnet/samples/02-agents/FoundryAgents/FoundryAgents_Step01.2_Running/Program.cs

@@ -3,7 +3,7 @@
 // This sample shows how to create and use a simple AI agent with Azure Foundry Agents as the backend.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 

dotnet/samples/02-agents/FoundryAgents/FoundryAgents_Step02_MultiturnConversation/Program.cs

@@ -2,9 +2,8 @@
 
 // This sample shows how to create and use a simple AI agent with a multi-turn conversation.
 
-using Azure.AI.Extensions.OpenAI;
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 

dotnet/samples/02-agents/FoundryAgents/FoundryAgents_Step04_UsingFunctionToolsWithApprovals/Program.cs

@@ -40,7 +40,7 @@ AgentResponse response = await agent.RunAsync("What is the weather like in Amste
 
 // Check if there are any approval requests.
 // For simplicity, we are assuming here that only function approvals are pending.
-List<ToolApprovalRequestContent> approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<ToolApprovalRequestContent>().ToList();
+List<FunctionApprovalRequestContent> approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<FunctionApprovalRequestContent>().ToList();
 
 while (approvalRequests.Count > 0)
 {
@@ -48,7 +48,7 @@ while (approvalRequests.Count > 0)
     List<ChatMessage> userInputMessages = approvalRequests
         .ConvertAll(functionApprovalRequest =>
         {
-            Console.WriteLine($"The agent would like to invoke the following function, please reply Y to approve: Name {((FunctionCallContent)functionApprovalRequest.ToolCall).Name}");
+            Console.WriteLine($"The agent would like to invoke the following function, please reply Y to approve: Name {functionApprovalRequest.FunctionCall.Name}");
             bool approved = Console.ReadLine()?.Equals("Y", StringComparison.OrdinalIgnoreCase) ?? false;
             return new ChatMessage(ChatRole.User, [functionApprovalRequest.CreateResponse(approved)]);
         });
@@ -56,7 +56,7 @@ while (approvalRequests.Count > 0)
     // Pass the user input responses back to the agent for further processing.
     response = await agent.RunAsync(userInputMessages, session);
 
-    approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<ToolApprovalRequestContent>().ToList();
+    approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<FunctionApprovalRequestContent>().ToList();
 }
 
 Console.WriteLine($"\nAgent: {response}");

dotnet/samples/02-agents/FoundryAgents/FoundryAgents_Step12_Middleware/Program.cs

@@ -197,7 +197,7 @@ async Task<AgentResponse> ConsolePromptingApprovalMiddleware(IEnumerable<ChatMes
     AgentResponse response = await innerAgent.RunAsync(messages, session, options, cancellationToken);
 
     // For simplicity, we are assuming here that only function approvals are pending.
-    List<ToolApprovalRequestContent> approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<ToolApprovalRequestContent>().ToList();
+    List<FunctionApprovalRequestContent> approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<FunctionApprovalRequestContent>().ToList();
 
     while (approvalRequests.Count > 0)
     {
@@ -206,14 +206,14 @@ async Task<AgentResponse> ConsolePromptingApprovalMiddleware(IEnumerable<ChatMes
         response.Messages = approvalRequests
             .ConvertAll(functionApprovalRequest =>
             {
-                Console.WriteLine($"The agent would like to invoke the following function, please reply Y to approve: Name {((FunctionCallContent)functionApprovalRequest.ToolCall).Name}");
+                Console.WriteLine($"The agent would like to invoke the following function, please reply Y to approve: Name {functionApprovalRequest.FunctionCall.Name}");
                 bool approved = Console.ReadLine()?.Equals("Y", StringComparison.OrdinalIgnoreCase) ?? false;
                 return new ChatMessage(ChatRole.User, [functionApprovalRequest.CreateResponse(approved)]);
             });
 
         response = await innerAgent.RunAsync(response.Messages, session, options, cancellationToken);
 
-        approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<ToolApprovalRequestContent>().ToList();
+        approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<FunctionApprovalRequestContent>().ToList();
     }
 
     return response;

dotnet/samples/02-agents/FoundryAgents/FoundryAgents_Step14_CodeInterpreter/Program.cs

@@ -4,7 +4,7 @@
 
 using System.Text;
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;

dotnet/samples/02-agents/FoundryAgents/FoundryAgents_Step15_ComputerUse/Program.cs

@@ -3,7 +3,7 @@
 // This sample shows how to use Computer Use Tool with AI Agents.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;

dotnet/samples/02-agents/FoundryAgents/FoundryAgents_Step16_FileSearch/Program.cs

@@ -3,7 +3,7 @@
 // This sample shows how to use File Search Tool with AI Agents.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;

dotnet/samples/02-agents/FoundryAgents/FoundryAgents_Step17_OpenAPITools/Program.cs

@@ -3,7 +3,7 @@
 // This sample shows how to use OpenAPI Tools with AI Agents.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 using OpenAI.Responses;
@@ -72,7 +72,7 @@ const string CountriesOpenApiSpec = """
 AIProjectClient aiProjectClient = new(new Uri(endpoint), new DefaultAzureCredential());
 
 // Create the OpenAPI function definition
-var openApiFunction = new OpenApiFunctionDefinition(
+var openApiFunction = new OpenAPIFunctionDefinition(
     "get_countries",
     BinaryData.FromString(CountriesOpenApiSpec),
     new OpenAPIAnonymousAuthenticationDetails())

dotnet/samples/02-agents/FoundryAgents/FoundryAgents_Step18_BingCustomSearch/Program.cs

@@ -3,7 +3,7 @@
 // This sample shows how to use Bing Custom Search Tool with AI Agents.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 using OpenAI.Responses;
@@ -25,7 +25,7 @@ const string AgentInstructions = """
 AIProjectClient aiProjectClient = new(new Uri(endpoint), new DefaultAzureCredential());
 
 // Bing Custom Search tool parameters shared by both options
-BingCustomSearchToolOptions bingCustomSearchToolParameters = new([
+BingCustomSearchToolParameters bingCustomSearchToolParameters = new([
     new BingCustomSearchConfiguration(connectionId, instanceName)
 ]);
 

dotnet/samples/02-agents/FoundryAgents/FoundryAgents_Step19_SharePoint/Program.cs

@@ -3,7 +3,7 @@
 // This sample shows how to use SharePoint Grounding Tool with AI Agents.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 using OpenAI.Responses;

dotnet/samples/02-agents/FoundryAgents/FoundryAgents_Step20_MicrosoftFabric/Program.cs

@@ -3,7 +3,7 @@
 // This sample shows how to use Microsoft Fabric Tool with AI Agents.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 using OpenAI.Responses;

dotnet/samples/02-agents/FoundryAgents/FoundryAgents_Step21_WebSearch/Program.cs

@@ -3,7 +3,7 @@
 // This sample shows how to use the Responses API Web Search Tool with AI Agents.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;

dotnet/samples/02-agents/FoundryAgents/FoundryAgents_Step22_MemorySearch/FoundryAgents_Step22_MemorySearch.csproj

@@ -13,6 +13,7 @@
     <PackageReference Include="Microsoft.Extensions.Logging.Console" />
     <PackageReference Include="Azure.Identity" />
     <PackageReference Include="Azure.AI.Projects" />
+    <PackageReference Include="Azure.AI.Projects.OpenAI" />
   </ItemGroup>
 
   <ItemGroup>

dotnet/samples/02-agents/FoundryAgents/FoundryAgents_Step22_MemorySearch/Program.cs

@@ -4,9 +4,8 @@
 // The Memory Search Tool enables agents to recall information from previous conversations,
 // supporting user profile persistence and chat summaries across sessions.
 
-using Azure.AI.Extensions.OpenAI;
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 using OpenAI.Responses;
@@ -37,7 +36,7 @@ AIProjectClient aiProjectClient = new(new Uri(endpoint), credential);
 await EnsureMemoryStoreAsync();
 
 // Create the Memory Search tool configuration
-MemorySearchPreviewTool memorySearchTool = new(memoryStoreName, userScope) { UpdateDelayInSecs = 0 };
+MemorySearchPreviewTool memorySearchTool = new(memoryStoreName, userScope) { UpdateDelay = 0 };
 
 // Create agent using Option 1 (MEAI) or Option 2 (Native SDK)
 AIAgent agent = await CreateAgentWithMEAI();
@@ -129,8 +128,8 @@ async Task EnsureMemoryStoreAsync()
 
     MemoryUpdateResult updateResult = await aiProjectClient.MemoryStores.WaitForMemoriesUpdateAsync(
         memoryStoreName: memoryStoreName,
-        pollingInterval: 500,
-        options: memoryOptions);
+        options: memoryOptions,
+        pollingInterval: 500);
 
     if (updateResult.Status == MemoryStoreUpdateStatus.Failed)
     {

dotnet/samples/02-agents/ModelContextProtocol/FoundryAgent_Hosted_MCP/FoundryAgent_Hosted_MCP.csproj

@@ -9,12 +9,12 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Azure.AI.Projects" />
+    <PackageReference Include="Azure.AI.Agents.Persistent" />
     <PackageReference Include="Azure.Identity" />
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI.Persistent\Microsoft.Agents.AI.AzureAI.Persistent.csproj" />
   </ItemGroup>
 
 </Project>

dotnet/samples/02-agents/ModelContextProtocol/FoundryAgent_Hosted_MCP/Program.cs

@@ -4,7 +4,7 @@
 // In this case the Azure Foundry Agents service will invoke any MCP tools as required. MCP tools are not invoked by the Agent Framework.
 // The sample first shows how to use MCP tools with auto approval, and then how to set up a tool that requires approval before it can be invoked and how to approve such a tool.
 
-using Azure.AI.Projects;
+using Azure.AI.Agents.Persistent;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
@@ -16,7 +16,7 @@ var model = Environment.GetEnvironmentVariable("AZURE_AI_MODEL_DEPLOYMENT_NAME")
 // WARNING: DefaultAzureCredential is convenient for development but requires careful consideration in production.
 // In production, consider using a specific credential (e.g., ManagedIdentityCredential) to avoid
 // latency issues, unintended credential probing, and potential security risks from fallback mechanisms.
-var aiProjectClient = new AIProjectClient(new Uri(endpoint), new DefaultAzureCredential());
+var persistentAgentsClient = new PersistentAgentsClient(endpoint, new DefaultAzureCredential());
 
 // **** MCP Tool with Auto Approval ****
 // *************************************
@@ -31,8 +31,8 @@ var mcpTool = new HostedMcpServerTool(
     ApprovalMode = HostedMcpServerToolApprovalMode.NeverRequire
 };
 
-// Create a server side agent with the mcp tool, and expose it as an AIAgent.
-AIAgent agent = await aiProjectClient.CreateAIAgentAsync(
+// Create a server side persistent agent with the mcp tool, and expose it as an AIAgent.
+AIAgent agent = await persistentAgentsClient.CreateAIAgentAsync(
     model: model,
     options: new()
     {
@@ -49,7 +49,7 @@ AgentSession session = await agent.CreateSessionAsync();
 Console.WriteLine(await agent.RunAsync("Please summarize the Azure AI Agent documentation related to MCP Tool calling?", session));
 
 // Cleanup for sample purposes.
-aiProjectClient.Agents.DeleteAgent(agent.Name);
+await persistentAgentsClient.Administration.DeleteAgentAsync(agent.Id);
 
 // **** MCP Tool with Approval Required ****
 // *****************************************
@@ -64,8 +64,8 @@ var mcpToolWithApproval = new HostedMcpServerTool(
     ApprovalMode = HostedMcpServerToolApprovalMode.AlwaysRequire
 };
 
-// Create an agent with the MCP tool that requires approval.
-AIAgent agentWithRequiredApproval = await aiProjectClient.CreateAIAgentAsync(
+// Create an agent based on Azure OpenAI Responses as the backend.
+AIAgent agentWithRequiredApproval = await persistentAgentsClient.CreateAIAgentAsync(
     model: model,
     options: new()
     {
@@ -81,7 +81,7 @@ AIAgent agentWithRequiredApproval = await aiProjectClient.CreateAIAgentAsync(
 // For simplicity, we are assuming here that only mcp tool approvals are pending.
 AgentSession sessionWithRequiredApproval = await agentWithRequiredApproval.CreateSessionAsync();
 AgentResponse response = await agentWithRequiredApproval.RunAsync("Please summarize the Azure AI Agent documentation related to MCP Tool calling?", sessionWithRequiredApproval);
-List<ToolApprovalRequestContent> approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<ToolApprovalRequestContent>().ToList();
+List<McpServerToolApprovalRequestContent> approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<McpServerToolApprovalRequestContent>().ToList();
 
 while (approvalRequests.Count > 0)
 {
@@ -89,12 +89,11 @@ while (approvalRequests.Count > 0)
     List<ChatMessage> userInputResponses = approvalRequests
         .ConvertAll(approvalRequest =>
         {
-            McpServerToolCallContent mcpToolCall = (McpServerToolCallContent)approvalRequest.ToolCall!;
             Console.WriteLine($"""
                 The agent would like to invoke the following MCP Tool, please reply Y to approve.
-                ServerName: {mcpToolCall.ServerName}
-                Name: {mcpToolCall.Name}
-                Arguments: {string.Join(", ", mcpToolCall.Arguments?.Select(x => $"{x.Key}: {x.Value}") ?? [])}
+                ServerName: {approvalRequest.ToolCall.ServerName}
+                Name: {approvalRequest.ToolCall.ToolName}
+                Arguments: {string.Join(", ", approvalRequest.ToolCall.Arguments?.Select(x => $"{x.Key}: {x.Value}") ?? [])}
                 """);
             return new ChatMessage(ChatRole.User, [approvalRequest.CreateResponse(Console.ReadLine()?.Equals("Y", StringComparison.OrdinalIgnoreCase) ?? false)]);
         });
@@ -102,7 +101,7 @@ while (approvalRequests.Count > 0)
     // Pass the user input responses back to the agent for further processing.
     response = await agentWithRequiredApproval.RunAsync(userInputResponses, sessionWithRequiredApproval);
 
-    approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<ToolApprovalRequestContent>().ToList();
+    approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<McpServerToolApprovalRequestContent>().ToList();
 }
 
 Console.WriteLine($"\nAgent: {response}");

dotnet/samples/02-agents/ModelContextProtocol/ResponseAgent_Hosted_MCP/Program.cs

@@ -33,9 +33,8 @@ var mcpTool = new HostedMcpServerTool(
 AIAgent agent = new AzureOpenAIClient(
     new Uri(endpoint),
     new DefaultAzureCredential())
-     .GetResponsesClient()
+     .GetResponsesClient(deploymentName)
      .AsAIAgent(
-        model: deploymentName,
         instructions: "You answer questions by searching the Microsoft Learn content only.",
         name: "MicrosoftLearnAgent",
         tools: [mcpTool]);
@@ -61,9 +60,8 @@ var mcpToolWithApproval = new HostedMcpServerTool(
 AIAgent agentWithRequiredApproval = new AzureOpenAIClient(
     new Uri(endpoint),
     new DefaultAzureCredential())
-    .GetResponsesClient()
+    .GetResponsesClient(deploymentName)
     .AsAIAgent(
-        model: deploymentName,
         instructions: "You answer questions by searching the Microsoft Learn content only.",
         name: "MicrosoftLearnAgentWithApproval",
         tools: [mcpToolWithApproval]);
@@ -72,7 +70,7 @@ AIAgent agentWithRequiredApproval = new AzureOpenAIClient(
 // For simplicity, we are assuming here that only mcp tool approvals are pending.
 AgentSession sessionWithRequiredApproval = await agentWithRequiredApproval.CreateSessionAsync();
 AgentResponse response = await agentWithRequiredApproval.RunAsync("Please summarize the Azure AI Agent documentation related to MCP Tool calling?", sessionWithRequiredApproval);
-List<ToolApprovalRequestContent> approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<ToolApprovalRequestContent>().ToList();
+List<McpServerToolApprovalRequestContent> approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<McpServerToolApprovalRequestContent>().ToList();
 
 while (approvalRequests.Count > 0)
 {
@@ -80,12 +78,11 @@ while (approvalRequests.Count > 0)
     List<ChatMessage> userInputResponses = approvalRequests
         .ConvertAll(approvalRequest =>
         {
-            McpServerToolCallContent mcpToolCall = (McpServerToolCallContent)approvalRequest.ToolCall!;
             Console.WriteLine($"""
                 The agent would like to invoke the following MCP Tool, please reply Y to approve.
-                ServerName: {mcpToolCall.ServerName}
-                Name: {mcpToolCall.Name}
-                Arguments: {string.Join(", ", mcpToolCall.Arguments?.Select(x => $"{x.Key}: {x.Value}") ?? [])}
+                ServerName: {approvalRequest.ToolCall.ServerName}
+                Name: {approvalRequest.ToolCall.ToolName}
+                Arguments: {string.Join(", ", approvalRequest.ToolCall.Arguments?.Select(x => $"{x.Key}: {x.Value}") ?? [])}
                 """);
             return new ChatMessage(ChatRole.User, [approvalRequest.CreateResponse(Console.ReadLine()?.Equals("Y", StringComparison.OrdinalIgnoreCase) ?? false)]);
         });
@@ -93,7 +90,7 @@ while (approvalRequests.Count > 0)
     // Pass the user input responses back to the agent for further processing.
     response = await agentWithRequiredApproval.RunAsync(userInputResponses, sessionWithRequiredApproval);
 
-    approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<ToolApprovalRequestContent>().ToList();
+    approvalRequests = response.Messages.SelectMany(m => m.Contents).OfType<McpServerToolApprovalRequestContent>().ToList();
 }
 
 Console.WriteLine($"\nAgent: {response}");

dotnet/samples/03-workflows/Agents/FoundryAgent/FoundryAgent.csproj

@@ -9,13 +9,13 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Azure.AI.Projects" />
+    <PackageReference Include="Azure.AI.Agents.Persistent" />
     <PackageReference Include="Azure.Identity" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.Workflows\Microsoft.Agents.AI.Workflows.csproj" />
-    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI.Persistent\Microsoft.Agents.AI.AzureAI.Persistent.csproj" />
     <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI\Microsoft.Agents.AI.csproj" />
   </ItemGroup>
 

dotnet/samples/03-workflows/Agents/FoundryAgent/Program.cs

@@ -1,6 +1,6 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using Azure.AI.Projects;
+using Azure.AI.Agents.Persistent;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 using Microsoft.Agents.AI.Workflows;
@@ -20,63 +20,60 @@ public static class Program
 {
     private static async Task Main()
     {
-        // Set up the Azure AI Project client
+        // Set up the Azure OpenAI client
         var endpoint = Environment.GetEnvironmentVariable("AZURE_AI_PROJECT_ENDPOINT")
             ?? throw new InvalidOperationException("AZURE_AI_PROJECT_ENDPOINT is not set.");
         var deploymentName = Environment.GetEnvironmentVariable("AZURE_AI_MODEL_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
-        var aiProjectClient = new AIProjectClient(new Uri(endpoint), new AzureCliCredential());
+        var persistentAgentsClient = new PersistentAgentsClient(endpoint, new AzureCliCredential());
 
         // Create agents
-        AIAgent frenchAgent = await CreateTranslationAgentAsync("French", aiProjectClient, deploymentName);
-        AIAgent spanishAgent = await CreateTranslationAgentAsync("Spanish", aiProjectClient, deploymentName);
-        AIAgent englishAgent = await CreateTranslationAgentAsync("English", aiProjectClient, deploymentName);
+        AIAgent frenchAgent = await GetTranslationAgentAsync("French", persistentAgentsClient, deploymentName);
+        AIAgent spanishAgent = await GetTranslationAgentAsync("Spanish", persistentAgentsClient, deploymentName);
+        AIAgent englishAgent = await GetTranslationAgentAsync("English", persistentAgentsClient, deploymentName);
 
-        try
+        // Build the workflow by adding executors and connecting them
+        var workflow = new WorkflowBuilder(frenchAgent)
+            .AddEdge(frenchAgent, spanishAgent)
+            .AddEdge(spanishAgent, englishAgent)
+            .Build();
+
+        // Execute the workflow
+        await using StreamingRun run = await InProcessExecution.RunStreamingAsync(workflow, new ChatMessage(ChatRole.User, "Hello World!"));
+        // Must send the turn token to trigger the agents.
+        // The agents are wrapped as executors. When they receive messages,
+        // they will cache the messages and only start processing when they receive a TurnToken.
+        await run.TrySendMessageAsync(new TurnToken(emitEvents: true));
+        await foreach (WorkflowEvent evt in run.WatchStreamAsync())
         {
-            // Build the workflow by adding executors and connecting them
-            var workflow = new WorkflowBuilder(frenchAgent)
-                .AddEdge(frenchAgent, spanishAgent)
-                .AddEdge(spanishAgent, englishAgent)
-                .Build();
-
-            // Execute the workflow
-            await using StreamingRun run = await InProcessExecution.RunStreamingAsync(workflow, new ChatMessage(ChatRole.User, "Hello World!"));
-            // Must send the turn token to trigger the agents.
-            // The agents are wrapped as executors. When they receive messages,
-            // they will cache the messages and only start processing when they receive a TurnToken.
-            await run.TrySendMessageAsync(new TurnToken(emitEvents: true));
-            await foreach (WorkflowEvent evt in run.WatchStreamAsync())
+            if (evt is AgentResponseUpdateEvent executorComplete)
             {
-                if (evt is AgentResponseUpdateEvent executorComplete)
-                {
-                    Console.WriteLine($"{executorComplete.ExecutorId}: {executorComplete.Data}");
-                }
+                Console.WriteLine($"{executorComplete.ExecutorId}: {executorComplete.Data}");
             }
         }
-        finally
-        {
-            // Cleanup the agents created for the sample.
-            await aiProjectClient.Agents.DeleteAgentAsync(frenchAgent.Name);
-            await aiProjectClient.Agents.DeleteAgentAsync(spanishAgent.Name);
-            await aiProjectClient.Agents.DeleteAgentAsync(englishAgent.Name);
-        }
+
+        // Cleanup the agents created for the sample.
+        await persistentAgentsClient.Administration.DeleteAgentAsync(frenchAgent.Id);
+        await persistentAgentsClient.Administration.DeleteAgentAsync(spanishAgent.Id);
+        await persistentAgentsClient.Administration.DeleteAgentAsync(englishAgent.Id);
     }
 
     /// <summary>
     /// Creates a translation agent for the specified target language.
     /// </summary>
     /// <param name="targetLanguage">The target language for translation</param>
-    /// <param name="aiProjectClient">The <see cref="AIProjectClient"/> to create the agent with.</param>
+    /// <param name="persistentAgentsClient">The PersistentAgentsClient to create the agent</param>
     /// <param name="model">The model to use for the agent</param>
     /// <returns>A ChatClientAgent configured for the specified language</returns>
-    private static async Task<ChatClientAgent> CreateTranslationAgentAsync(
+    private static async Task<ChatClientAgent> GetTranslationAgentAsync(
         string targetLanguage,
-        AIProjectClient aiProjectClient,
+        PersistentAgentsClient persistentAgentsClient,
         string model)
     {
-        return await aiProjectClient.CreateAIAgentAsync(
-            name: $"{targetLanguage} Translator",
+        var agentMetadata = await persistentAgentsClient.Administration.CreateAgentAsync(
             model: model,
+            name: $"{targetLanguage} Translator",
             instructions: $"You are a translation assistant that translates the provided text to {targetLanguage}.");
+
+        return await persistentAgentsClient.GetAIAgentAsync(agentMetadata.Value.Id);
     }
 }

dotnet/samples/03-workflows/Agents/GroupChatToolApproval/Program.cs

@@ -17,7 +17,7 @@
 //
 // Demonstrate:
 // - Using custom GroupChatManager with agents that have approval-required tools.
-// - Handling ToolApprovalRequestContent in group chat scenarios.
+// - Handling FunctionApprovalRequestContent in group chat scenarios.
 // - Multi-round group chat with tool approval interruption and resumption.
 
 using System.ComponentModel;
@@ -101,16 +101,16 @@ public static class Program
             {
                 case RequestInfoEvent e:
                 {
-                    if (e.Request.TryGetDataAs(out ToolApprovalRequestContent? approvalRequestContent))
+                    if (e.Request.TryGetDataAs(out FunctionApprovalRequestContent? approvalRequestContent))
                     {
                         Console.WriteLine();
                         Console.WriteLine($"[APPROVAL REQUIRED] From agent: {e.Request.PortInfo.PortId}");
-                        Console.WriteLine($"  Tool: {((FunctionCallContent)approvalRequestContent.ToolCall).Name}");
-                        Console.WriteLine($"  Arguments: {JsonSerializer.Serialize(((FunctionCallContent)approvalRequestContent.ToolCall).Arguments)}");
+                        Console.WriteLine($"  Tool: {approvalRequestContent.FunctionCall.Name}");
+                        Console.WriteLine($"  Arguments: {JsonSerializer.Serialize(approvalRequestContent.FunctionCall.Arguments)}");
                         Console.WriteLine();
 
                         // Approve the tool call request
-                        Console.WriteLine($"Tool: {((FunctionCallContent)approvalRequestContent.ToolCall).Name} approved");
+                        Console.WriteLine($"Tool: {approvalRequestContent.FunctionCall.Name} approved");
                         await run.SendResponseAsync(e.Request.CreateResponse(approvalRequestContent.CreateResponse(approved: true)));
                     }
 

dotnet/samples/03-workflows/Agents/WorkflowAsAnAgent/WorkflowFactory.cs

@@ -41,7 +41,6 @@ internal static class WorkflowFactory
     /// <summary>
     /// Executor that aggregates the results from the concurrent agents.
     /// </summary>
-    [YieldsOutput(typeof(string))]
     private sealed class ConcurrentAggregationExecutor() :
         Executor<List<ChatMessage>>("ConcurrentAggregationExecutor"), IResettableExecutor
     {

dotnet/samples/03-workflows/Checkpoint/CheckpointAndRehydrate/WorkflowFactory.cs

@@ -41,7 +41,6 @@ internal enum NumberSignal
 /// <summary>
 /// Executor that makes a guess based on the current bounds.
 /// </summary>
-[SendsMessage(typeof(int))]
 internal sealed class GuessNumberExecutor() : Executor<NumberSignal>("Guess")
 {
     /// <summary>
@@ -105,8 +104,6 @@ internal sealed class GuessNumberExecutor() : Executor<NumberSignal>("Guess")
 /// <summary>
 /// Executor that judges the guess and provides feedback.
 /// </summary>
-[SendsMessage(typeof(NumberSignal))]
-[YieldsOutput(typeof(string))]
 internal sealed class JudgeExecutor() : Executor<int>("Judge")
 {
     private readonly int _targetNumber;

dotnet/samples/03-workflows/Checkpoint/CheckpointAndResume/WorkflowFactory.cs

@@ -41,7 +41,6 @@ internal enum NumberSignal
 /// <summary>
 /// Executor that makes a guess based on the current bounds.
 /// </summary>
-[SendsMessage(typeof(int))]
 internal sealed class GuessNumberExecutor() : Executor<NumberSignal>("Guess")
 {
     /// <summary>
@@ -105,8 +104,6 @@ internal sealed class GuessNumberExecutor() : Executor<NumberSignal>("Guess")
 /// <summary>
 /// Executor that judges the guess and provides feedback.
 /// </summary>
-[SendsMessage(typeof(NumberSignal))]
-[YieldsOutput(typeof(string))]
 internal sealed class JudgeExecutor() : Executor<int>("Judge")
 {
     private readonly int _targetNumber;

dotnet/samples/03-workflows/Checkpoint/CheckpointWithHumanInTheLoop/WorkflowFactory.cs

@@ -53,8 +53,6 @@ internal sealed class SignalWithNumber
 /// <summary>
 /// Executor that judges the guess and provides feedback.
 /// </summary>
-[SendsMessage(typeof(SignalWithNumber))]
-[YieldsOutput(typeof(string))]
 internal sealed class JudgeExecutor() : Executor<int>("Judge")
 {
     private readonly int _targetNumber;

dotnet/samples/03-workflows/Concurrent/Concurrent/Program.cs

@@ -72,8 +72,6 @@ public static class Program
 /// <summary>
 /// Executor that starts the concurrent processing by sending messages to the agents.
 /// </summary>
-[SendsMessage(typeof(ChatMessage))]
-[SendsMessage(typeof(TurnToken))]
 internal sealed partial class ConcurrentStartExecutor() :
     Executor("ConcurrentStartExecutor")
 {
@@ -99,8 +97,7 @@ internal sealed partial class ConcurrentStartExecutor() :
 /// <summary>
 /// Executor that aggregates the results from the concurrent agents.
 /// </summary>
-[YieldsOutput(typeof(string))]
-internal sealed partial class ConcurrentAggregationExecutor() :
+internal sealed class ConcurrentAggregationExecutor() :
     Executor<List<ChatMessage>>("ConcurrentAggregationExecutor")
 {
     private readonly List<ChatMessage> _messages = [];

dotnet/samples/03-workflows/Concurrent/MapReduce/Program.cs

@@ -128,7 +128,6 @@ public static class Program
 /// <summary>
 /// Splits data into roughly equal chunks based on the number of mapper nodes.
 /// </summary>
-[SendsMessage(typeof(SplitComplete))]
 internal sealed class Split(string[] mapperIds, string id) :
     Executor<string>(id)
 {
@@ -187,7 +186,6 @@ internal sealed class Split(string[] mapperIds, string id) :
 /// <summary>
 /// Maps each token to a count of 1 and writes pairs to a per-mapper file.
 /// </summary>
-[SendsMessage(typeof(MapComplete))]
 internal sealed class Mapper(string id) : Executor<SplitComplete>(id)
 {
     /// <summary>
@@ -214,7 +212,6 @@ internal sealed class Mapper(string id) : Executor<SplitComplete>(id)
 /// <summary>
 /// Groups intermediate pairs by key and partitions them across reducers.
 /// </summary>
-[SendsMessage(typeof(ShuffleComplete))]
 internal sealed class Shuffler(string[] reducerIds, string[] mapperIds, string id) :
     Executor<MapComplete>(id)
 {
@@ -314,7 +311,6 @@ internal sealed class Shuffler(string[] reducerIds, string[] mapperIds, string i
 /// <summary>
 /// Sums grouped counts per key for its assigned partition.
 /// </summary>
-[SendsMessage(typeof(ReduceComplete))]
 internal sealed class Reducer(string id) : Executor<ShuffleComplete>(id)
 {
     /// <summary>
@@ -356,7 +352,6 @@ internal sealed class Reducer(string id) : Executor<ShuffleComplete>(id)
 /// <summary>
 /// Joins all reducer outputs and yields the final output.
 /// </summary>
-[YieldsOutput(typeof(List<string>))]
 internal sealed class CompletionExecutor(string id) :
     Executor<List<ReduceComplete>>(id)
 {

dotnet/samples/03-workflows/ConditionalEdges/01_EdgeCondition/Program.cs

@@ -228,7 +228,6 @@ internal sealed class EmailAssistantExecutor : Executor<DetectionResult, EmailRe
 /// <summary>
 /// Executor that sends emails.
 /// </summary>
-[YieldsOutput(typeof(string))]
 internal sealed class SendEmailExecutor() : Executor<EmailResponse>("SendEmailExecutor")
 {
     /// <summary>
@@ -241,7 +240,6 @@ internal sealed class SendEmailExecutor() : Executor<EmailResponse>("SendEmailEx
 /// <summary>
 /// Executor that handles spam messages.
 /// </summary>
-[YieldsOutput(typeof(string))]
 internal sealed class HandleSpamExecutor() : Executor<DetectionResult>("HandleSpamExecutor")
 {
     /// <summary>

dotnet/samples/03-workflows/ConditionalEdges/02_SwitchCase/Program.cs

@@ -252,7 +252,6 @@ internal sealed class EmailAssistantExecutor : Executor<DetectionResult, EmailRe
 /// <summary>
 /// Executor that sends emails.
 /// </summary>
-[YieldsOutput(typeof(string))]
 internal sealed class SendEmailExecutor() : Executor<EmailResponse>("SendEmailExecutor")
 {
     /// <summary>
@@ -265,7 +264,6 @@ internal sealed class SendEmailExecutor() : Executor<EmailResponse>("SendEmailEx
 /// <summary>
 /// Executor that handles spam messages.
 /// </summary>
-[YieldsOutput(typeof(string))]
 internal sealed class HandleSpamExecutor() : Executor<DetectionResult>("HandleSpamExecutor")
 {
     /// <summary>
@@ -287,7 +285,6 @@ internal sealed class HandleSpamExecutor() : Executor<DetectionResult>("HandleSp
 /// <summary>
 /// Executor that handles uncertain emails.
 /// </summary>
-[YieldsOutput(typeof(string))]
 internal sealed class HandleUncertainExecutor() : Executor<DetectionResult>("HandleUncertainExecutor")
 {
     /// <summary>

dotnet/samples/03-workflows/ConditionalEdges/03_MultiSelection/Program.cs

@@ -310,7 +310,6 @@ internal sealed class EmailAssistantExecutor : Executor<AnalysisResult, EmailRes
 /// <summary>
 /// Executor that sends emails.
 /// </summary>
-[YieldsOutput(typeof(string))]
 internal sealed class SendEmailExecutor() : Executor<EmailResponse>("SendEmailExecutor")
 {
     /// <summary>
@@ -323,7 +322,6 @@ internal sealed class SendEmailExecutor() : Executor<EmailResponse>("SendEmailEx
 /// <summary>
 /// Executor that handles spam messages.
 /// </summary>
-[YieldsOutput(typeof(string))]
 internal sealed class HandleSpamExecutor() : Executor<AnalysisResult>("HandleSpamExecutor")
 {
     /// <summary>
@@ -345,7 +343,6 @@ internal sealed class HandleSpamExecutor() : Executor<AnalysisResult>("HandleSpa
 /// <summary>
 /// Executor that handles uncertain messages.
 /// </summary>
-[YieldsOutput(typeof(string))]
 internal sealed class HandleUncertainExecutor() : Executor<AnalysisResult>("HandleUncertainExecutor")
 {
     /// <summary>

dotnet/samples/03-workflows/Declarative/CustomerSupport/Program.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Extensions.AI;
 using Microsoft.Extensions.Configuration;

dotnet/samples/03-workflows/Declarative/DeepResearch/Program.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Extensions.Configuration;
 using OpenAI.Responses;
@@ -275,7 +275,7 @@ internal sealed class Program
             Tools =
             {
                 AgentTool.CreateOpenApiTool(
-                    new OpenApiFunctionDefinition(
+                    new OpenAPIFunctionDefinition(
                         "weather-forecast",
                         BinaryData.FromString(File.ReadAllText(Path.Combine(AppContext.BaseDirectory, "wttr.json"))),
                         new OpenAPIAnonymousAuthenticationDetails()))

dotnet/samples/03-workflows/Declarative/FunctionTools/Program.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Extensions.AI;
 using Microsoft.Extensions.Configuration;

dotnet/samples/03-workflows/Declarative/HostedWorkflow/Program.cs

@@ -3,9 +3,8 @@
 // Uncomment this to enable JSON checkpointing to the local file system.
 //#define CHECKPOINT_JSON
 
-using Azure.AI.Extensions.OpenAI;
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;

dotnet/samples/03-workflows/Declarative/InputArguments/Program.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Extensions.Configuration;
 using OpenAI.Responses;

dotnet/samples/03-workflows/Declarative/InvokeFunctionTool/Program.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Extensions.AI;
 using Microsoft.Extensions.Configuration;

dotnet/samples/03-workflows/Declarative/InvokeMcpTool/Program.cs

@@ -5,7 +5,7 @@
 // invoked to perform specific tasks, like searching documentation or executing operations.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Core;
 using Azure.Identity;
 using Microsoft.Agents.AI.Workflows.Declarative.Mcp;

dotnet/samples/03-workflows/Declarative/Marketing/Program.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Extensions.Configuration;
 using Shared.Foundry;

dotnet/samples/03-workflows/Declarative/StudentTeacher/Program.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Extensions.Configuration;
 using Shared.Foundry;

dotnet/samples/03-workflows/Declarative/ToolApproval/Program.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
+using Azure.AI.Projects.OpenAI;
 using Azure.Identity;
 using Microsoft.Extensions.Configuration;
 using OpenAI.Responses;

dotnet/samples/03-workflows/HumanInTheLoop/HumanInTheLoopBasic/WorkflowFactory.cs

@@ -38,8 +38,6 @@ internal enum NumberSignal
 /// <summary>
 /// Executor that judges the guess and provides feedback.
 /// </summary>
-[SendsMessage(typeof(NumberSignal))]
-[YieldsOutput(typeof(string))]
 internal sealed class JudgeExecutor() : Executor<int>("Judge")
 {
     private readonly int _targetNumber;

dotnet/samples/03-workflows/Loop/Program.cs

@@ -56,7 +56,6 @@ internal enum NumberSignal
 /// <summary>
 /// Executor that makes a guess based on the current bounds.
 /// </summary>
-[SendsMessage(typeof(int))]
 internal sealed class GuessNumberExecutor : Executor<NumberSignal>
 {
     /// <summary>
@@ -105,8 +104,6 @@ internal sealed class GuessNumberExecutor : Executor<NumberSignal>
 /// <summary>
 /// Executor that judges the guess and provides feedback.
 /// </summary>
-[SendsMessage(typeof(NumberSignal))]
-[YieldsOutput(typeof(string))]
 internal sealed class JudgeExecutor : Executor<int>
 {
     private readonly int _targetNumber;
@@ -127,7 +124,8 @@ internal sealed class JudgeExecutor : Executor<int>
         this._tries++;
         if (message == this._targetNumber)
         {
-            await context.YieldOutputAsync($"{this._targetNumber} found in {this._tries} tries!", cancellationToken);
+            await context.YieldOutputAsync($"{this._targetNumber} found in {this._tries} tries!", cancellationToken)
+                         ;
         }
         else if (message < this._targetNumber)
         {

dotnet/samples/03-workflows/SharedStates/Program.cs

@@ -99,10 +99,6 @@ internal sealed class ParagraphCountingExecutor() : Executor<string, FileStats>(
     }
 }
 
-/// <summary>
-/// The aggregation executor collects results from both executors and yields the final output.
-/// </summary>
-[YieldsOutput(typeof(string))]
 internal sealed class AggregationExecutor() : Executor<FileStats>("AggregationExecutor")
 {
     private readonly List<FileStats> _messages = [];

dotnet/samples/03-workflows/_StartHere/06_MixedWorkflowAgentsAndExecutors/Program.cs

@@ -205,8 +205,6 @@ internal sealed class TextInverterExecutor(string id) : Executor<string, string>
 /// 1. Sending ChatMessage(s)
 /// 2. Sending a TurnToken to trigger processing
 /// </summary>
-[SendsMessage(typeof(ChatMessage))]
-[SendsMessage(typeof(TurnToken))]
 internal sealed class StringToChatMessageExecutor(string id) : Executor<string>(id)
 {
     public override async ValueTask HandleAsync(string message, IWorkflowContext context, CancellationToken cancellationToken = default)
@@ -236,8 +234,6 @@ internal sealed class StringToChatMessageExecutor(string id) : Executor<string>(
 /// The AIAgentHostExecutor sends response.Messages which has runtime type List&lt;ChatMessage&gt;.
 /// The message router uses exact type matching via message.GetType().
 /// </remarks>
-[SendsMessage(typeof(ChatMessage))]
-[SendsMessage(typeof(TurnToken))]
 internal sealed class JailbreakSyncExecutor() : Executor<List<ChatMessage>>("JailbreakSync")
 {
     public override async ValueTask HandleAsync(List<ChatMessage> message, IWorkflowContext context, CancellationToken cancellationToken = default)

dotnet/samples/05-end-to-end/A2AClientServer/A2AServer/A2AServer.csproj

@@ -9,7 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Azure.AI.Projects" />
+    <PackageReference Include="Azure.AI.Agents.Persistent" />
     <PackageReference Include="Azure.Identity" />
   </ItemGroup>
 
@@ -23,7 +23,7 @@
     <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.Hosting.A2A\Microsoft.Agents.AI.Hosting.A2A.csproj" />
 
     <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.A2A\Microsoft.Agents.AI.A2A.csproj" />
-    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI\Microsoft.Agents.AI.AzureAI.csproj" />
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.AzureAI.Persistent\Microsoft.Agents.AI.AzureAI.Persistent.csproj" />
     <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
   </ItemGroup>
 

dotnet/samples/05-end-to-end/A2AClientServer/A2AServer/HostAgentFactory.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using A2A;
-using Azure.AI.Projects;
+using Azure.AI.Agents.Persistent;
 using Azure.Identity;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
@@ -12,15 +12,16 @@ namespace A2AServer;
 
 internal static class HostAgentFactory
 {
-    internal static async Task<(AIAgent, AgentCard)> CreateFoundryHostAgentAsync(string agentType, string model, string endpoint, string agentName, IList<AITool>? tools = null)
+    internal static async Task<(AIAgent, AgentCard)> CreateFoundryHostAgentAsync(string agentType, string model, string endpoint, string assistantId, IList<AITool>? tools = null)
     {
         // WARNING: DefaultAzureCredential is convenient for development but requires careful consideration in production.
         // In production, consider using a specific credential (e.g., ManagedIdentityCredential) to avoid
         // latency issues, unintended credential probing, and potential security risks from fallback mechanisms.
-        var aiProjectClient = new AIProjectClient(new Uri(endpoint), new DefaultAzureCredential());
+        var persistentAgentsClient = new PersistentAgentsClient(endpoint, new DefaultAzureCredential());
+        PersistentAgent persistentAgent = await persistentAgentsClient.Administration.GetAgentAsync(assistantId);
 
-        AIAgent agent = await aiProjectClient
-            .GetAIAgentAsync(agentName, tools: tools);
+        AIAgent agent = await persistentAgentsClient
+            .GetAIAgentAsync(persistentAgent.Id, chatOptions: new() { Tools = tools });
 
         AgentCard agentCard = agentType.ToUpperInvariant() switch
         {

dotnet/samples/05-end-to-end/A2AClientServer/A2AServer/Program.cs

@@ -8,16 +8,16 @@ using Microsoft.Extensions.AI;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 
-string agentName = string.Empty;
+string agentId = string.Empty;
 string agentType = string.Empty;
 
 for (var i = 0; i < args.Length; i++)
 {
-    if (args[i].Equals("--agentName", StringComparison.OrdinalIgnoreCase) && i + 1 < args.Length)
+    if (args[i].StartsWith("--agentId", StringComparison.InvariantCultureIgnoreCase) && i + 1 < args.Length)
     {
-        agentName = args[++i];
+        agentId = args[++i];
     }
-    else if (args[i].Equals("--agentType", StringComparison.OrdinalIgnoreCase) && i + 1 < args.Length)
+    else if (args[i].StartsWith("--agentType", StringComparison.InvariantCultureIgnoreCase) && i + 1 < args.Length)
     {
         agentType = args[++i];
     }
@@ -50,13 +50,13 @@ IList<AITool> tools =
 AIAgent hostA2AAgent;
 AgentCard hostA2AAgentCard;
 
-if (!string.IsNullOrEmpty(endpoint) && !string.IsNullOrEmpty(agentName))
+if (!string.IsNullOrEmpty(endpoint) && !string.IsNullOrEmpty(agentId))
 {
     (hostA2AAgent, hostA2AAgentCard) = agentType.ToUpperInvariant() switch
     {
-        "INVOICE" => await HostAgentFactory.CreateFoundryHostAgentAsync(agentType, model, endpoint, agentName, tools),
-        "POLICY" => await HostAgentFactory.CreateFoundryHostAgentAsync(agentType, model, endpoint, agentName),
-        "LOGISTICS" => await HostAgentFactory.CreateFoundryHostAgentAsync(agentType, model, endpoint, agentName),
+        "INVOICE" => await HostAgentFactory.CreateFoundryHostAgentAsync(agentType, model, endpoint, agentId, tools),
+        "POLICY" => await HostAgentFactory.CreateFoundryHostAgentAsync(agentType, model, endpoint, agentId),
+        "LOGISTICS" => await HostAgentFactory.CreateFoundryHostAgentAsync(agentType, model, endpoint, agentId),
         _ => throw new ArgumentException($"Unsupported agent type: {agentType}"),
     };
 }
@@ -101,7 +101,7 @@ else if (!string.IsNullOrEmpty(apiKey))
 }
 else
 {
-    throw new ArgumentException("Either A2AServer:ApiKey or A2AServer:ConnectionString & agentName must be provided");
+    throw new ArgumentException("Either A2AServer:ApiKey or A2AServer:ConnectionString & agentId must be provided");
 }
 
 var a2aTaskManager = app.MapA2A(

dotnet/samples/05-end-to-end/A2AClientServer/README.md

@@ -90,15 +90,15 @@ $env:AZURE_AI_PROJECT_ENDPOINT="https://ai-foundry-your-project.services.ai.azur
 Use the following commands to run each A2A server
 
 ```bash
-dotnet run --urls "http://localhost:5000;https://localhost:5010" --agentName "<Invoice Agent Name>" --agentType "invoice" --no-build
+dotnet run --urls "http://localhost:5000;https://localhost:5010" --agentId "<Invoice Agent Id>" --agentType "invoice" --no-build
 ```
 
 ```bash
-dotnet run --urls "http://localhost:5001;https://localhost:5011" --agentName "<Policy Agent Name>" --agentType "policy" --no-build
+dotnet run --urls "http://localhost:5001;https://localhost:5011" --agentId "<Policy Agent Id>" --agentType "policy" --no-build
 ```
 
 ```bash
-dotnet run --urls "http://localhost:5002;https://localhost:5012" --agentName "<Logistics Agent Name>" --agentType "logistics" --no-build
+dotnet run --urls "http://localhost:5002;https://localhost:5012" --agentId "<Logistics Agent Id>" --agentType "logistics" --no-build
 ```
 
 ### Testing the Agents using the Rest Client

dotnet/samples/05-end-to-end/AgentWebChat/AgentWebChat.Web/OpenAIResponsesAgentClient.cs

@@ -27,7 +27,7 @@ internal sealed class OpenAIResponsesAgentClient(HttpClient httpClient) : AgentC
             Transport = new HttpClientPipelineTransport(httpClient)
         };
 
-        var openAiClient = new ResponsesClient(credential: new ApiKeyCredential("dummy-key"), options: options).AsIChatClient(agentName);
+        var openAiClient = new ResponsesClient(model: agentName, credential: new ApiKeyCredential("dummy-key"), options: options).AsIChatClient();
         var chatOptions = new ChatOptions()
         {
             ConversationId = sessionId

dotnet/samples/05-end-to-end/AgentWithPurview/Program.cs

@@ -30,8 +30,8 @@ TokenCredential browserCredential = new InteractiveBrowserCredential(
 using IChatClient client = new AzureOpenAIClient(
     new Uri(endpoint),
     new DefaultAzureCredential())
-    .GetResponsesClient()
-    .AsIChatClient(deploymentName)
+    .GetResponsesClient(deploymentName)
+    .AsIChatClient()
     .AsBuilder()
     .WithPurview(browserCredential, new PurviewSettings("Agent Framework Test App"))
     .Build();

dotnet/samples/05-end-to-end/HostedAgents/AgentThreadAndHITL/AgentThreadAndHITL.csproj

@@ -36,10 +36,10 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Azure.AI.AgentServer.AgentFramework" Version="1.0.0-beta.11" />
-    <PackageReference Include="Azure.AI.OpenAI" Version="2.9.0-beta.1" />
+    <PackageReference Include="Azure.AI.AgentServer.AgentFramework" Version="1.0.0-beta.9" />
+    <PackageReference Include="Azure.AI.OpenAI" Version="2.8.0-beta.1" />
     <PackageReference Include="Azure.Identity" Version="1.17.1" />
-    <PackageReference Include="Microsoft.Agents.AI.OpenAI" Version="1.0.0-rc4" />
+    <PackageReference Include="Microsoft.Agents.AI.OpenAI" Version="1.0.0-rc1" />
   </ItemGroup>
 
   <!-- Add analyzers with compatible versions -->

dotnet/samples/05-end-to-end/HostedAgents/AgentWithHostedMCP/AgentWithHostedMCP.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
@@ -35,10 +35,10 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Azure.AI.AgentServer.AgentFramework" Version="1.0.0-beta.11" />
+    <PackageReference Include="Azure.AI.AgentServer.AgentFramework" Version="1.0.0-beta.9" />
     <PackageReference Include="Azure.AI.OpenAI" Version="2.8.0-beta.1" />
     <PackageReference Include="Azure.Identity" Version="1.17.1" />
-    <PackageReference Include="Microsoft.Agents.AI.OpenAI" Version="1.0.0-rc4" />
+    <PackageReference Include="Microsoft.Agents.AI.OpenAI" Version="1.0.0-rc1" />
   </ItemGroup>
 
   <!-- Add analyzers with compatible versions -->

dotnet/samples/05-end-to-end/HostedAgents/AgentWithLocalTools/AgentWithLocalTools.csproj

@@ -36,11 +36,11 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Azure.AI.AgentServer.AgentFramework" Version="1.0.0-beta.11" />
-    <PackageReference Include="Azure.AI.Projects" Version="2.0.0-beta.1" />
-    <PackageReference Include="Azure.AI.OpenAI" Version="2.9.0-beta.1" />
+    <PackageReference Include="Azure.AI.AgentServer.AgentFramework" Version="1.0.0-beta.9" />
+    <PackageReference Include="Azure.AI.Projects" Version="1.2.0-beta.5" />
+    <PackageReference Include="Azure.AI.OpenAI" Version="2.8.0-beta.1" />
     <PackageReference Include="Azure.Identity" Version="1.17.1" />
-    <PackageReference Include="Microsoft.Agents.AI.OpenAI" Version="1.0.0-rc4" />
+    <PackageReference Include="Microsoft.Agents.AI.OpenAI" Version="1.0.0-rc1" />
   </ItemGroup>
 
   <!-- Add analyzers with compatible versions -->

dotnet/samples/05-end-to-end/HostedAgents/AgentWithTextSearchRag/AgentWithTextSearchRag.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
@@ -35,10 +35,10 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Azure.AI.AgentServer.AgentFramework" Version="1.0.0-beta.11" />
-    <PackageReference Include="Azure.AI.OpenAI" Version="2.9.0-beta.1" />
+    <PackageReference Include="Azure.AI.AgentServer.AgentFramework" Version="1.0.0-beta.9" />
+    <PackageReference Include="Azure.AI.OpenAI" Version="2.7.0-beta.2" />
     <PackageReference Include="Azure.Identity" Version="1.17.1" />
-    <PackageReference Include="Microsoft.Agents.AI.OpenAI" Version="1.0.0-rc4" />
+    <PackageReference Include="Microsoft.Agents.AI.OpenAI" Version="1.0.0-rc1" />
   </ItemGroup>
 
   <!-- Add analyzers with compatible versions -->

dotnet/samples/05-end-to-end/HostedAgents/AgentWithTools/AgentWithTools.csproj

@@ -0,0 +1,68 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+
+    <!-- 
+      Disable central package management for this project.
+      This project requires explicit package references with versions specified inline rather than 
+      inheriting them from Directory.Packages.props. This is necessary because a Docker image will 
+      be created from this project, and the Docker build process only has access to this folder 
+      and cannot access parent folders where Directory.Packages.props resides.
+    -->
+    <ManagePackageVersionsCentrally>false</ManagePackageVersionsCentrally>
+  </PropertyGroup>
+
+  <!-- 
+    Remove analyzer PackageReference items inherited from Directory.Packages.props.
+    Note: ManagePackageVersionsCentrally only controls PackageVersion items, not PackageReference items.
+    Directory.Packages.props contains both PackageVersion and PackageReference entries for analyzers,
+    and the PackageReference items are always inherited through MSBuild imports regardless of the 
+    ManagePackageVersionsCentrally setting. We must explicitly remove them before adding our own versions.
+  -->
+  <ItemGroup>
+    <PackageReference Remove="Microsoft.CodeAnalysis.NetAnalyzers" />
+    <PackageReference Remove="Microsoft.VisualStudio.Threading.Analyzers" />
+    <PackageReference Remove="xunit.analyzers" />
+    <PackageReference Remove="Moq.Analyzers" />
+    <PackageReference Remove="Roslynator.Analyzers" />
+    <PackageReference Remove="Roslynator.CodeAnalysis.Analyzers" />
+    <PackageReference Remove="Roslynator.Formatting.Analyzers" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.AgentServer.AgentFramework" Version="1.0.0-beta.9" />
+    <PackageReference Include="Azure.AI.OpenAI" Version="2.8.0-beta.1" />
+    <PackageReference Include="Azure.Identity" Version="1.17.1" />
+    <PackageReference Include="Microsoft.Agents.AI.OpenAI" Version="1.0.0-rc1" />
+  </ItemGroup>
+
+  <!-- Add analyzers with compatible versions -->
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="10.0.100">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.14.15">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Roslynator.Analyzers" Version="4.14.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Roslynator.CodeAnalysis.Analyzers" Version="4.14.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Roslynator.Formatting.Analyzers" Version="4.14.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+</Project>

dotnet/samples/05-end-to-end/HostedAgents/AgentWithTools/Dockerfile

@@ -0,0 +1,20 @@
+# Build the application
+FROM mcr.microsoft.com/dotnet/sdk:10.0-alpine AS build
+WORKDIR /src
+
+# Copy files from the current directory on the host to the working directory in the container
+COPY . .
+
+RUN dotnet restore
+RUN dotnet build -c Release --no-restore
+RUN dotnet publish -c Release --no-build -o /app -f net10.0
+
+# Run the application
+FROM mcr.microsoft.com/dotnet/aspnet:10.0-alpine AS final
+WORKDIR /app
+
+# Copy everything needed to run the app from the "build" stage.
+COPY --from=build /app .
+
+EXPOSE 8088
+ENTRYPOINT ["dotnet", "AgentWithTools.dll"]

dotnet/samples/05-end-to-end/HostedAgents/AgentWithTools/Program.cs

@@ -0,0 +1,46 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample demonstrates how to use Foundry tools (MCP and code interpreter)
+// with an AI agent hosted using the Azure AI AgentServer SDK.
+
+using Azure.AI.AgentServer.AgentFramework.Extensions;
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+
+string openAiEndpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+string deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+string toolConnectionId = Environment.GetEnvironmentVariable("MCP_TOOL_CONNECTION_ID") ?? throw new InvalidOperationException("MCP_TOOL_CONNECTION_ID is not set.");
+
+// WARNING: DefaultAzureCredential is convenient for development but requires careful consideration in production.
+// In production, consider using a specific credential (e.g., ManagedIdentityCredential) to avoid
+// latency issues, unintended credential probing, and potential security risks from fallback mechanisms.
+DefaultAzureCredential credential = new();
+
+IChatClient chatClient = new AzureOpenAIClient(new Uri(openAiEndpoint), credential)
+    .GetChatClient(deploymentName)
+    .AsIChatClient()
+    .AsBuilder()
+    .UseFoundryTools(new { type = "mcp", project_connection_id = toolConnectionId }, new { type = "code_interpreter" })
+    .UseOpenTelemetry(sourceName: "Agents", configure: (cfg) => cfg.EnableSensitiveData = true)
+    .Build();
+
+AIAgent agent = chatClient.AsAIAgent(
+      name: "AgentWithTools",
+      instructions: @"You are a helpful assistant with access to tools for fetching Microsoft documentation.
+
+  IMPORTANT: When the user asks about Microsoft Learn articles or documentation:
+  1. You MUST use the microsoft_docs_fetch tool to retrieve the actual content
+  2. Do NOT rely on your training data
+  3. Always fetch the latest information from the provided URL
+
+  Available tools:
+  - microsoft_docs_fetch: Fetches and converts Microsoft Learn documentation
+  - microsoft_docs_search: Searches Microsoft/Azure documentation
+  - microsoft_code_sample_search: Searches for code examples")
+      .AsBuilder()
+      .UseOpenTelemetry(sourceName: "Agents", configure: (cfg) => cfg.EnableSensitiveData = true)
+      .Build();
+
+await agent.RunAIAgentAsync(telemetrySourceName: "Agents");

dotnet/samples/05-end-to-end/HostedAgents/AgentWithTools/README.md

@@ -0,0 +1,45 @@
+# What this sample demonstrates
+
+This sample demonstrates how to use Foundry tools with an AI agent via the `UseFoundryTools` extension. The agent is configured with two tool types: an MCP (Model Context Protocol) connection for fetching Microsoft Learn documentation and a code interpreter for running code when needed.
+
+Key features:
+
+- Configuring Foundry tools using `UseFoundryTools` with MCP and code interpreter
+- Connecting to an external MCP tool via a Foundry project connection
+- Using `DefaultAzureCredential` for Azure authentication
+- OpenTelemetry instrumentation for both the chat client and agent
+
+> For common prerequisites and setup instructions, see the [Hosted Agent Samples README](../README.md).
+
+## Prerequisites
+
+In addition to the common prerequisites:
+
+1. An **Azure AI Foundry project** with a chat model deployed (e.g., `gpt-5.2`, `gpt-4o-mini`)
+2. The **Azure AI Developer** role assigned on the Foundry resource (includes the `agents/write` data action required by `UseFoundryTools`)
+3. An **MCP tool connection** configured in your Foundry project pointing to `https://learn.microsoft.com/api/mcp`
+
+## Environment Variables
+
+In addition to the common environment variables in the root README:
+
+```powershell
+# Your Azure AI Foundry project endpoint (required by UseFoundryTools)
+$env:AZURE_AI_PROJECT_ENDPOINT="https://your-resource.services.ai.azure.com/api/projects/your-project"
+
+# Chat model deployment name (defaults to gpt-4o-mini if not set)
+$env:AZURE_OPENAI_DEPLOYMENT_NAME="gpt-4o-mini"
+
+# The MCP tool connection name (just the name, not the full ARM resource ID)
+$env:MCP_TOOL_CONNECTION_ID="SampleMCPTool"
+```
+
+## How It Works
+
+1. An `AzureOpenAIClient` is created with `DefaultAzureCredential` and used to get a chat client
+2. The chat client is wrapped with `UseFoundryTools` which registers two Foundry tool types:
+   - **MCP connection**: Connects to an external MCP server (Microsoft Learn) via the project connection name, providing documentation fetch and search capabilities
+   - **Code interpreter**: Allows the agent to execute code snippets when needed
+3. `UseFoundryTools` resolves the connection using `AZURE_AI_PROJECT_ENDPOINT` internally
+4. A `ChatClientAgent` is created with instructions guiding it to use the MCP tools for documentation queries
+5. The agent is hosted using `RunAIAgentAsync` which exposes the OpenAI Responses-compatible API endpoint

dotnet/samples/05-end-to-end/HostedAgents/AgentWithTools/agent.yaml

@@ -0,0 +1,31 @@
+name: AgentWithTools
+displayName: "Agent with Tools"
+description: >
+  An AI agent that uses Foundry tools (MCP and code interpreter) with Azure OpenAI.
+  The agent can fetch Microsoft Learn documentation and run code when needed.
+metadata:
+  authors:
+    - Microsoft Agent Framework Team
+  tags:
+    - Azure AI AgentServer
+    - Microsoft Agent Framework
+    - Tools
+    - MCP
+    - Code Interpreter
+template:
+  kind: hosted
+  name: AgentWithTools
+  protocols:
+    - protocol: responses
+      version: v1
+  environment_variables:
+    - name: AZURE_OPENAI_ENDPOINT
+      value: ${AZURE_OPENAI_ENDPOINT}
+    - name: AZURE_OPENAI_DEPLOYMENT_NAME
+      value: gpt-4o-mini
+    - name: MCP_TOOL_CONNECTION_ID
+      value: ${MCP_TOOL_CONNECTION_ID}
+resources:
+  - name: "gpt-4o-mini"
+    kind: model
+    id: gpt-4o-mini

dotnet/samples/05-end-to-end/HostedAgents/AgentWithTools/run-requests.http

@@ -0,0 +1,30 @@
+@host = http://localhost:8088
+@endpoint = {{host}}/responses
+
+### Health Check
+GET {{host}}/readiness
+
+### Simple string input
+POST {{endpoint}}
+Content-Type: application/json
+{
+    "input": "Please use the microsoft_docs_fetch tool to fetch and summarize the Microsoft Learn article at https://learn.microsoft.com/azure/ai-services/openai/overview"
+}
+
+### Explicit input
+POST {{endpoint}}
+Content-Type: application/json
+{
+    "input": [
+        {
+            "type": "message",
+            "role": "user",
+            "content": [
+                {
+                    "type": "input_text",
+                    "text": "Please use the microsoft_docs_fetch tool to fetch and summarize the Microsoft Learn article at https://learn.microsoft.com/azure/ai-services/openai/overview"
+                }
+            ]
+        }
+    ]
+}

dotnet/samples/05-end-to-end/HostedAgents/AgentsInWorkflows/AgentsInWorkflows.csproj

@@ -35,10 +35,10 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Azure.AI.AgentServer.AgentFramework" Version="1.0.0-beta.11" />
-    <PackageReference Include="Azure.AI.OpenAI" Version="2.9.0-beta.1" />
+    <PackageReference Include="Azure.AI.AgentServer.AgentFramework" Version="1.0.0-beta.9" />
+    <PackageReference Include="Azure.AI.OpenAI" Version="2.7.0-beta.2" />
     <PackageReference Include="Azure.Identity" Version="1.17.1" />
-    <PackageReference Include="Microsoft.Agents.AI.OpenAI" Version="1.0.0-rc4" />
+    <PackageReference Include="Microsoft.Agents.AI.OpenAI" Version="1.0.0-rc1" />
   </ItemGroup>
 
   <!-- Add analyzers with compatible versions -->

dotnet/samples/05-end-to-end/HostedAgents/FoundryMultiAgent/FoundryMultiAgent.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFrameworks>net10.0</TargetFrameworks>
@@ -33,12 +33,12 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Azure.AI.AgentServer.AgentFramework" Version="1.0.0-beta.11" />
-    <PackageReference Include="Azure.AI.Projects" Version="2.0.0-beta.1" />
+    <PackageReference Include="Azure.AI.AgentServer.AgentFramework" Version="1.0.0-beta.8" />
+    <PackageReference Include="Azure.AI.Projects" Version="1.2.0-beta.5" />
     <PackageReference Include="Azure.Identity" Version="1.17.1" />
-    <PackageReference Include="Microsoft.Agents.AI" Version="1.0.0-rc4" />
-    <PackageReference Include="Microsoft.Agents.AI.AzureAI" Version="1.0.0-rc4" />
-    <PackageReference Include="Microsoft.Agents.AI.Workflows" Version="1.0.0-rc4" />
+    <PackageReference Include="Microsoft.Agents.AI" Version="1.0.0-preview.251219.1" />
+    <PackageReference Include="Microsoft.Agents.AI.AzureAI" Version="1.0.0-preview.251219.1" />
+    <PackageReference Include="Microsoft.Agents.AI.Workflows" Version="1.0.0-preview.251219.1" />
     <PackageReference Include="OpenTelemetry" Version="1.12.0" />
     <PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.12.0" />
   </ItemGroup>