docs: add Workflows unit-test coverage summary and incremental plan

Agent-Logs-Url: https://github.com/microsoft/agent-framework/sessions/0cf188fb-1c65-4d0c-8aa3-8eec87aaaa6c

Co-authored-by: lokitoth <6936551+lokitoth@users.noreply.github.com>

.github/workflows/issue-triage.yml

@@ -149,14 +149,16 @@ jobs:
             --apply-labels
 
       - name: Stop after spam gate
-        if: ${{ steps.spam.outputs.allow_triage != 'true' }}
+        if: ${{ steps.spam.outputs.decision != 'allow' }}
         shell: bash
+        env:
+          SPAM_DECISION: ${{ steps.spam.outputs.decision }}
         run: |
-          echo "Stopping: issue triage preflight did not allow automation."
+          echo "Stopping: spam gate decided: ${SPAM_DECISION}"
           exit 1
 
       - name: Reproduce reported issue
-        if: ${{ steps.spam.outputs.allow_triage == 'true' }}
+        if: ${{ steps.spam.outputs.decision == 'allow' }}
         id: repro
         working-directory: ${{ env.DEVFLOW_PATH }}
         env:

docs/decisions/0026-hosted-session-identity-context.md

@@ -1,84 +0,0 @@
----
-status: accepted
-contact: rogerbarreto
-date: 2026-05-07
-deciders: rogerbarreto
-consulted: []
-informed: []
----
-
-# Hosted session identity context for Foundry Hosting
-
-## Context and Problem Statement
-
-Server-hosted Foundry agents need a way to scope per-user state (most notably `FoundryMemoryProvider` memories) by the end user that initiated the request. The Foundry platform already injects `x-agent-user-isolation-key` and `x-agent-chat-isolation-key` headers on every Responses request, but the agent-framework hosting layer did not surface those values to `AIContextProvider` instances. The provider's `stateInitializer` only received an `AgentSession?` with no identity attached, so per-user scoping was impossible without out-of-band plumbing.
-
-## Decision Drivers
-
-- Memory and any future user-private context must be partitioned per end user without per-sample boilerplate.
-- The identity must be **read-only** from the perspective of `AIContextProvider`s, so a buggy or hostile provider cannot escalate or leak across users.
-- The persisted session must validate against the live request on every resume to defend against session-id leak and in-process tampering.
-- The change must work for every existing hosted-agent type (`ChatClientAgent`, `FoundryAgent`, future ones) without per-type refactoring of cast-heavy code paths in `Microsoft.Agents.AI`.
-- Local Docker debugging must remain possible when the platform headers are absent.
-
-## Considered Options
-
-1. **`HostedSessionContext` stored in `AgentSessionStateBag`, exposed via a public read accessor and an `internal` setter.** Hosting writes once on session creation and validates on every resume.
-2. **Specialised `HostedAgentSession : AgentSession` wrapper** that carries `UserId`/`ChatId` properties, with `GetService<ChatClientAgentSession>()` as the unwrap escape hatch.
-3. **New property on `AgentSession` base class** (`HostedSessionContext? HostedContext { get; internal set; }`).
-4. **AsyncLocal middleware** that reads the headers and stuffs them into a per-request `AsyncLocal<HostedSessionContext>` consumed by the provider.
-
-For the source of identity:
-- A. The platform-injected `IsolationContext` exposed by `ResponseContext.Isolation` (typed `UserIsolationKey`/`ChatIsolationKey`).
-- B. The OpenAI Responses spec's top-level `request.User` field.
-- C. A custom HTTP header `x-client-user`.
-
-## Decision Outcome
-
-**Option 1** was chosen for the storage shape, sourced from **Option A** (`ResponseContext.Isolation`).
-
-Rationale:
-
-- **Wrapper rejected (Option 2).** `ChatClientAgentSession` is `sealed` and `ChatClientAgent` rejects any other session type via direct `is not ChatClientAgentSession` checks at multiple call sites. Wrapping would force non-trivial refactors across `Microsoft.Agents.AI` and a corresponding repeat for every other agent type.
-- **Base-class property rejected (Option 3).** Leaks "hosted" semantics into the universal `AgentSession` abstraction used by Durable, A2A, and CopilotStudio agents that have no notion of a hosted user.
-- **AsyncLocal rejected (Option 4).** Surfaces the concept only locally, requires every consumer to re-implement the bridge, and cannot be enforced as read-only.
-- **`request.User` rejected (Option B).** Set by the caller, not the platform. Forging it client-side trivially defeats per-user partitioning.
-- **`x-client-user` rejected (Option C).** Non-standard, requires custom HTTP plumbing, and duplicates the platform-provided isolation contract.
-
-Implementation summary in `Microsoft.Agents.AI.Foundry.Hosting`:
-
-| Type | Visibility | Purpose |
-|---|---|---|
-| `HostedSessionContext` | public sealed | Captures `UserId` and `ChatId` (both required, non-whitespace). |
-| `HostedSessionContextExtensions.GetHostedContext` | public | Read accessor for `AIContextProvider`s. |
-| `HostedSessionContextExtensions.SetHostedContext` | internal | Writer reserved for the hosting assembly. Backed by `AgentSessionStateBag` under a well-known key for serialisation. |
-| `HostedSessionIsolationKeyProvider` (abstract) | public | DI-resolvable factory. Async signature: `ValueTask<HostedSessionContext?> GetKeysAsync(ResponseContext, CreateResponse, CancellationToken)`. |
-| `PlatformHostedSessionIsolationKeyProvider` | internal sealed | Default implementation. Maps `context.Isolation.UserIsolationKey` and `context.Isolation.ChatIsolationKey`. Returns `null` when either is absent. |
-
-Behaviour added to `AgentFrameworkResponseHandler.CreateAsync`:
-
-1. Resolve `HostedSessionIsolationKeyProvider` from DI; fall back to `PlatformHostedSessionIsolationKeyProvider`.
-2. Call `GetKeysAsync(context, request, cancellationToken)`. A `null` result throws `InvalidOperationException` (becomes 500). A null/whitespace `UserId` or `ChatId` is rejected by `HostedSessionContext`'s constructor.
-3. Branch on the **session's existing context**, not on whether a `conversation_id` was supplied:
-   - **No session (`session is null`):** nothing to stamp; skip.
-   - **Session present but un-stamped (`GetHostedContext() is null`):** treat as fresh. This covers both newly-created sessions and pre-existing sessions whose `conversation_id` was provisioned externally (e.g. via `conversations.CreateProjectConversationAsync()`) before the first hosted-agent request. Stamp the resolved identity now.
-   - **Session present with stamped context:** strict resume. The persisted `UserId` and `ChatId` must equal the resolved values exactly. Mismatch throws `ResponsesApiException` with status 403 and body `Hosted session identity context mismatch`.
-
-## Consequences
-
-Positive:
-
-- Per-user memory partitioning works out of the box for any agent that consumes a `Microsoft.Agents.AI.Foundry.FoundryMemoryProvider` configured to read `session.GetHostedContext().UserId`.
-- Cross-user session-id leak and in-process tampering of the persisted identity both surface as a 403 with a deliberately uninformative body.
-- The identity is opaque to the framework, matching the platform's semantics. The framework never inspects user identity; the `IsolationContext` keys are pre-partitioned per agent.
-
-Negative:
-
-- Every existing hosted sample fails locally without a `HostedSessionIsolationKeyProvider` registered, because the platform headers are absent outside the platform. Mitigated by shipping `Hosted_Shared_Contributor_Setup` with `DevTemporaryLocalSessionIsolationKeyProvider` and `AddDevTemporaryLocalContributorSetup`, and migrating all 9 existing responses samples.
-- An attacker who can plant an un-stamped session under a victim's `conversation_id` *before* the victim's first hosted-agent request would be stamped with the attacker's identity on that first request. This is not a regression vs. behaviour without this contract, and is mitigated in practice because the `conversation_id` namespace is allocated by the platform per project. Once a session is stamped, the strict equality check fully defends the resume path.
-
-## Out of scope
-
-- Per-request `User` field on `CreateResponse` is intentionally not consumed; only the platform `IsolationContext` headers carry trustworthy identity.
-- Generic (non-Foundry) hosting layers can re-define an equivalent type if needed; nothing in this ADR is moved into `Microsoft.Agents.AI.Hosting` because `Microsoft.Agents.AI.Foundry.Hosting` does not depend on it.
-- HMAC tamper signatures over the persisted context are not implemented; comparison against `ResponseContext.Isolation` on every request is sufficient because the platform sets those headers at the trust boundary.

dotnet/agent-framework-dotnet.slnx

@@ -242,7 +242,6 @@
     <Project Path="samples/03-workflows/Declarative/HostedWorkflow/HostedWorkflow.csproj" />
     <Project Path="samples/03-workflows/Declarative/InputArguments/InputArguments.csproj" />
     <Project Path="samples/03-workflows/Declarative/InvokeFunctionTool/InvokeFunctionTool.csproj" />
-    <Project Path="samples/03-workflows/Declarative/InvokeFoundryToolboxMcp/InvokeFoundryToolboxMcp.csproj" />
     <Project Path="samples/03-workflows/Declarative/InvokeHttpRequest/InvokeHttpRequest.csproj" />
     <Project Path="samples/03-workflows/Declarative/InvokeMcpTool/InvokeMcpTool.csproj" />
     <Project Path="samples/03-workflows/Declarative/Marketing/Marketing.csproj" />
@@ -327,15 +326,9 @@
   <Folder Name="/Samples/04-hosting/FoundryHostedAgents/responses/Hosted-McpTools/">
     <Project Path="samples/04-hosting/FoundryHostedAgents/responses/Hosted-McpTools/HostedMcpTools.csproj" />
   </Folder>
-  <Folder Name="/Samples/04-hosting/FoundryHostedAgents/responses/Hosted-MemoryAgent/">
-    <Project Path="samples/04-hosting/FoundryHostedAgents/responses/Hosted-MemoryAgent/HostedMemoryAgent.csproj" />
-  </Folder>
   <Folder Name="/Samples/04-hosting/FoundryHostedAgents/responses/Hosted-Observability/">
     <Project Path="samples/04-hosting/FoundryHostedAgents/responses/Hosted-Observability/HostedObservability.csproj" />
   </Folder>
-  <Folder Name="/Samples/04-hosting/FoundryHostedAgents/responses/Hosted_Shared_Contributor_Setup/">
-    <Project Path="samples/04-hosting/FoundryHostedAgents/responses/Hosted_Shared_Contributor_Setup/Hosted_Shared_Contributor_Setup.csproj" />
-  </Folder>
   <Folder Name="/Samples/04-hosting/FoundryHostedAgents/responses/Hosted-Toolbox/">
     <Project Path="samples/04-hosting/FoundryHostedAgents/responses/Hosted-Toolbox/HostedToolbox.csproj" />
   </Folder>

dotnet/docs/workflows/wf-coverage-plan.md

@@ -0,0 +1,383 @@
+# Workflows Unit Test Coverage — Incremental Plan
+
+Companion to [`wf-coverage-summary.md`](./wf-coverage-summary.md). That document
+is the snapshot; this document is the proposal for **how to close the gap**
+between today's `Microsoft.Agents.AI.Workflows` coverage (79.7% line / 67.2%
+branch) and the team target (85%) and personal stretch target (90%).
+
+## Goals
+
+1. Reach **≥85% line coverage** on `Microsoft.Agents.AI.Workflows`, with
+   branch coverage trending toward the same threshold.
+2. Stretch to **≥90% line coverage**.
+3. Prefer tests that exercise **public APIs** through their documented entry
+   points rather than tests that bind to internals.
+4. Keep each PR **small and reviewable** (a single class or a small group of
+   tightly related classes), so coverage progresses incrementally rather than
+   in one large unreviewable change.
+
+## Out of scope (covered by pending PRs — do not duplicate)
+
+The following classes are already addressed by in-flight PRs and are
+**explicitly excluded** from every wave below. Re-check them once the PR(s)
+merge before adding any new tests.
+
+- `RouteBuilder` — [#5824](https://github.com/microsoft/agent-framework/pull/5824)
+- `WorkflowBuilderExtensions` (`ForwardMessage`, `ForwardExcept`, `AddChain`,
+  `AddExternalCall`, `AddSwitch`) and `SwitchBuilder` —
+  [#5826](https://github.com/microsoft/agent-framework/pull/5826)
+- `MagenticWorkflowBuilder`, `MagenticOrchestrator`, `MagenticTaskContext`,
+  and the Magentic event/state record types —
+  [#5833](https://github.com/microsoft/agent-framework/pull/5833)
+- All of `Observability.*`, `OpenTelemetryWorkflowBuilderExtensions`, and the
+  related delivery-status / activity helpers — re-enabled by
+  [#5837](https://github.com/microsoft/agent-framework/pull/5837)
+
+The following are also out of scope as not-worth-testing:
+
+- `YieldsMessageAttribute`, `StreamsMessageAttribute` — both `[Obsolete]` and
+  ignored by the source generator and runtime per their `Obsolete` message.
+
+## Method
+
+Each wave below states:
+
+- **Target classes** with current line coverage and the approximate uncovered-
+  line count from the snapshot.
+- **What to test** — the user-visible behavior(s) the new tests should
+  exercise. Tests should go through the public API where possible (e.g.,
+  `WorkflowBuilder` / `WorkflowHostAgent` / `InProcessExecution`) and only
+  reach into internals when there is no public path.
+- **Estimated line-coverage delta** — the *upper bound* assuming every
+  uncovered line in the listed classes becomes covered. Real deltas are
+  typically 60–80% of the upper bound.
+- **Suggested PR shape** — the smallest natural unit of work.
+
+The waves are ordered by **(impact / effort)**, highest first. Stop after each
+wave, re-run the snapshot, and re-prioritize.
+
+---
+
+## Wave 1 — Public API holes that are easy to write (largest single jump)
+
+These are public types where the missing tests are mechanical (constructors,
+guards, equality, simple round-trips) but cumulatively account for ~140
+uncovered lines.
+
+### 1A. `Workflow` (35 uncov, 44.4% line / 44.1% branch) — **public**
+
+The bulk of the gap is around ownership and protocol-description paths that
+are reachable but never asserted on directly:
+
+- `Workflow.TakeOwnership` / `ReleaseOwnershipAsync`: each of the four
+  `(subworkflow, _ownedAsSubworkflow)` switch arms (the four error messages
+  enumerated in `TakeOwnership`), the "release by non-owner" branch, the
+  `ObjectDisposedException`-substitute branch, and the
+  `IResettableExecutor`-failure branch (the `"Cannot reuse Workflow with shared
+  Executor instances that do not implement IResettableExecutor."` path).
+- `Workflow.DescribeProtocolAsync`: protocol described from a workflow whose
+  start executor is also an output executor; protocol described from a
+  workflow whose start executor binds to a `RequestPort`.
+- `Workflow.ReflectPorts` / `ReflectExecutors` / `ReflectEdges`: returns
+  fresh-copy semantics (mutating returned dictionary does not mutate
+  `Workflow`).
+
+**Suggested PR**: `WorkflowOwnershipAndReflectionTests.cs`. Covers ownership
+state machine + the three `Reflect*` accessors + `DescribeProtocolAsync`.
+
+### 1B. `EdgeId` (15 uncov, 37.5% / 0%) — **public struct**
+
+Zero branch coverage on a public equality type. Add a single
+`EdgeIdEqualityTests.cs`:
+
+- `Equals(object)` against `null`, `EdgeId`, `int`, and an unrelated type.
+- `Equals(EdgeId)`.
+- `==` and `!=` operators (equal, unequal, default).
+- `GetHashCode()` consistency with `Equals`.
+- `ToString()` round-trip with the underlying index.
+
+This is ~10 minutes of code, lifts a public struct from 37→100%, and
+contributes to the branch-coverage number disproportionately.
+
+### 1C. `Execution.EdgeConnection` (30 uncov, 36.1% / 37.5%) — **public**
+
+Public class with a documented ID-uniqueness factory and an `IEquatable<>`
+contract that is largely untested. Add `EdgeConnectionTests.cs`:
+
+- `EdgeConnection(sourceIds, sinkIds)` null-guards on both arguments.
+- `EdgeConnection.WithUniqueIds(...)` (the factory documented in the source
+  comment as enforcing uniqueness): both sides must reject duplicates with
+  `ArgumentException`.
+- `Equals` / `GetHashCode`: equal when both ordered lists match; unequal when
+  source order differs (ordering is documented as significant); unequal when
+  sink order differs.
+- `ToString` / display formatting if applicable.
+
+### 1D. `EdgeId` and `EdgeConnection` together unlock `EdgeIdConverter`
+
+Once 1B + 1C land, `EdgeIdConverter` (currently 80%) typically reaches 100%
+without additional code because the new equality assertions cause the
+serializer round-trip to be exercised by existing JSON tests.
+
+**Wave 1 upper-bound delta:** ~80 lines (~1.5 percentage points).
+
+---
+
+## Wave 2 — `WorkflowBuilder` public-surface gaps (largest single class)
+
+`WorkflowBuilder` is currently 82.4% line / 79.4% branch with **48 uncovered
+lines** — by far the largest absolute gap on a public type that is **not**
+already addressed by [#5824](https://github.com/microsoft/agent-framework/pull/5824)
+or [#5826](https://github.com/microsoft/agent-framework/pull/5826).
+
+Audit the file (`dotnet/src/Microsoft.Agents.AI.Workflows/WorkflowBuilder.cs`)
+for the specific uncovered lines before writing tests; the report-generator
+HTML output highlights them. From the snapshot, the under-tested behaviors
+are:
+
+- The `WithName` / `WithDescription` / `WithStartExecutor` chain on
+  pre-existing builders (re-assigning a start executor; assigning to the same
+  executor twice).
+- `AddFanInEdge` validation paths (duplicate sources, source equals sink,
+  empty source list).
+- `Build()` validation: workflow with no edges, workflow whose start executor
+  is unreachable from any registered executor (cycle-only graph), workflow
+  with a `RequestPort` not associated with any executor.
+- `BindFunctionExecutor` / `Bind` overloads that take a custom id collision —
+  the duplicate-id branch.
+- The "telemetry context already set" branch reached when
+  `OpenTelemetryWorkflowBuilderExtensions.WithOpenTelemetry` is called twice
+  on the same builder.
+
+**Suggested PR**: `WorkflowBuilderValidationTests.cs`, focused on the
+not-yet-exercised validation branches and the rebinding behaviors. Avoid
+duplicating anything already in `WorkflowBuilderSmokeTests.cs`.
+
+**Wave 2 upper-bound delta:** ~48 lines (~0.9 pp).
+
+---
+
+## Wave 3 — `ExecutorBindingExtensions` (public, 32% covered)
+
+`public static class ExecutorBindingExtensions` (50 lines, 34 uncovered) is
+the canonical entry point for turning user code into `ExecutorBinding`
+instances. Many of its overloads are completely untested:
+
+- `BindExecutor(this Executor)` — round-trip through `WorkflowBuilder` to
+  prove the `ExecutorInstanceBinding` resolves to the supplied instance.
+- `BindExecutorFactory<TExecutor>(Func<ValueTask<TExecutor>>)` — including
+  the eager-instantiation behavior documented in the XML comment ("...will be
+  instantiated if a `ProtocolDescriptor` for the `Workflow` is requested, and
+  it is the starting executor.").
+- `BindExecutorFactory<TExecutor>(string id, Func<ValueTask<TExecutor>>)` —
+  custom-id overload.
+- `BindFunction` / `Bind<TInput>(Func<…>)` / `Bind<TInput, TOutput>(Func<…>)`
+  — both sync and async overloads, both with and without `CancellationToken`,
+  including null-guard on the function and on the id.
+
+**Suggested PR**: `ExecutorBindingExtensionsTests.cs`. Mostly mechanical;
+each overload becomes one or two `[Theory]` rows. This single PR alone is
+worth ~30 lines / ~0.6 pp on its own and removes a 32%-covered public type
+from the lagging list.
+
+---
+
+## Wave 4 — `WorkflowSession` and `WorkflowHostAgent` (public hosting surface)
+
+`WorkflowSession` is internal but is the implementation of the
+**public** `WorkflowHostAgent`. Together they account for ~80 uncovered
+lines and several documented public guarantees that have no test coverage
+today.
+
+The uncovered lines concentrate in three areas:
+
+1. **Resume from a serialized session.** `WorkflowSession(Workflow, JsonElement,
+   IWorkflowExecutionEnvironment, …)` — currently exercised only on the happy
+   path. Add tests for: invalid JSON payload, payload missing pending-request
+   ids, payload referencing a different `Workflow` shape, round-trip through
+   `Serialize()` → re-construct.
+2. **External-request reconciliation.** The `_pendingRequests` plumbing
+   (`AddPendingRequest`, `RemovePendingRequest`, `TryGetPendingRequest`) and
+   the `NormalizeResponseContentForDelivery` / `CreateRequestContentForDelivery`
+   / `CloneFunctionCallContent` / `CloneFunctionResultContent` /
+   `CloneToolApprovalRequestContent` / `CloneToolApprovalResponseContent`
+   helpers. Each helper has at least one branch (id mismatch, missing
+   metadata, unsupported `AIContent` subtype) that is not hit today.
+3. **`WorkflowHostAgent` failure paths.** Calling the agent against a
+   `Workflow` with no checkpointing configured when checkpointing is required
+   (the path validated by `VerifyCheckpointingConfiguration`); calling
+   `RunAsync` after the session has terminated; passing `null` for the
+   message list.
+
+**Suggested PRs**:
+
+- 4a — `WorkflowSessionResumeTests.cs` (resume + serialize round-trip).
+- 4b — `WorkflowSessionExternalRequestTests.cs` (request/response cloning and
+  pending-request bookkeeping).
+- 4c — `WorkflowHostAgentValidationTests.cs` (agent-level guards).
+
+**Wave 4 upper-bound delta:** ~80 lines (~1.5 pp). This is the single largest
+uncovered area on the `Workflow*` public surface.
+
+---
+
+## Wave 5 — Checkpointing converters and the file-system store
+
+Cluster of small but high-percentage wins. None of these is glamorous, but
+together they take the `Checkpointing.*` namespace from "spotty" to
+"comprehensive" and remove every <60% type from the namespace except the
+abstract `JsonCheckpointStore` (which by itself is 1 line and not worth a
+dedicated test).
+
+| Class | Cov | Uncov | What's missing |
+| ----- | ---:| ----:| -------------- |
+| `Checkpointing.ExecutorIdentityConverter` | 12.5% | 14 | Read/write paths for null id, mixed-case id, non-string token. |
+| `Checkpointing.JsonWireSerializedValue` | 48.1% | 14 | Read with missing `TypeId`, missing `Value`, type-id mismatch on `As<T>()`. |
+| `Checkpointing.PortableValueConverter` | 57.5% | 14 | Round-trip of `null`, primitive, complex object, and the unknown-type branch. |
+| `Checkpointing.FileSystemJsonCheckpointStore` | 62.2% | 20 | Index-file rebuild on missing index, corrupted index file (existing test only covers the happy path), retrieval of unknown checkpoint id, store created against a path that does not yet exist. |
+| `Checkpointing.WorkflowInfo` | 80.3% | 10 | Equality/serialization branches for workflows that vary only in `Name` / `Description`. |
+
+`FileSystemJsonCheckpointStoreTests.cs` already exists; the additions can go
+into the same file.
+
+**Suggested PRs**: one PR per file, or one combined "checkpointing-converter"
+PR plus a separate "FileSystemJsonCheckpointStore-edge-cases" PR.
+
+**Wave 5 upper-bound delta:** ~70 lines (~1.3 pp).
+
+---
+
+## Wave 6 — `HandoffWorkflowBuilderCore<TBuilder>` (public base, 80.7% / 65.7%)
+
+`HandoffWorkflowBuilderCore` is the public base used by `HandoffWorkflowBuilder`
+and friends. With 22 uncovered lines and only 65.7% branch coverage on a
+public surface, it is one of the two remaining public builders without
+exhaustive validation tests (`WorkflowBuilder` itself is the other — see
+Wave 2). Cross-check against existing `HandoffOrchestrationTests.cs` and
+`HandoffMessageFilterTests.cs` to avoid duplication.
+
+Behaviors to cover:
+
+- Null/empty arguments to each public `Add*` / `WithStart*` / `WithEnd*`
+  method.
+- Duplicate-id detection (per the `WorkflowBuilder` contract).
+- `Build()` failure when no end executor is wired up.
+- `Build()` failure when no handoff filter is supplied and the default rejects
+  the configured handoff target.
+
+**Wave 6 upper-bound delta:** ~22 lines (~0.4 pp).
+
+---
+
+## Wave 7 — Public statics and remaining 0% public types
+
+These are short tests with disproportionate impact on the *count of public
+types with 0% coverage*, which is itself a useful quality metric independent
+of the line-coverage number.
+
+- **`StatefulExecutor<TState, TInput, TOutput>` (public, 0% / 9 lines)** —
+  add one minimal subclass that returns a value from `HandleAsync`, drive it
+  through `WorkflowBuilder` + `InProcessExecution`, assert state survives
+  across handler invocations. Mirror the existing tests for the two-type
+  `StatefulExecutor<TState, TInput>` overload (which is already covered).
+- **`Specialized.RequestPortExtensions` (internal, 7.1% / 13 lines)** — three
+  tests: `ShouldProcessResponse` returns `false` when the response targets a
+  different port; throws `InvalidOperationException` (with the specific
+  message produced by `CreateExceptionForType`) when port matches but the
+  payload type does not; returns `true` on a matching port and matching
+  payload.
+- **`MagenticPlanReviewRequest` / `MagenticPlanReviewResponse` (public, 0%)** —
+  PR [#5833](https://github.com/microsoft/agent-framework/pull/5833) covers
+  `MagenticPlanReviewResponse`. After it merges, add a one-shot test that
+  constructs `MagenticPlanReviewRequest` with each documented constructor
+  argument combination and asserts the property values, only if it is still
+  not covered.
+- **`WorkflowEvaluationExtensions` (public, 89.4%, 12 uncov)** — the gap is
+  in two paths: the cancellation path through `EvaluateAsync` and the
+  evaluator-throws path. Two `[Fact]`s.
+
+**Wave 7 upper-bound delta:** ~35 lines (~0.6 pp).
+
+---
+
+## Wave 8 — Internal helpers behind public hot paths
+
+Lower priority than waves 1–7 because the public-API gaps should be closed
+first. Listed here so they aren't forgotten when chasing the 90% stretch
+target.
+
+- `Execution.ExecutorIdentity` (15 uncov) — equality with `null`, with
+  `string`, with mismatched-case `ExecutorIdentity`, implicit `string` ↔
+  `ExecutorIdentity` conversions.
+- `InProc.InProcStepTracer` (20 uncov, but only 21.4% **branch** coverage) —
+  drive a workflow that has both internal and external messages in the same
+  super-step; assert `SuperStepStartInfo.HasExternalMessages`,
+  `SuperStepCompletionInfo.HasPendingMessages` /
+  `HasPendingRequests`, the `Reload(lastStepNumber)` API, and the
+  `ToString()` formatting.
+- `MessageMerger` (13 uncov, 89.6% / 85.7%) — the small remaining branches
+  in `MessageMerger.ResponseMergeState` (split across multiple final
+  fragments) and the empty-input branch.
+- `ExecutorBinding` (11 uncov) — the abstract base; covered automatically as
+  Waves 3 and 4 land. Re-check after.
+- `Visualization.WorkflowVisualizer` (18 uncov, 92.1%) — the remaining gaps
+  are escape-handling for unusual executor labels (newlines, double-quotes,
+  unicode) and the "subworkflow-with-zero-edges" formatting path. Three
+  `[Theory]` rows.
+
+**Wave 8 upper-bound delta:** ~75 lines (~1.4 pp).
+
+---
+
+## Cumulative projection
+
+| After… | Upper-bound line cov | Realistic (≈70%) |
+| ------ | ---: | ---: |
+| Today | 79.7% | — |
+| In-flight PRs (#5824, #5826, #5833, #5837) merged | ~86–87% | — |
+| Wave 1 (public structs + `Workflow` ownership) | +1.5 pp | +1.0 pp |
+| Wave 2 (`WorkflowBuilder` validation) | +0.9 pp | +0.6 pp |
+| Wave 3 (`ExecutorBindingExtensions`) | +0.6 pp | +0.4 pp |
+| Wave 4 (`WorkflowSession` + `WorkflowHostAgent`) | +1.5 pp | +1.0 pp |
+| Wave 5 (checkpointing converters + file-system store edges) | +1.3 pp | +0.9 pp |
+| Wave 6 (`HandoffWorkflowBuilderCore`) | +0.4 pp | +0.3 pp |
+| Wave 7 (zero-coverage public types) | +0.6 pp | +0.4 pp |
+| Wave 8 (internal helpers) | +1.4 pp | +1.0 pp |
+
+Realistic projection after **all four pending PRs + Waves 1–4**: **~89–90%
+line coverage**, comfortably past the 85% team target and reaching the 90%
+stretch target. Waves 5–8 then take the assembly above 90% on both line and
+branch coverage.
+
+## Workflow for executing the plan
+
+1. Wait for the four in-flight PRs (#5824, #5826, #5833, #5837) to merge.
+2. Re-run the snapshot in
+   [`wf-coverage-summary.md`](./wf-coverage-summary.md) and refresh the
+   per-class table. Some entries in this plan may already be addressed; drop
+   them.
+3. Open Wave 1 as **one** PR per sub-section (1A, 1B, 1C). Keep each PR
+   focused on a single class so review stays mechanical.
+4. After each wave merges, re-run the snapshot and re-prioritize. If a class
+   listed in a later wave is already past 90% coverage, drop it.
+5. When the assembly clears 85% line coverage, raise the
+   `dotnet-check-coverage.ps1` threshold and add
+   `Microsoft.Agents.AI.Workflows` to the `nonExperimentalAssemblies` list in
+   that script so the bar cannot regress.
+
+## Conventions for the new tests
+
+- Follow the existing test-project conventions in
+  `dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests`:
+  xUnit v3 + Microsoft Testing Platform, `FluentAssertions`, and the existing
+  helper classes in `TestingExecutor.cs`, `TestRunContext.cs`,
+  `TestWorkflowContext.cs`, `MessageDeliveryValidation.cs`, etc. Reuse them
+  rather than introducing parallel infrastructure.
+- Preserve the `Throw.IfXYZ` validation idiom in production code. New tests
+  should assert against the existing `ArgumentNullException` /
+  `ArgumentException` thrown by those helpers; do not change production
+  validation to a different style.
+- For each new test file, prefer `[Theory]` over many near-duplicate
+  `[Fact]`s when only a single argument varies — this keeps reviewer load
+  low and matches the convention used in `WorkflowBuilderSmokeTests.cs` and
+  `RouteBuilderTests.cs` (PR #5824).

dotnet/docs/workflows/wf-coverage-summary.md

@@ -0,0 +1,156 @@
+# Workflows Unit Test Coverage — Snapshot
+
+This document captures a coverage snapshot of `Microsoft.Agents.AI.Workflows`
+produced by running the existing `Microsoft.Agents.AI.Workflows.UnitTests`
+suite. It is the input for [`wf-coverage-plan.md`](./wf-coverage-plan.md), which
+proposes incremental work to lift coverage to the 85%/90% targets.
+
+## How this snapshot was produced
+
+```bash
+cd dotnet
+dotnet build tests/Microsoft.Agents.AI.Workflows.UnitTests/Microsoft.Agents.AI.Workflows.UnitTests.csproj -f net10.0
+
+dotnet test --project tests/Microsoft.Agents.AI.Workflows.UnitTests/Microsoft.Agents.AI.Workflows.UnitTests.csproj \
+  -f net10.0 --no-build \
+  --coverage --coverage-output-format cobertura \
+  --coverage-output coverage.cobertura.xml \
+  --coverage-settings tests/coverage.runsettings
+
+reportgenerator \
+  -reports:tests/Microsoft.Agents.AI.Workflows.UnitTests/bin/Debug/net10.0/TestResults/coverage.cobertura.xml \
+  -targetdir:./coverage-report \
+  -reporttypes:'Html_Dark;JsonSummary;TextSummary' \
+  -assemblyfilters:'+Microsoft.Agents.AI.Workflows;-Microsoft.Agents.AI.Workflows.Declarative*'
+```
+
+- Tooling: `dotnet test` with `Microsoft.Testing.Extensions.CodeCoverage` (the
+  same configuration documented in `dotnet/.github/skills/build-and-test/SKILL.md`).
+- Scope: only the `Microsoft.Agents.AI.Workflows` assembly. The
+  `Microsoft.Agents.AI.Workflows.Declarative*` family is excluded — those have
+  their own test projects and a different ownership area.
+- Test result: **460 passed, 22 skipped, 0 failed** (482 total). The 22 skipped
+  tests are the previously-flaky `ObservabilityTests` and
+  `WorkflowRunActivityStopTests`; **PR [#5837](https://github.com/microsoft/agent-framework/pull/5837)
+  re-enables them all.**
+
+## Headline numbers
+
+| Metric                | Value                       | Target |
+| --------------------- | --------------------------- | ------ |
+| Line coverage         | **79.7%** (4386 / 5499)     | 85% / 90% |
+| Branch coverage       | **67.2%** (1111 / 1653)     | — |
+| Method coverage       | **80.9%** (903 / 1115)      | — |
+| Fully-covered methods | **70.8%** (790 / 1115)      | — |
+| Coverable lines       | 5,499                       | — |
+| Uncovered lines       | **1,113**                   | — |
+| Classes               | 237 (185 source files)      | — |
+
+Distance to the 85% line target ≈ **+292 covered lines**.
+Distance to the 90% personal target ≈ **+567 covered lines**.
+
+The much larger branch-coverage gap (67.2%) is the bigger structural problem:
+many code paths are reached but not all branches inside them are exercised.
+
+## In-flight PRs that already address part of this gap
+
+The plan in [`wf-coverage-plan.md`](./wf-coverage-plan.md) **excludes** the
+classes covered by these PRs to avoid duplicate work or merge conflicts:
+
+| PR | Classes added/improved |
+| -- | ---------------------- |
+| [#5824](https://github.com/microsoft/agent-framework/pull/5824) — `RouteBuilder` unit tests | `RouteBuilder` (143 lines, 58 currently uncovered) |
+| [#5826](https://github.com/microsoft/agent-framework/pull/5826) — `WorkflowBuilder` specialized edge tests | `WorkflowBuilderExtensions` (51 lines, 21 uncov), `SwitchBuilder` (already 90.4%, but null-guard branches added) |
+| [#5833](https://github.com/microsoft/agent-framework/pull/5833) — Magentic E2E coverage | `MagenticWorkflowBuilder` (69 lines, 0%), `MagenticOrchestrator` (52%), `MagenticTaskContext` (35%), and the related Magentic event types (all 0%) |
+| [#5837](https://github.com/microsoft/agent-framework/pull/5837) — Re-enable `ObservabilityTests`/`WorkflowRunActivityStopTests` | `Observability/WorkflowTelemetryContext` (42.7%), `Observability/ActivityExtensions` (0%), `Observability/EdgeRunnerDeliveryStatusExtensions` (0%), `OpenTelemetryWorkflowBuilderExtensions` (0%), and the bulk of `Tags` / `EventNames` / `ActivityNames` |
+
+Estimated combined impact once all four merge: **~360–410 of the current 1,113
+uncovered lines** become covered, lifting line coverage to roughly **86–87%**
+even before any of the new work proposed in the plan.
+
+## Top uncovered classes (after excluding in-flight PRs)
+
+Sorted by uncovered line count. "Public surface" indicates whether the class
+itself or its uncovered members are part of the public API of the
+`Microsoft.Agents.AI.Workflows` assembly — those are the highest-leverage
+targets.
+
+| # | Class | Public surface | Line cov | Branch cov | Coverable | Uncov |
+|---|-------|:-:|---:|---:|---:|---:|
+| 1 | `WorkflowSession` | internal (reached via `WorkflowHostAgent`) | 67.7% | 47.5% | 217 | **70** |
+| 2 | `WorkflowBuilder` | **public** | 82.4% | 79.4% | 273 | **48** |
+| 3 | `Workflow` | **public** | 44.4% | 44.1% | 63 | **35** |
+| 4 | `ExecutorBindingExtensions` | **public** | 32.0% | n/a | 50 | **34** |
+| 5 | `Execution.EdgeConnection` | **public** | 36.1% | 37.5% | 47 | **30** |
+| 6 | `HandoffWorkflowBuilderCore<TBuilder>` | **public (base)** | 80.7% | 65.7% | 114 | **22** |
+| 7 | `Checkpointing.FileSystemJsonCheckpointStore` | **public** | 62.2% | 57.1% | 53 | **20** |
+| 8 | `InProc.InProcStepTracer` | internal | 62.9% | 21.4% | 54 | **20** |
+| 9 | `Visualization.WorkflowVisualizer` | **public** | 92.1% | 93.5% | 230 | **18** |
+| 10 | `EdgeId` | **public** struct | 37.5% | 0.0% | 24 | **15** |
+| 11 | `Execution.ExecutorIdentity` | internal | 28.5% | 18.7% | 21 | **15** |
+| 12 | `Checkpointing.ExecutorIdentityConverter` | internal | 12.5% | 0.0% | 16 | **14** |
+| 13 | `Checkpointing.JsonWireSerializedValue` | internal | 48.1% | 50.0% | 27 | **14** |
+| 14 | `Checkpointing.PortableValueConverter` | internal | 57.5% | 35.7% | 33 | **14** |
+| 15 | `Execution.StateScope` | internal | 79.0% | 72.2% | 62 | **13** |
+| 16 | `MessageMerger` | internal | 89.6% | 85.7% | 126 | **13** |
+| 17 | `Specialized.RequestPortExtensions` | internal | 7.1% | 0.0% | 14 | **13** |
+| 18 | `WorkflowEvaluationExtensions` | **public** | 89.4% | 75.0% | 114 | **12** |
+| 19 | `ExecutorBinding` | internal (base) | 60.7% | 28.5% | 28 | **11** |
+| 20 | `Checkpointing.WorkflowInfo` | internal | 80.3% | 54.5% | 51 | **10** |
+| 21 | `WorkflowHostAgent` | **public** | 70.5% | 75.0% | 34 | **10** |
+| 22 | `StatefulExecutor<TState, TInput, TOutput>` | **public** | **0.0%** | n/a | 9 | **9** |
+| 23 | `CheckpointableRunBase` | internal (base of `Run`) | 42.8% | 16.6% | 14 | **8** |
+| 24 | `Reflection.MessageHandlerInfo` | internal | 78.3% | 66.6% | 37 | **8** |
+| 25 | `Specialized.ConcurrentEndExecutor` | internal | 78.9% | n/a | 38 | **8** |
+
+### Other notable gaps
+
+- **0% on small-but-public types**: `JsonCheckpointStore` (abstract base, 1
+  line, no test instantiates it), `IResettableExecutor` (interface default
+  method, 3 lines), `MagenticPlanReviewRequest`/`MagenticPlanReviewResponse`
+  (5/2 lines — partly covered by [#5833](https://github.com/microsoft/agent-framework/pull/5833)).
+- **Obsolete attributes** with 0% coverage but no value to test:
+  `YieldsMessageAttribute`, `StreamsMessageAttribute`. Both are explicitly
+  marked `[Obsolete]` and are ignored by both the source generator and the
+  runtime — **excluded** from the plan.
+- **Records / events** with low line counts (`SubworkflowWarningEvent`,
+  `RequestHaltEvent`, `ResetChatSignal`, `MagenticReplannedEvent`, etc.) appear
+  as 0% only because no test ever constructs them. Tiny absolute impact
+  individually, but easy bulk wins via constructor smoke tests.
+- **`Observability.*`** classes appear at 0–43% because the entire
+  `ObservabilityTests` and `WorkflowRunActivityStopTests` files are skipped on
+  `main`. Re-enabling them via PR [#5837](https://github.com/microsoft/agent-framework/pull/5837)
+  is expected to lift those into the 80–95% range without any new test code.
+
+## Per-area coverage breakdown
+
+(Aggregated by namespace; `Microsoft.Agents.AI.Workflows.Declarative*` excluded.)
+
+| Area | Approx line cov | Notes |
+| ---- | ---: | ----- |
+| Top-level (`Workflow`, `WorkflowBuilder`, `WorkflowSession`, `WorkflowHostAgent`, `Run`, `StreamingRun`) | ~75% | Largest absolute gap; many public-surface gaps. |
+| `Execution.*` | ~85–90% on hot-path types, **<40%** on `EdgeConnection` and `ExecutorIdentity` | Identity/equality and connection-validation paths under-tested. |
+| `Checkpointing.*` | ~80% mean | Several converter classes 12–58%; `FileSystemJsonCheckpointStore` 62% (concurrency / corruption / index-rebuild paths). |
+| `InProc.*` | ~85% | `InProcStepTracer` is the only outlier (62.9% line, 21.4% branch). |
+| `Reflection.*` | ~85% | Solid; minor gaps. |
+| `Visualization.*` | 92.1% | Already strong; remaining 18 lines are escape-handling and a couple of unusual edge layouts. |
+| `Observability.*` | **<45%** today, expected **>85%** after [#5837](https://github.com/microsoft/agent-framework/pull/5837). |
+| `Specialized.Magentic.*` | 35–82% today; the orchestrator + builder + task context lift to high coverage after [#5833](https://github.com/microsoft/agent-framework/pull/5833). |
+| `Specialized.*` (non-Magentic — handoff, group-chat, request-port helpers) | ~80–90% | `RequestPortExtensions` (7.1%) is the only sharp outlier. |
+| `Evaluation.*` | 89.4% | Mostly there; only branch coverage gaps remain. |
+
+## Reproducing the per-class data
+
+The full per-class table used to build the buckets above is regenerated by:
+
+```bash
+python3 - <<'PY'
+import json
+data = json.load(open('coverage-report/Summary.json'))
+asm = data['coverage']['assemblies'][0]
+def uncov(c): return c['coverablelines'] - c['coveredlines']
+for c in sorted(asm['classesinassembly'], key=lambda c: -uncov(c)):
+    if uncov(c) == 0: continue
+    print(f"{c['name']:80s}  {c['coverage']:5.1f}%  uncov={uncov(c):4d}  lines={c['coverablelines']}")
+PY
+```

dotnet/eng/verify-samples/WorkflowSamples.cs

@@ -478,17 +478,6 @@ internal static class WorkflowSamples
             ExpectedOutputDescription = ["The output should show a workflow invoking a function tool (e.g. a menu plugin) to answer a question about the soup of the day."],
         },
 
-        new SampleDefinition
-        {
-            Name = "Workflow_Declarative_InvokeFoundryToolboxMcp",
-            ProjectPath = "samples/03-workflows/Declarative/InvokeFoundryToolboxMcp",
-            RequiredEnvironmentVariables = ["AZURE_AI_PROJECT_ENDPOINT"],
-            OptionalEnvironmentVariables = ["AZURE_AI_MODEL_DEPLOYMENT_NAME", "FOUNDRY_TOOLBOX_NAME", "FOUNDRY_AGENT_TOOLSET_API_VERSION"],
-            Inputs = ["How do I use Azure OpenAI with my data?"],
-            InputDelayMs = 3000,
-            ExpectedOutputDescription = ["The output should show a workflow using Foundry Toolbox MCP tools to search Microsoft Learn documentation and web search to provide a summary of results."],
-        },
-
         new SampleDefinition
         {
             Name = "Workflow_Declarative_InvokeMcpTool",

dotnet/samples/02-agents/Harness/ConsoleReactiveComponents/TextPanel.cs

@@ -9,30 +9,42 @@ namespace Harness.ConsoleReactiveComponents;
 /// </summary>
 public record TextPanelProps : ConsoleReactiveProps
 {
-    /// <summary>Gets the items to render in the panel. Each item is a pre-rendered
-    /// console string (may include ANSI escape sequences and newlines).</summary>
-    public IReadOnlyList<string> Items { get; init; } = [];
+    /// <summary>Gets the items to render in the panel.</summary>
+    public IReadOnlyList<object> Items { get; init; } = [];
 }
 
 /// <summary>
-/// A component that renders a list of pre-rendered string items vertically.
+/// A component that renders a list of items vertically using a custom render delegate.
 /// Designed for rendering dynamic items in a non-scroll region that may be
 /// re-rendered on each update. If the component's <see cref="ConsoleReactiveComponent.Height"/>
 /// exceeds the number of output lines, leftover lines are erased.
 /// </summary>
 public class TextPanel : ConsoleReactiveComponent<TextPanelProps, ConsoleReactiveState>
 {
+    private readonly Func<object, string> _renderItem;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="TextPanel"/> class.
+    /// </summary>
+    /// <param name="renderItem">A delegate that renders an item and returns the text to display (may contain newlines).</param>
+    public TextPanel(Func<object, string> renderItem)
+    {
+        this._renderItem = renderItem;
+    }
+
     /// <summary>
     /// Calculates the height (in lines) needed to render all items.
     /// </summary>
     /// <param name="items">The items to measure.</param>
+    /// <param name="renderItem">The render delegate to use for measuring.</param>
     /// <returns>The total number of lines all items will occupy.</returns>
-    public static int CalculateHeight(IReadOnlyList<string> items)
+    public static int CalculateHeight(IReadOnlyList<object> items, Func<object, string> renderItem)
     {
         int total = 0;
         for (int i = 0; i < items.Count; i++)
         {
-            total += CountLines(items[i]);
+            string text = renderItem(items[i]);
+            total += CountLines(text);
         }
 
         return total;
@@ -45,7 +57,7 @@ public class TextPanel : ConsoleReactiveComponent<TextPanelProps, ConsoleReactiv
 
         for (int i = 0; i < props.Items.Count; i++)
         {
-            string text = props.Items[i];
+            string text = this._renderItem(props.Items[i]);
             string[] lines = text.Split('\n');
             int lineCount = CountLines(text);
 

dotnet/samples/02-agents/Harness/ConsoleReactiveComponents/TextScrollPanel.cs

@@ -9,9 +9,8 @@ namespace Harness.ConsoleReactiveComponents;
 /// </summary>
 public record TextScrollPanelProps : ConsoleReactiveProps
 {
-    /// <summary>Gets the items to render in the scroll panel. Each item is a pre-rendered
-    /// console string (may include ANSI escape sequences and newlines).</summary>
-    public IReadOnlyList<string> Items { get; init; } = [];
+    /// <summary>Gets the items to render in the scroll panel.</summary>
+    public IReadOnlyList<object> Items { get; init; } = [];
 }
 
 /// <summary>
@@ -21,17 +20,21 @@ public record TextScrollPanelProps : ConsoleReactiveProps
 public record TextScrollPanelState(int RenderedCount = 0) : ConsoleReactiveState;
 
 /// <summary>
-/// A component that renders pre-rendered string items within a scroll area.
+/// A component that renders items within a scroll area using a custom render delegate.
 /// All items are considered finalized — only new items since the last render are output.
 /// Use <see cref="Reset"/> to force a full re-render.
 /// </summary>
 public class TextScrollPanel : ConsoleReactiveComponent<TextScrollPanelProps, TextScrollPanelState>
 {
+    private readonly Func<object, string> _renderItem;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="TextScrollPanel"/> class.
     /// </summary>
-    public TextScrollPanel()
+    /// <param name="renderItem">A delegate that renders a single item and returns the text to display (may contain newlines).</param>
+    public TextScrollPanel(Func<object, string> renderItem)
     {
+        this._renderItem = renderItem;
         this.State = new TextScrollPanelState();
     }
 
@@ -57,7 +60,8 @@ public class TextScrollPanel : ConsoleReactiveComponent<TextScrollPanelProps, Te
         // Output only new items since last rendered
         for (int i = state.RenderedCount; i < props.Items.Count; i++)
         {
-            Console.Write(props.Items[i]);
+            string text = this._renderItem(props.Items[i]);
+            Console.Write(text);
         }
 
         // Update state to track what we've rendered

dotnet/samples/02-agents/Harness/Harness_ConsoleSandbox/AppComponent.cs

@@ -0,0 +1,315 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Harness.ConsoleReactiveComponents;
+using Harness.ConsoleReactiveFramework;
+
+namespace Harness.ConsoleSandbox;
+
+/// <summary>
+/// Determines which component is shown in the bottom panel.
+/// </summary>
+public enum BottomPanelMode
+{
+    /// <summary>Show the list selection component.</summary>
+    ListSelection,
+
+    /// <summary>Show the text input component.</summary>
+    TextInput
+}
+
+public record AppComponentProps : ConsoleReactiveProps
+{
+    public IReadOnlyList<string> Items { get; init; } = Array.Empty<string>();
+    public IReadOnlyList<object> ScrollItems { get; init; } = [];
+
+    /// <summary>Gets the bottom panel mode.</summary>
+    public BottomPanelMode Mode { get; init; } = BottomPanelMode.ListSelection;
+
+    /// <summary>Gets the prompt string for text input mode.</summary>
+    public string Prompt { get; init; } = "> ";
+
+    /// <summary>Gets the placeholder text shown when the input is empty.</summary>
+    public string Placeholder { get; init; } = "";
+
+    /// <summary>Gets the highlight color for the active list item. Defaults to <see cref="ConsoleColor.Cyan"/>.</summary>
+    public ConsoleColor ListHighlightColor { get; init; } = ConsoleColor.Cyan;
+
+    /// <summary>Gets the placeholder text for the custom text input option in the list. If <c>null</c>, no custom option is shown.</summary>
+    public string? ListCustomTextPlaceholder { get; init; }
+
+    /// <summary>Gets the foreground color for the rule borders. If <c>null</c>, uses the default terminal color.</summary>
+    public ConsoleColor? RuleColor { get; init; }
+}
+
+/// <summary>
+/// Internal state for the <see cref="AppComponent"/>.
+/// </summary>
+public record AppComponentState : ConsoleReactiveState
+{
+    /// <summary>Gets the selected index in list selection mode.</summary>
+    public int SelectedIndex { get; init; }
+
+    /// <summary>Gets the current input text being typed in text input mode.</summary>
+    public string InputText { get; init; } = "";
+
+    /// <summary>Gets the current text being typed into the list's custom text option.</summary>
+    public string ListInputText { get; init; } = "";
+}
+
+public class AppComponent : ConsoleReactiveComponent<AppComponentProps, AppComponentState>
+{
+    private readonly TopBottomRule _rule = new();
+    private readonly ListSelection _listSelection = new();
+    private readonly TextInput _textInput = new();
+    private readonly TextScrollPanel _textScrollPanel;
+    private readonly TextPanel _textPanel;
+    private readonly Func<object, string> _renderItem;
+    private readonly Action<string> _onTextInputSubmit;
+    private readonly Action<string> _onListInputSubmit;
+    private bool _resizedSinceLastRender;
+    private int _lastScrollBottom;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AppComponent"/> class.
+    /// </summary>
+    /// <param name="renderScrollItem">A delegate that renders a single scroll panel item and returns the text to display.</param>
+    /// <param name="onTextInputSubmit">A callback invoked with the input text when the user presses Enter in text input mode.</param>
+    /// <param name="onListInputSubmit">A callback invoked with the selected or typed text when the user presses Enter in list selection mode.</param>
+    public AppComponent(Func<object, string> renderScrollItem, Action<string> onTextInputSubmit, Action<string> onListInputSubmit)
+    {
+        this._renderItem = renderScrollItem;
+        this._onTextInputSubmit = onTextInputSubmit;
+        this._onListInputSubmit = onListInputSubmit;
+        this._textScrollPanel = new TextScrollPanel(renderScrollItem);
+        this._textPanel = new TextPanel(renderScrollItem);
+        this.State = new AppComponentState();
+        KeyEventListener.Instance.KeyPressed += this.OnKeyPressed;
+        ConsoleResizeListener.Instance.ConsoleResized += this.OnConsoleResized;
+    }
+
+    private void OnKeyPressed(object? sender, KeyPressEventArgs e)
+    {
+        if (this.Props!.Mode == BottomPanelMode.TextInput)
+        {
+            this.HandleTextInputKey(e);
+        }
+        else
+        {
+            this.HandleListSelectionKey(e);
+        }
+    }
+
+    private void HandleTextInputKey(KeyPressEventArgs e)
+    {
+        if (e.KeyInfo.Key == ConsoleKey.Enter)
+        {
+            string text = this.State!.InputText;
+            this.SetState(this.State with { InputText = "" });
+            this._onTextInputSubmit(text);
+        }
+        else if (e.KeyInfo.Key == ConsoleKey.Backspace)
+        {
+            if (this.State!.InputText.Length > 0)
+            {
+                this.SetState(this.State with { InputText = this.State.InputText[..^1] });
+            }
+        }
+        else if (e.KeyInfo.KeyChar != '\0' && !char.IsControl(e.KeyInfo.KeyChar))
+        {
+            this.SetState(this.State! with { InputText = this.State.InputText + e.KeyInfo.KeyChar });
+        }
+    }
+
+    private void HandleListSelectionKey(KeyPressEventArgs e)
+    {
+        int maxIndex = this.Props!.Items.Count - 1;
+        if (this.Props.ListCustomTextPlaceholder != null)
+        {
+            maxIndex = this.Props.Items.Count; // extra option at the end
+        }
+
+        bool isOnCustomTextOption = this.Props.ListCustomTextPlaceholder != null
+            && this.State!.SelectedIndex == this.Props.Items.Count;
+
+        if (e.KeyInfo.Key == ConsoleKey.UpArrow)
+        {
+            this.SetState(this.State! with { SelectedIndex = Math.Max(0, this.State.SelectedIndex - 1) });
+        }
+        else if (e.KeyInfo.Key == ConsoleKey.DownArrow)
+        {
+            this.SetState(this.State! with { SelectedIndex = Math.Min(maxIndex, this.State.SelectedIndex + 1) });
+        }
+        else if (e.KeyInfo.Key == ConsoleKey.Enter)
+        {
+            if (isOnCustomTextOption)
+            {
+                string text = this.State!.ListInputText;
+                this.SetState(this.State with { ListInputText = "" });
+                this._onListInputSubmit(text);
+            }
+            else
+            {
+                this._onListInputSubmit(this.Props.Items[this.State!.SelectedIndex]);
+            }
+        }
+        else if (isOnCustomTextOption)
+        {
+            // Typing only works when on the custom text option
+            if (e.KeyInfo.Key == ConsoleKey.Backspace)
+            {
+                if (this.State!.ListInputText.Length > 0)
+                {
+                    this.SetState(this.State with { ListInputText = this.State.ListInputText[..^1] });
+                }
+            }
+            else if (e.KeyInfo.KeyChar != '\0' && !char.IsControl(e.KeyInfo.KeyChar))
+            {
+                this.SetState(this.State! with { ListInputText = this.State.ListInputText + e.KeyInfo.KeyChar });
+            }
+        }
+    }
+
+    private void OnConsoleResized(object? sender, ConsoleResizeEventArgs e)
+    {
+        this._resizedSinceLastRender = true;
+        this.Render();
+    }
+
+    public override void RenderCore(AppComponentProps props, AppComponentState state)
+    {
+        // Determine the text panel height for the last scroll item
+        object? lastItem = props.ScrollItems.Count > 0 ? props.ScrollItems[^1] : null;
+        IReadOnlyList<object> lastItems = lastItem != null ? [lastItem] : [];
+        int textPanelHeight = TextPanel.CalculateHeight(lastItems, this._renderItem);
+        if (textPanelHeight > 0)
+        {
+            textPanelHeight++; // Extra line for spacing between text panel and rule
+        }
+
+        // Build the bottom panel child based on mode
+        ConsoleReactiveComponent bottomChild;
+        int bottomChildHeight;
+
+        if (props.Mode == BottomPanelMode.TextInput)
+        {
+            var textInputProps = new TextInputProps
+            {
+                Prompt = props.Prompt,
+                Text = state.InputText,
+                Placeholder = props.Placeholder
+            };
+
+            bottomChildHeight = TextInput.CalculateHeight(textInputProps, Console.WindowWidth);
+            this._textInput.Width = Console.WindowWidth;
+            this._textInput.Height = bottomChildHeight;
+            this._textInput.Props = textInputProps;
+            bottomChild = this._textInput;
+        }
+        else
+        {
+            var listProps = new ListSelectionProps
+            {
+                Items = props.Items,
+                SelectedIndex = state.SelectedIndex,
+                HighlightColor = props.ListHighlightColor,
+                CustomTextPlaceholder = props.ListCustomTextPlaceholder,
+                CustomText = state.ListInputText
+            };
+
+            bottomChildHeight = ListSelection.CalculateHeight(listProps);
+            this._listSelection.Height = bottomChildHeight;
+            this._listSelection.Props = listProps;
+            bottomChild = this._listSelection;
+        }
+
+        var ruleProps = new TopBottomRuleProps
+        {
+            Width = Console.WindowWidth,
+            Color = props.RuleColor,
+            Children = [bottomChild]
+        };
+
+        int ruleHeight = TopBottomRule.CalculateHeight(ruleProps);
+        int scrollBottom = Console.WindowHeight - ruleHeight - textPanelHeight;
+
+        // If scroll region changed or a clear is needed, reset everything
+        if (this._resizedSinceLastRender || (this._lastScrollBottom != 0 && scrollBottom != this._lastScrollBottom))
+        {
+            Console.Write(AnsiEscapes.EraseEntireScreen);
+            Console.Write(AnsiEscapes.EraseScrollbackBuffer);
+            this._textScrollPanel.Reset();
+            this._resizedSinceLastRender = false;
+        }
+
+        this._lastScrollBottom = scrollBottom;
+
+        Console.Write(AnsiEscapes.SetScrollRegion(scrollBottom));
+
+        // Render text scroll panel in the scroll area (all items except the last)
+        IReadOnlyList<object> scrollItems = props.ScrollItems.Count > 1
+            ? props.ScrollItems.Take(props.ScrollItems.Count - 1).ToList()
+            : [];
+
+        this._textScrollPanel.X = 1;
+        this._textScrollPanel.Y = 1;
+        this._textScrollPanel.Width = Console.WindowWidth;
+        this._textScrollPanel.Height = scrollBottom;
+        this._textScrollPanel.Props = new TextScrollPanelProps
+        {
+            Items = scrollItems
+        };
+        this._textScrollPanel.Render();
+
+        // Render the text panel for the last (dynamic) item just below the scroll region
+        this._textPanel.X = 1;
+        this._textPanel.Y = scrollBottom + 1;
+        this._textPanel.Width = Console.WindowWidth;
+        this._textPanel.Height = textPanelHeight;
+        this._textPanel.Props = new TextPanelProps
+        {
+            Items = lastItems,
+        };
+        this._textPanel.Render();
+
+        // Render the bottom rule + child below the text panel
+        this._rule.X = 1;
+        this._rule.Y = scrollBottom + textPanelHeight + 1;
+        this._rule.Props = ruleProps;
+        this._rule.Render();
+
+        // Position cursor for natural typing appearance
+        if (props.Mode == BottomPanelMode.TextInput)
+        {
+            int promptLength = props.Prompt.Length;
+            int textWidth = Console.WindowWidth - promptLength;
+            int textLength = state.InputText.Length;
+
+            // The TextInput starts at rule.Y + 1 (first row inside the rule)
+            int textInputY = this._rule.Y + 1;
+
+            if (textWidth <= 0 || textLength == 0)
+            {
+                // Cursor right after the prompt
+                Console.Write(AnsiEscapes.MoveCursor(textInputY, promptLength + 1));
+            }
+            else
+            {
+                // Calculate which row and column the cursor lands on
+                int cursorRow = textLength < textWidth ? 0 : 1 + ((textLength - textWidth) / textWidth);
+                int cursorCol = textLength < textWidth ? textLength : (textLength - textWidth) % textWidth;
+                Console.Write(AnsiEscapes.MoveCursor(textInputY + cursorRow, promptLength + cursorCol + 1));
+            }
+        }
+        else if (props.Mode == BottomPanelMode.ListSelection
+            && props.ListCustomTextPlaceholder != null
+            && state.SelectedIndex == props.Items.Count)
+        {
+            // Cursor after the typed text in the custom text option
+            // The custom text option is at rule.Y + 1 + Items.Count (0-based row inside rule)
+            int customOptionY = this._rule.Y + 1 + props.Items.Count;
+            // "> " prefix is 2 chars, then the typed text
+            int cursorCol = 2 + state.ListInputText.Length + 1;
+            Console.Write(AnsiEscapes.MoveCursor(customOptionY, cursorCol));
+        }
+    }
+}

dotnet/samples/02-agents/Harness/Harness_Shared_Console/Commands/CommandHandler.cs

@@ -23,7 +23,7 @@ public abstract class CommandHandler
     /// </summary>
     /// <param name="input">The raw user input string.</param>
     /// <param name="session">The current agent session.</param>
-    /// <param name="ux">The UX state driver for rendering output.</param>
+    /// <param name="ux">The UX container for rendering output.</param>
     /// <returns><see langword="true"/> if this handler handled the input; <see langword="false"/> otherwise.</returns>
-    public abstract ValueTask<bool> TryHandleAsync(string input, AgentSession session, IUXStateDriver ux);
+    public abstract ValueTask<bool> TryHandleAsync(string input, AgentSession session, HarnessUXContainer ux);
 }

dotnet/samples/02-agents/Harness/Harness_Shared_Console/Commands/ExitCommandHandler.cs

@@ -1,26 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using Microsoft.Agents.AI;
-
-namespace Harness.Shared.Console.Commands;
-
-/// <summary>
-/// Handles the <c>/exit</c> command to shut down the console application.
-/// </summary>
-public sealed class ExitCommandHandler : CommandHandler
-{
-    /// <inheritdoc/>
-    public override string? GetHelpText() => "/exit (quit)";
-
-    /// <inheritdoc/>
-    public override ValueTask<bool> TryHandleAsync(string input, AgentSession session, IUXStateDriver ux)
-    {
-        if (!input.Equals("/exit", StringComparison.OrdinalIgnoreCase))
-        {
-            return new ValueTask<bool>(false);
-        }
-
-        ux.RequestShutdown();
-        return new ValueTask<bool>(true);
-    }
-}

dotnet/samples/02-agents/Harness/Harness_Shared_Console/Commands/ModeCommandHandler.cs

@@ -7,7 +7,7 @@ namespace Harness.Shared.Console.Commands;
 /// <summary>
 /// Handles the <c>/mode</c> command to display or switch the current agent mode.
 /// </summary>
-public sealed class ModeCommandHandler : CommandHandler
+internal sealed class ModeCommandHandler : CommandHandler
 {
     private readonly AgentModeProvider? _modeProvider;
     private readonly IReadOnlyDictionary<string, ConsoleColor>? _modeColors;
@@ -27,7 +27,7 @@ public sealed class ModeCommandHandler : CommandHandler
     public override string? GetHelpText() => this._modeProvider is not null ? "/mode [plan|execute] (show or switch mode)" : null;
 
     /// <inheritdoc/>
-    public override async ValueTask<bool> TryHandleAsync(string input, AgentSession session, IUXStateDriver ux)
+    public override async ValueTask<bool> TryHandleAsync(string input, AgentSession session, HarnessUXContainer ux)
     {
         if (!input.StartsWith("/mode ", StringComparison.OrdinalIgnoreCase) && !input.Equals("/mode", StringComparison.OrdinalIgnoreCase))
         {

dotnet/samples/02-agents/Harness/Harness_Shared_Console/Commands/TodoCommandHandler.cs

@@ -7,7 +7,7 @@ namespace Harness.Shared.Console.Commands;
 /// <summary>
 /// Handles the <c>/todos</c> command to display the current todo list.
 /// </summary>
-public sealed class TodoCommandHandler : CommandHandler
+internal sealed class TodoCommandHandler : CommandHandler
 {
     private readonly TodoProvider? _todoProvider;
 
@@ -24,7 +24,7 @@ public sealed class TodoCommandHandler : CommandHandler
     public override string? GetHelpText() => this._todoProvider is not null ? "/todos (show todo list)" : null;
 
     /// <inheritdoc/>
-    public override async ValueTask<bool> TryHandleAsync(string input, AgentSession session, IUXStateDriver ux)
+    public override async ValueTask<bool> TryHandleAsync(string input, AgentSession session, HarnessUXContainer ux)
     {
         if (!input.Equals("/todos", StringComparison.OrdinalIgnoreCase))
         {

dotnet/samples/02-agents/Harness/Harness_Shared_Console/FollowUpAction.cs

@@ -1,59 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using Microsoft.Extensions.AI;
-
-namespace Harness.Shared.Console;
-
-/// <summary>
-/// Represents an action returned by an observer at the end of an agent turn.
-/// Subtypes describe either a question to ask the user (<see cref="FollowUpQuestion"/>)
-/// or a message to add directly to the next agent input (<see cref="FollowUpMessage"/>).
-/// </summary>
-public abstract record FollowUpAction;
-
-/// <summary>
-/// Represents a question that should be presented to the user. The
-/// <see cref="Continuation"/> delegate is invoked with the user's answer and the
-/// UX state driver, and returns an optional <see cref="ChatMessage"/> to add to the
-/// next agent invocation.
-/// </summary>
-/// <param name="Prompt">The question text shown to the user.</param>
-/// <param name="Continuation">
-/// Invoked with the user's answer and the UX state driver. The driver lets the
-/// continuation write output (e.g., an action label like "Approved") in addition
-/// to producing an optional <see cref="ChatMessage"/> for the next agent invocation.
-/// </param>
-public abstract record FollowUpQuestion(
-    string Prompt,
-    Func<string, IUXStateDriver, Task<ChatMessage?>> Continuation) : FollowUpAction;
-
-/// <summary>
-/// A free-form text question. The user may type any response.
-/// </summary>
-/// <param name="Prompt">The question text shown to the user.</param>
-/// <param name="Continuation">Continuation that builds the response message.</param>
-public sealed record TextFollowUpQuestion(
-    string Prompt,
-    Func<string, IUXStateDriver, Task<ChatMessage?>> Continuation)
-    : FollowUpQuestion(Prompt, Continuation);
-
-/// <summary>
-/// A choice question. The user picks from <paramref name="Choices"/>, optionally with
-/// the ability to enter custom text when <paramref name="AllowCustomText"/> is true.
-/// </summary>
-/// <param name="Prompt">The question text shown to the user.</param>
-/// <param name="Choices">The list of pre-defined choices.</param>
-/// <param name="AllowCustomText">If true, the user may type a custom response in addition to the listed choices.</param>
-/// <param name="Continuation">Continuation that builds the response message.</param>
-public sealed record ChoiceFollowUpQuestion(
-    string Prompt,
-    IReadOnlyList<string> Choices,
-    bool AllowCustomText,
-    Func<string, IUXStateDriver, Task<ChatMessage?>> Continuation)
-    : FollowUpQuestion(Prompt, Continuation);
-
-/// <summary>
-/// A message to add directly to the next agent invocation without prompting the user.
-/// </summary>
-/// <param name="Message">The chat message to add.</param>
-public sealed record FollowUpMessage(ChatMessage Message) : FollowUpAction;

dotnet/samples/02-agents/Harness/Harness_Shared_Console/HarnessAgentRunner.cs

@@ -1,279 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using Harness.Shared.Console.Commands;
-using Harness.Shared.Console.Observers;
-using Microsoft.Agents.AI;
-using Microsoft.Extensions.AI;
-
-namespace Harness.Shared.Console;
-
-/// <summary>
-/// Orchestrates agent invocations driven by user-input events from the UI.
-/// The component invokes the runner's input handlers (<see cref="OnUserInputAsync"/>,
-/// <see cref="OnStreamingInputAsync"/>, <see cref="StartAgentTurnAsync"/>) directly;
-/// the runner mutates UI state through the supplied <see cref="IUXStateDriver"/>.
-/// All per-turn follow-up state (pending questions and accumulated responses) lives
-/// in the component's state record — the runner reads/writes it exclusively through
-/// the driver and holds no per-turn fields itself.
-/// </summary>
-public sealed class HarnessAgentRunner : IDisposable
-{
-    private readonly AIAgent _agent;
-    private readonly AgentSession _session;
-    private readonly AgentModeProvider? _modeProvider;
-    private readonly MessageInjectingChatClient? _messageInjector;
-    private readonly IReadOnlyList<CommandHandler> _commandHandlers;
-    private readonly IReadOnlyList<ConsoleObserver> _observers;
-    private readonly IUXStateDriver _ux;
-
-    private readonly SemaphoreSlim _inputGate = new(1, 1);
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="HarnessAgentRunner"/> class.
-    /// </summary>
-    public HarnessAgentRunner(
-        AIAgent agent,
-        AgentSession session,
-        AgentModeProvider? modeProvider,
-        MessageInjectingChatClient? messageInjector,
-        IReadOnlyList<CommandHandler> commandHandlers,
-        IReadOnlyList<ConsoleObserver> observers,
-        IUXStateDriver ux)
-    {
-        this._agent = agent;
-        this._session = session;
-        this._modeProvider = modeProvider;
-        this._messageInjector = messageInjector;
-        this._commandHandlers = commandHandlers;
-        this._observers = observers;
-        this._ux = ux;
-
-        this.HelpText = string.Join(
-            ", ",
-            commandHandlers
-                .Select(h => h.GetHelpText())
-                .Where(t => t is not null)!);
-    }
-
-    /// <summary>
-    /// Gets the help text describing all available commands (joined by ", "), suitable
-    /// for display in the mode-and-help bar. Computed from the supplied
-    /// <c>commandHandlers</c>.
-    /// </summary>
-    public string HelpText { get; }
-
-    /// <inheritdoc/>
-    public void Dispose() => this._inputGate.Dispose();
-
-    /// <summary>
-    /// Handles a top-level user input submission (TextInput mode, no pending question).
-    /// Dispatches to command handlers, or starts an agent turn.
-    /// </summary>
-    internal async Task OnUserInputAsync(string text)
-    {
-        await this._inputGate.WaitAsync().ConfigureAwait(false);
-        try
-        {
-            this._ux.WriteUserInputEcho(text);
-
-            foreach (var handler in this._commandHandlers)
-            {
-                if (await handler.TryHandleAsync(text, this._session, this._ux).ConfigureAwait(false))
-                {
-                    this._ux.CurrentMode = this._modeProvider?.GetMode(this._session);
-                    return;
-                }
-            }
-
-            await this.RunAgentLoopAsync([new ChatMessage(ChatRole.User, text)]).ConfigureAwait(false);
-        }
-        finally
-        {
-            this._inputGate.Release();
-        }
-    }
-
-    /// <summary>
-    /// Handles a user input submission while an agent turn is streaming. The text is
-    /// enqueued via the <see cref="MessageInjectingChatClient"/> so it can be picked up
-    /// by the agent on its next opportunity.
-    /// </summary>
-    internal Task OnStreamingInputAsync(string text)
-    {
-        if (this._messageInjector is null)
-        {
-            return Task.CompletedTask;
-        }
-
-        this._messageInjector.EnqueueMessages(this._session, [new ChatMessage(ChatRole.User, text)]);
-        this._ux.SetQueuedMessages(this._messageInjector.GetPendingMessages(this._session));
-        return Task.CompletedTask;
-    }
-
-    /// <summary>
-    /// Resumes (or completes) a turn after the user has answered all pending follow-up
-    /// questions. The component invokes this with the messages drained from
-    /// <see cref="IUXStateDriver.TakeFollowUpResponses"/>; an empty list simply ends
-    /// the streaming display state without invoking the agent.
-    /// </summary>
-    internal async Task StartAgentTurnAsync(IList<ChatMessage> messages)
-    {
-        await this._inputGate.WaitAsync().ConfigureAwait(false);
-        try
-        {
-            if (messages.Count == 0)
-            {
-                this.CompleteTurn();
-                return;
-            }
-
-            await this.RunAgentLoopAsync(messages).ConfigureAwait(false);
-        }
-        finally
-        {
-            this._inputGate.Release();
-        }
-    }
-
-    private async Task RunAgentLoopAsync(IList<ChatMessage> messages)
-    {
-        IList<ChatMessage>? nextMessages = messages;
-        IReadOnlyList<ChatMessage> lastPendingMessages = this._messageInjector?.GetPendingMessages(this._session) ?? [];
-
-        while (nextMessages is not null)
-        {
-            var runOptions = new AgentRunOptions();
-            foreach (var observer in this._observers)
-            {
-                observer.ConfigureRunOptions(runOptions, this._agent, this._session);
-            }
-
-            this._ux.CurrentMode = this._modeProvider?.GetMode(this._session);
-            this._ux.BeginStreaming();
-            this._ux.BeginStreamingOutput();
-
-            try
-            {
-                await foreach (var update in this._agent.RunStreamingAsync(nextMessages, this._session, runOptions))
-                {
-                    if (this._modeProvider is not null)
-                    {
-                        string currentMode = this._modeProvider.GetMode(this._session);
-                        if (currentMode != this._ux.CurrentMode)
-                        {
-                            this._ux.CurrentMode = currentMode;
-                        }
-                    }
-
-                    foreach (var content in update.Contents)
-                    {
-                        foreach (var observer in this._observers)
-                        {
-                            await observer.OnContentAsync(this._ux, content, this._agent, this._session).ConfigureAwait(false);
-                        }
-                    }
-
-                    if (!string.IsNullOrEmpty(update.Text))
-                    {
-                        foreach (var observer in this._observers)
-                        {
-                            await observer.OnTextAsync(this._ux, update.Text, this._agent, this._session).ConfigureAwait(false);
-                        }
-                    }
-
-                    this.SyncQueuedMessageDisplay(ref lastPendingMessages);
-                }
-            }
-            catch (Exception ex)
-            {
-                await this._ux.WriteInfoLineAsync($"❌ Stream error: {ex.GetType().Name}:\n{ex}", ConsoleColor.Red).ConfigureAwait(false);
-            }
-
-            // Final sync after streaming.
-            this.SyncQueuedMessageDisplay(ref lastPendingMessages);
-
-            this._ux.StopSpinner();
-            await this._ux.EndStreamingOutputAsync().ConfigureAwait(false);
-
-            // Collect FollowUpActions from each observer.
-            var directMessages = new List<ChatMessage>();
-            var questions = new List<FollowUpQuestion>();
-            foreach (var observer in this._observers)
-            {
-                var actions = await observer.OnStreamCompleteAsync(this._ux, this._agent, this._session).ConfigureAwait(false);
-                if (actions is null)
-                {
-                    continue;
-                }
-
-                foreach (var action in actions)
-                {
-                    switch (action)
-                    {
-                        case FollowUpMessage msg:
-                            directMessages.Add(msg.Message);
-                            break;
-                        case FollowUpQuestion q:
-                            questions.Add(q);
-                            break;
-                    }
-                }
-            }
-
-            bool hasFollowUpActions = directMessages.Count > 0 || questions.Count > 0;
-            await this._ux.WriteNoTextWarningAsync(hasFollowUpActions).ConfigureAwait(false);
-
-            // Add any direct messages to the accumulator regardless of whether questions follow —
-            // they're sent on the next agent invocation, either by us (if no questions) or by
-            // the component (after the user finishes answering, via StartAgentTurnAsync).
-            foreach (var msg in directMessages)
-            {
-                this._ux.AddFollowUpResponse(msg);
-            }
-
-            if (questions.Count > 0)
-            {
-                // Pause: hand control back to the UX to collect answers.
-                this._ux.QueueFollowUpQuestions(questions);
-                return;
-            }
-
-            // No questions to ask — drain anything we just accumulated and loop with it.
-            IReadOnlyList<ChatMessage> drained = this._ux.TakeFollowUpResponses();
-            nextMessages = drained.Count > 0 ? [.. drained] : null;
-        }
-
-        this.CompleteTurn();
-    }
-
-    private void CompleteTurn()
-    {
-        this._ux.EndStreaming();
-        this._ux.CurrentMode = this._modeProvider?.GetMode(this._session);
-    }
-
-    /// <summary>
-    /// Synchronizes the queued items display with the message injector's pending messages.
-    /// Messages that have been consumed (drained by the service) are echoed to the output
-    /// area as regular user-input entries.
-    /// </summary>
-    private void SyncQueuedMessageDisplay(ref IReadOnlyList<ChatMessage> lastPendingMessages)
-    {
-        if (this._messageInjector is null)
-        {
-            return;
-        }
-
-        var pending = this._messageInjector.GetPendingMessages(this._session);
-
-        int consumedCount = lastPendingMessages.Count - pending.Count;
-        for (int i = 0; i < consumedCount && i < lastPendingMessages.Count; i++)
-        {
-            string text = lastPendingMessages[i].Text ?? string.Empty;
-            this._ux.WriteUserInputEcho(text);
-        }
-
-        lastPendingMessages = pending;
-        this._ux.SetQueuedMessages(pending);
-    }
-}

dotnet/samples/02-agents/Harness/Harness_Shared_Console/HarnessAppComponent.cs

@@ -3,89 +3,171 @@
 using Harness.ConsoleReactiveComponents;
 using Harness.ConsoleReactiveFramework;
 using Harness.Shared.Console.Components;
-using Microsoft.Extensions.AI;
 
 namespace Harness.Shared.Console;
 
 /// <summary>
-/// The main application component for the Harness console. Manages the scroll region
-/// and bottom panel (text input, list selection, or streaming indicator). Owns the
-/// <see cref="HarnessConsoleUXStateDriver"/> and routes user input events to the
-/// registered <see cref="HarnessAgentRunner"/>.
+/// Determines which component is shown in the bottom panel.
 /// </summary>
-public class HarnessAppComponent : ConsoleReactiveComponent<ConsoleReactiveProps, HarnessAppComponentState>, IDisposable
+public enum BottomPanelMode
+{
+    /// <summary>Show the text input component for user input.</summary>
+    TextInput,
+
+    /// <summary>Show the list selection component for interactive prompts.</summary>
+    ListSelection,
+
+    /// <summary>Show a disabled input indicator during agent streaming.</summary>
+    Streaming,
+}
+
+/// <summary>
+/// Event arguments for the <see cref="HarnessAppComponent.InputSubmitted"/> event.
+/// </summary>
+public sealed class InputSubmittedEventArgs : EventArgs
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="InputSubmittedEventArgs"/> class.
+    /// </summary>
+    /// <param name="text">The submitted text.</param>
+    /// <param name="mode">The bottom panel mode in which the input was submitted.</param>
+    public InputSubmittedEventArgs(string text, BottomPanelMode mode)
+    {
+        this.Text = text;
+        this.Mode = mode;
+    }
+
+    /// <summary>Gets the submitted text.</summary>
+    public string Text { get; }
+
+    /// <summary>Gets the bottom panel mode in which the input was submitted.</summary>
+    public BottomPanelMode Mode { get; }
+}
+
+/// <summary>
+/// Props for <see cref="HarnessAppComponent"/>.
+/// </summary>
+public record HarnessAppComponentProps : ConsoleReactiveProps
+{
+    /// <summary>Gets or sets the list selection choices (for ListSelection mode).</summary>
+    public IReadOnlyList<string> Items { get; set; } = Array.Empty<string>();
+
+    /// <summary>Gets or sets the scroll items (output entries) to render in the scroll panel.</summary>
+    public IReadOnlyList<object> ScrollItems { get; set; } = [];
+
+    /// <summary>Gets or sets the bottom panel mode.</summary>
+    public BottomPanelMode Mode { get; set; } = BottomPanelMode.TextInput;
+
+    /// <summary>Gets or sets the prompt string for text input mode.</summary>
+    public string Prompt { get; set; } = "You: ";
+
+    /// <summary>Gets or sets the placeholder text shown when the input is empty.</summary>
+    public string Placeholder { get; set; } = "";
+
+    /// <summary>Gets or sets the highlight color for the active list item.</summary>
+    public ConsoleColor ListHighlightColor { get; set; } = ConsoleColor.Cyan;
+
+    /// <summary>Gets or sets the placeholder text for the custom text input option in the list.</summary>
+    public string? ListCustomTextPlaceholder { get; set; }
+
+    /// <summary>Gets or sets the foreground color for the rule borders and mode label.</summary>
+    public ConsoleColor? ModeColor { get; set; }
+
+    /// <summary>Gets or sets the current mode name displayed below the bottom rule (e.g. "plan").</summary>
+    public string? ModeText { get; set; }
+
+    /// <summary>Gets or sets the help text displayed below the bottom rule (available commands).</summary>
+    public string? HelpText { get; set; }
+
+    /// <summary>Gets or sets the title text displayed above the list selection (for interactive prompts).</summary>
+    public string? ListTitle { get; set; }
+
+    /// <summary>Gets or sets a value indicating whether input is enabled during streaming.</summary>
+    public bool InputEnabled { get; set; }
+
+    /// <summary>Gets or sets the prompt to show during streaming when input is disabled.</summary>
+    public string StreamingPrompt { get; set; } = "(agent is running...)";
+
+    /// <summary>Gets or sets a value indicating whether the agent status spinner is visible.</summary>
+    public bool ShowSpinner { get; set; }
+
+    /// <summary>Gets or sets the formatted token usage text to display in the status bar.</summary>
+    public string? UsageText { get; set; }
+
+    /// <summary>Gets or sets the queued input items to display above the rule.</summary>
+    public IReadOnlyList<object> QueuedItems { get; set; } = [];
+}
+
+/// <summary>
+/// Internal state for <see cref="HarnessAppComponent"/>.
+/// </summary>
+public record HarnessAppComponentState : ConsoleReactiveState
+{
+    /// <summary>Gets the selected index in list selection mode.</summary>
+    public int SelectedIndex { get; init; }
+
+    /// <summary>Gets the current input text being typed.</summary>
+    public string InputText { get; init; } = "";
+
+    /// <summary>Gets the current text being typed into the list's custom text option.</summary>
+    public string ListInputText { get; init; } = "";
+
+    /// <summary>Gets the current console width in columns.</summary>
+    public int ConsoleWidth { get; init; }
+
+    /// <summary>Gets the current console height in rows.</summary>
+    public int ConsoleHeight { get; init; }
+}
+
+/// <summary>
+/// The main application component for the Harness console. Manages the scroll region
+/// and bottom panel (text input, list selection, or streaming indicator), and emits
+/// an <see cref="InputSubmitted"/> event when the user submits text in any mode.
+/// </summary>
+public class HarnessAppComponent : ConsoleReactiveComponent<HarnessAppComponentProps, HarnessAppComponentState>, IDisposable
 {
     private readonly TopBottomRule _rule = new();
     private readonly ListSelection _listSelection = new();
     private readonly TextInput _textInput = new();
-    private readonly TextScrollPanel _textScrollPanel = new();
-    private readonly TextPanel _textPanel = new();
-    private readonly TextPanel _queuedPanel = new();
+    private readonly TextScrollPanel _textScrollPanel;
+    private readonly TextPanel _textPanel;
+    private readonly TextPanel _queuedPanel;
     private readonly AgentStatus _agentStatus = new();
     private readonly AgentModeAndHelp _modeAndHelp = new();
-    private readonly HarnessConsoleUXStateDriver _uxDriver;
-    private readonly TaskCompletionSource<bool> _shutdownTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
-    private readonly SemaphoreSlim _followUpGate = new(1, 1);
-    private int _scrollRegionBottom;
-    private bool _resizedSinceLastRender = true;
+    private readonly Func<object, string> _renderItem;
+    private bool _resizedSinceLastRender;
     private bool _deactivated;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="HarnessAppComponent"/> class.
     /// </summary>
-    /// <param name="placeholder">Placeholder text shown when the input is empty.</param>
-    /// <param name="initialMode">The current agent mode, used to colour the rule and prompt.</param>
-    /// <param name="inputEnabled">Whether the bottom-panel input accepts keystrokes during streaming.</param>
-    /// <param name="runnerFactory">Factory invoked with the component's <see cref="IUXStateDriver"/>
-    /// to construct the <see cref="HarnessAgentRunner"/> that owns the agent loop.</param>
-    /// <param name="modeColors">Optional mapping of mode names to console colors.</param>
-    public HarnessAppComponent(
-        string placeholder,
-        string? initialMode,
-        bool inputEnabled,
-        Func<IUXStateDriver, HarnessAgentRunner> runnerFactory,
-        IReadOnlyDictionary<string, ConsoleColor>? modeColors = null)
+    /// <param name="renderScrollItem">A delegate that renders a single output entry and returns the text to display.</param>
+    public HarnessAppComponent(Func<object, string> renderScrollItem)
     {
-        this.Props = new ConsoleReactiveProps();
+        this._renderItem = renderScrollItem;
+        this._textScrollPanel = new TextScrollPanel(renderScrollItem);
+        this._textPanel = new TextPanel(renderScrollItem);
+        this._queuedPanel = new TextPanel(renderScrollItem);
         this.State = new HarnessAppComponentState
         {
-            Mode = BottomPanelMode.TextInput,
-            Prompt = "> ",
-            Placeholder = placeholder,
-            ModeColor = ModeColors.Get(initialMode, modeColors),
-            ModeText = initialMode,
-            InputEnabled = inputEnabled,
             ConsoleWidth = System.Console.WindowWidth,
             ConsoleHeight = System.Console.WindowHeight,
         };
-
-        this._uxDriver = new HarnessConsoleUXStateDriver(
-            getState: () => this.State!,
-            setState: s => this.SetState(s),
-            requestShutdown: () => this._shutdownTcs.TrySetResult(true),
-            modeColors: modeColors);
-
-        this.Runner = runnerFactory(this._uxDriver);
-
-        // Seed help text now that the runner (which knows the registered command handlers)
-        // is available. Direct assignment — no Render is triggered until the caller invokes Render().
-        this.State = this.State with { HelpText = this.Runner.HelpText };
-
         KeyEventListener.Instance.KeyPressed += this.OnKeyPressed;
         ConsoleResizeListener.Instance.ConsoleResized += this.OnConsoleResized;
     }
 
     /// <summary>
-    /// Gets the agent runner that owns the agent loop. Constructed by the factory
-    /// passed to the component's constructor.
+    /// Gets the 1-based row number of the last row in the output scroll region.
     /// </summary>
-    public HarnessAgentRunner Runner { get; }
+    public int ScrollRegionBottom { get; private set; }
 
     /// <summary>
-    /// Completes when a command handler requests application shutdown (e.g. the user types <c>/exit</c>).
-    /// Awaited by <see cref="HarnessConsole.RunAgentAsync"/>.
+    /// Occurs when the user submits input via Enter, in any mode (text input, list selection,
+    /// or streaming injection). Consumers inspect <see cref="InputSubmittedEventArgs.Mode"/>
+    /// to decide how to handle the submission.
     /// </summary>
-    public Task ShutdownTask => this._shutdownTcs.Task;
+    public event EventHandler<InputSubmittedEventArgs>? InputSubmitted;
 
     /// <summary>
     /// Deactivates the component, resetting the scroll region and unsubscribing from events.
@@ -102,6 +184,9 @@ public class HarnessAppComponent : ConsoleReactiveComponent<ConsoleReactiveProps
         this._agentStatus.Dispose();
         KeyEventListener.Instance.KeyPressed -= this.OnKeyPressed;
         ConsoleResizeListener.Instance.ConsoleResized -= this.OnConsoleResized;
+        System.Console.Write(AnsiEscapes.ResetScrollRegion);
+        System.Console.Write(AnsiEscapes.MoveCursor(System.Console.WindowHeight, 1));
+        System.Console.WriteLine();
     }
 
     /// <inheritdoc/>
@@ -120,23 +205,20 @@ public class HarnessAppComponent : ConsoleReactiveComponent<ConsoleReactiveProps
         if (disposing)
         {
             this.Deactivate();
-            this._followUpGate.Dispose();
-            this.Runner.Dispose();
         }
     }
 
     private void OnKeyPressed(object? sender, KeyPressEventArgs e)
     {
-        BottomPanelMode mode = this.State!.Mode;
-        if (mode == BottomPanelMode.TextInput)
+        if (this.Props!.Mode == BottomPanelMode.TextInput)
         {
             this.HandleTextInputKey(e);
         }
-        else if (mode == BottomPanelMode.ListSelection)
+        else if (this.Props.Mode == BottomPanelMode.ListSelection)
         {
             this.HandleListSelectionKey(e);
         }
-        else if (mode == BottomPanelMode.Streaming && this.State.InputEnabled)
+        else if (this.Props.Mode == BottomPanelMode.Streaming && this.Props.InputEnabled)
         {
             this.HandleStreamingInputKey(e);
         }
@@ -153,7 +235,7 @@ public class HarnessAppComponent : ConsoleReactiveComponent<ConsoleReactiveProps
             }
 
             this.SetState(this.State with { InputText = "" });
-            this.DispatchTextInputSubmission(text);
+            this.InputSubmitted?.Invoke(this, new InputSubmittedEventArgs(text, BottomPanelMode.TextInput));
         }
         else if (e.KeyInfo.Key == ConsoleKey.Backspace)
         {
@@ -170,50 +252,51 @@ public class HarnessAppComponent : ConsoleReactiveComponent<ConsoleReactiveProps
 
     private void HandleListSelectionKey(KeyPressEventArgs e)
     {
-        int maxIndex = this.State!.ListSelectionOptions.Count - 1;
-        if (this.State.ListSelectionCustomTextPlaceholder != null)
+        int maxIndex = this.Props!.Items.Count - 1;
+        if (this.Props.ListCustomTextPlaceholder != null)
         {
-            maxIndex = this.State.ListSelectionOptions.Count;
+            maxIndex = this.Props.Items.Count;
         }
 
-        bool isOnCustomTextOption = this.State.ListSelectionCustomTextPlaceholder != null
-            && this.State.ListSelectionIndex == this.State.ListSelectionOptions.Count;
+        bool isOnCustomTextOption = this.Props.ListCustomTextPlaceholder != null
+            && this.State!.SelectedIndex == this.Props.Items.Count;
 
         if (e.KeyInfo.Key == ConsoleKey.UpArrow)
         {
-            this.SetState(this.State with { ListSelectionIndex = Math.Max(0, this.State.ListSelectionIndex - 1) });
+            this.SetState(this.State! with { SelectedIndex = Math.Max(0, this.State.SelectedIndex - 1) });
         }
         else if (e.KeyInfo.Key == ConsoleKey.DownArrow)
         {
-            this.SetState(this.State with { ListSelectionIndex = Math.Min(maxIndex, this.State.ListSelectionIndex + 1) });
+            this.SetState(this.State! with { SelectedIndex = Math.Min(maxIndex, this.State.SelectedIndex + 1) });
         }
         else if (e.KeyInfo.Key == ConsoleKey.Enter)
         {
             string result = isOnCustomTextOption
-                ? this.State.ListSelectionCustomInputText
-                : this.State.ListSelectionOptions[this.State.ListSelectionIndex];
+                ? this.State!.ListInputText
+                : this.Props.Items[this.State!.SelectedIndex];
 
-            this.SetState(this.State with { ListSelectionCustomInputText = "", ListSelectionIndex = 0 });
-            this.DispatchListSelectionSubmission(result);
+            this.SetState(this.State with { ListInputText = "", SelectedIndex = 0 });
+            this.InputSubmitted?.Invoke(this, new InputSubmittedEventArgs(result, BottomPanelMode.ListSelection));
         }
         else if (isOnCustomTextOption)
         {
             if (e.KeyInfo.Key == ConsoleKey.Backspace)
             {
-                if (this.State.ListSelectionCustomInputText.Length > 0)
+                if (this.State!.ListInputText.Length > 0)
                 {
-                    this.SetState(this.State with { ListSelectionCustomInputText = this.State.ListSelectionCustomInputText[..^1] });
+                    this.SetState(this.State with { ListInputText = this.State.ListInputText[..^1] });
                 }
             }
             else if (e.KeyInfo.KeyChar != '\0' && !char.IsControl(e.KeyInfo.KeyChar))
             {
-                this.SetState(this.State with { ListSelectionCustomInputText = this.State.ListSelectionCustomInputText + e.KeyInfo.KeyChar });
+                this.SetState(this.State! with { ListInputText = this.State.ListInputText + e.KeyInfo.KeyChar });
             }
         }
     }
 
     private void HandleStreamingInputKey(KeyPressEventArgs e)
     {
+        // During streaming with input enabled, capture text for message injection
         if (e.KeyInfo.Key == ConsoleKey.Enter)
         {
             string text = this.State!.InputText;
@@ -223,7 +306,7 @@ public class HarnessAppComponent : ConsoleReactiveComponent<ConsoleReactiveProps
             }
 
             this.SetState(this.State with { InputText = "" });
-            _ = this.Runner.OnStreamingInputAsync(text);
+            this.InputSubmitted?.Invoke(this, new InputSubmittedEventArgs(text, BottomPanelMode.Streaming));
         }
         else if (e.KeyInfo.Key == ConsoleKey.Backspace)
         {
@@ -238,90 +321,6 @@ public class HarnessAppComponent : ConsoleReactiveComponent<ConsoleReactiveProps
         }
     }
 
-    private void DispatchTextInputSubmission(string text)
-    {
-        if (this.State!.PendingQuestions.Count > 0)
-        {
-            _ = this.HandleFollowUpAnswerAsync(text);
-        }
-        else
-        {
-            _ = this.Runner.OnUserInputAsync(text);
-        }
-    }
-
-    private void DispatchListSelectionSubmission(string text)
-    {
-        // List selection is only used to answer FollowUpQuestions.
-        _ = this.HandleFollowUpAnswerAsync(text);
-    }
-
-    /// <summary>
-    /// Handles a user answer to the head of the pending follow-up question queue:
-    /// awaits the question's continuation (which is responsible for echoing both the
-    /// question and answer to the scroll area as it sees fit), appends any returned
-    /// chat message to the response accumulator, advances the queue, and — when the
-    /// queue empties — drains the accumulator and resumes the runner.
-    /// </summary>
-    private async Task HandleFollowUpAnswerAsync(string text)
-    {
-        IReadOnlyList<ChatMessage>? messagesToSend = null;
-
-        await this._followUpGate.WaitAsync().ConfigureAwait(false);
-        try
-        {
-            HarnessConsoleUXStateDriver ux = this._uxDriver;
-            IReadOnlyList<FollowUpQuestion> queue = this.State!.PendingQuestions;
-            if (queue.Count == 0)
-            {
-                return;
-            }
-
-            FollowUpQuestion head = queue[0];
-
-            ChatMessage? response;
-            try
-            {
-                response = await head.Continuation(text, ux).ConfigureAwait(false);
-            }
-            catch (Exception ex)
-            {
-                await ux.WriteInfoLineAsync($"❌ Follow-up handler error: {ex.GetType().Name}: {ex.Message}", ConsoleColor.Red).ConfigureAwait(false);
-                response = null;
-            }
-
-            if (response is not null)
-            {
-                ux.AddFollowUpResponse(response);
-            }
-
-            ux.AdvanceFollowUpQuestion();
-
-            if (this.State!.PendingQuestions.Count == 0)
-            {
-                messagesToSend = ux.TakeFollowUpResponses();
-            }
-        }
-        finally
-        {
-            this._followUpGate.Release();
-        }
-
-        // Resume the agent outside the gate — StartAgentTurnAsync runs the full agent
-        // loop which may queue new follow-up questions (re-entering this method).
-        if (messagesToSend is not null)
-        {
-            try
-            {
-                await this.Runner.StartAgentTurnAsync([.. messagesToSend]).ConfigureAwait(false);
-            }
-            catch (Exception ex)
-            {
-                await this._uxDriver.WriteInfoLineAsync($"❌ Agent error: {ex.GetType().Name}: {ex.Message}", ConsoleColor.Red).ConfigureAwait(false);
-            }
-        }
-    }
-
     private void OnConsoleResized(object? sender, ConsoleResizeEventArgs e)
     {
         this._resizedSinceLastRender = true;
@@ -333,40 +332,35 @@ public class HarnessAppComponent : ConsoleReactiveComponent<ConsoleReactiveProps
     }
 
     /// <inheritdoc />
-    public override void RenderCore(ConsoleReactiveProps props, HarnessAppComponentState state)
+    public override void RenderCore(HarnessAppComponentProps props, HarnessAppComponentState state)
     {
-        if (this._deactivated)
-        {
-            return;
-        }
-
         // Determine the text panel height for the last scroll item
-        IReadOnlyList<string> lastItems = state.ScrollAreaContentItems.Count > 0
-            ? [state.ScrollAreaContentItems[^1]]
+        IReadOnlyList<object> lastItems = props.ScrollItems.Count > 0
+            ? [props.ScrollItems[^1]]
             : [];
-        int textPanelHeight = TextPanel.CalculateHeight(lastItems);
+        int textPanelHeight = TextPanel.CalculateHeight(lastItems, this._renderItem);
         if (textPanelHeight > 0)
         {
             textPanelHeight++; // Extra line for spacing between text panel and rule
         }
 
         // Calculate queued items panel height
-        int queuedPanelHeight = TextPanel.CalculateHeight(state.QueuedItems);
+        int queuedPanelHeight = TextPanel.CalculateHeight(props.QueuedItems, this._renderItem);
 
         // Build the bottom panel child based on mode
         ConsoleReactiveComponent bottomChild;
         int bottomChildHeight;
 
-        if (state.Mode == BottomPanelMode.ListSelection)
+        if (props.Mode == BottomPanelMode.ListSelection)
         {
             var listProps = new ListSelectionProps
             {
-                Title = state.ListSelectionTitle,
-                Items = state.ListSelectionOptions,
-                SelectedIndex = state.ListSelectionIndex,
-                HighlightColor = state.ListHighlightColor,
-                CustomTextPlaceholder = state.ListSelectionCustomTextPlaceholder,
-                CustomText = state.ListSelectionCustomInputText,
+                Title = props.ListTitle,
+                Items = props.Items,
+                SelectedIndex = state.SelectedIndex,
+                HighlightColor = props.ListHighlightColor,
+                CustomTextPlaceholder = props.ListCustomTextPlaceholder,
+                CustomText = state.ListInputText,
             };
 
             bottomChildHeight = ListSelection.CalculateHeight(listProps);
@@ -374,25 +368,25 @@ public class HarnessAppComponent : ConsoleReactiveComponent<ConsoleReactiveProps
             this._listSelection.Props = listProps;
             bottomChild = this._listSelection;
         }
-        else if (state.Mode == BottomPanelMode.Streaming)
+        else if (props.Mode == BottomPanelMode.Streaming)
         {
             TextInputProps textInputProps;
-            if (state.InputEnabled)
+            if (props.InputEnabled)
             {
                 textInputProps = new TextInputProps
                 {
-                    Prompt = state.Prompt,
+                    Prompt = props.Prompt,
                     Text = state.InputText,
-                    Placeholder = state.Placeholder,
+                    Placeholder = props.Placeholder,
                 };
             }
             else
             {
                 textInputProps = new TextInputProps
                 {
-                    Prompt = state.Prompt,
+                    Prompt = props.Prompt,
                     Text = "",
-                    Placeholder = state.StreamingPrompt,
+                    Placeholder = props.StreamingPrompt,
                 };
             }
 
@@ -406,9 +400,9 @@ public class HarnessAppComponent : ConsoleReactiveComponent<ConsoleReactiveProps
         {
             var textInputProps = new TextInputProps
             {
-                Prompt = state.Prompt,
+                Prompt = props.Prompt,
                 Text = state.InputText,
-                Placeholder = state.Placeholder,
+                Placeholder = props.Placeholder,
             };
 
             bottomChildHeight = TextInput.CalculateHeight(textInputProps, state.ConsoleWidth);
@@ -421,52 +415,46 @@ public class HarnessAppComponent : ConsoleReactiveComponent<ConsoleReactiveProps
         var ruleProps = new TopBottomRuleProps
         {
             Width = state.ConsoleWidth,
-            Color = state.ModeColor,
+            Color = props.ModeColor,
             Children = [bottomChild],
         };
 
+        // Calculate the agent status height
         var agentStatusProps = new AgentStatusProps
         {
-            ShowSpinner = state.ShowSpinner,
-            UsageText = state.UsageText,
+            ShowSpinner = props.ShowSpinner,
+            UsageText = props.UsageText,
         };
+        int agentStatusHeight = AgentStatus.CalculateHeight(agentStatusProps);
 
+        // Calculate the mode-and-help height
         var modeAndHelpProps = new AgentModeAndHelpProps
         {
-            Mode = state.ModeText,
-            ModeColor = state.ModeColor,
-            HelpText = state.HelpText,
+            Mode = props.ModeText,
+            ModeColor = props.ModeColor,
+            HelpText = props.HelpText,
         };
-
-        // Hide agent status and mode/help during follow-up questions (ListSelection mode)
-        // as they clutter the UI and aren't relevant.
-        bool showStatusAndHelp = state.Mode != BottomPanelMode.ListSelection;
-        int agentStatusHeight = showStatusAndHelp ? AgentStatus.CalculateHeight(agentStatusProps) : 0;
-        int modeAndHelpHeight = showStatusAndHelp ? AgentModeAndHelp.CalculateHeight(modeAndHelpProps) : 0;
+        int modeAndHelpHeight = AgentModeAndHelp.CalculateHeight(modeAndHelpProps);
 
         int ruleHeight = TopBottomRule.CalculateHeight(ruleProps);
-        int nonScrollHeight = ruleHeight + textPanelHeight + agentStatusHeight + queuedPanelHeight + modeAndHelpHeight + 1; // +1 for bottom padding
-        int scrollBottom = Math.Max(1, state.ConsoleHeight - nonScrollHeight);
+        int scrollBottom = Math.Max(1, state.ConsoleHeight - ruleHeight - textPanelHeight - agentStatusHeight - queuedPanelHeight - modeAndHelpHeight);
 
         // If scroll region changed or a clear is needed, reset everything
-        if (this._resizedSinceLastRender || (this._scrollRegionBottom != 0 && scrollBottom != this._scrollRegionBottom))
+        if (this._resizedSinceLastRender || (this.ScrollRegionBottom != 0 && scrollBottom != this.ScrollRegionBottom))
         {
-            // Reset scroll region to full screen before erasing so the erase covers all rows —
-            // some terminals only erase within the active DECSTBM region.
-            System.Console.Write(AnsiEscapes.ResetScrollRegion);
             System.Console.Write(AnsiEscapes.EraseEntireScreen);
             System.Console.Write(AnsiEscapes.EraseScrollbackBuffer);
             this._textScrollPanel.Reset();
             this._resizedSinceLastRender = false;
         }
 
-        this._scrollRegionBottom = scrollBottom;
+        this.ScrollRegionBottom = scrollBottom;
 
         System.Console.Write(AnsiEscapes.SetScrollRegion(scrollBottom));
 
         // Render text scroll panel in the scroll area (all items except the last)
-        IReadOnlyList<string> scrollItems = state.ScrollAreaContentItems.Count > 1
-            ? state.ScrollAreaContentItems.Take(state.ScrollAreaContentItems.Count - 1).ToList()
+        IReadOnlyList<object> scrollItems = props.ScrollItems.Count > 1
+            ? props.ScrollItems.Take(props.ScrollItems.Count - 1).ToList()
             : [];
 
         this._textScrollPanel.X = 1;
@@ -498,21 +486,18 @@ public class HarnessAppComponent : ConsoleReactiveComponent<ConsoleReactiveProps
         this._queuedPanel.Height = queuedPanelHeight;
         this._queuedPanel.Props = new TextPanelProps
         {
-            Items = state.QueuedItems,
+            Items = props.QueuedItems,
         };
         this._queuedPanel.Render();
 
         // Render the agent status line between queued items and rule
         int agentStatusY = queuedPanelY + queuedPanelHeight;
-        if (showStatusAndHelp)
-        {
-            this._agentStatus.X = 1;
-            this._agentStatus.Y = agentStatusY;
-            this._agentStatus.Width = state.ConsoleWidth;
-            this._agentStatus.Height = agentStatusHeight;
-            this._agentStatus.Props = agentStatusProps;
-            this._agentStatus.Render();
-        }
+        this._agentStatus.X = 1;
+        this._agentStatus.Y = agentStatusY;
+        this._agentStatus.Width = state.ConsoleWidth;
+        this._agentStatus.Height = agentStatusHeight;
+        this._agentStatus.Props = agentStatusProps;
+        this._agentStatus.Render();
 
         // Render the bottom rule + child below the agent status
         this._rule.X = 1;
@@ -521,27 +506,24 @@ public class HarnessAppComponent : ConsoleReactiveComponent<ConsoleReactiveProps
         this._rule.Render();
 
         // Render the mode-and-help line below the bottom rule
-        if (showStatusAndHelp)
-        {
-            int modeAndHelpY = this._rule.Y + ruleHeight;
-            this._modeAndHelp.X = 1;
-            this._modeAndHelp.Y = modeAndHelpY;
-            this._modeAndHelp.Width = state.ConsoleWidth;
-            this._modeAndHelp.Height = modeAndHelpHeight;
-            this._modeAndHelp.Props = modeAndHelpProps;
-            this._modeAndHelp.Render();
-        }
+        int modeAndHelpY = this._rule.Y + ruleHeight;
+        this._modeAndHelp.X = 1;
+        this._modeAndHelp.Y = modeAndHelpY;
+        this._modeAndHelp.Width = state.ConsoleWidth;
+        this._modeAndHelp.Height = modeAndHelpHeight;
+        this._modeAndHelp.Props = modeAndHelpProps;
+        this._modeAndHelp.Render();
 
         // Position cursor for natural typing appearance
-        this.PositionCursor(state);
+        this.PositionCursor(props, state);
     }
 
-    private void PositionCursor(HarnessAppComponentState state)
+    private void PositionCursor(HarnessAppComponentProps props, HarnessAppComponentState state)
     {
-        if (state.Mode == BottomPanelMode.TextInput
-            || (state.Mode == BottomPanelMode.Streaming && state.InputEnabled))
+        if (props.Mode == BottomPanelMode.TextInput
+            || (props.Mode == BottomPanelMode.Streaming && props.InputEnabled))
         {
-            int promptLength = state.Prompt.Length;
+            int promptLength = props.Prompt.Length;
             int textWidth = state.ConsoleWidth - promptLength;
             int textLength = state.InputText.Length;
 
@@ -558,13 +540,13 @@ public class HarnessAppComponent : ConsoleReactiveComponent<ConsoleReactiveProps
                 System.Console.Write(AnsiEscapes.MoveCursor(textInputY + cursorRow, promptLength + cursorCol + 1));
             }
         }
-        else if (state.Mode == BottomPanelMode.ListSelection
-            && state.ListSelectionCustomTextPlaceholder != null
-            && state.ListSelectionIndex == state.ListSelectionOptions.Count)
+        else if (props.Mode == BottomPanelMode.ListSelection
+            && props.ListCustomTextPlaceholder != null
+            && state.SelectedIndex == props.Items.Count)
         {
-            int titleLines = state.ListSelectionTitle?.Split('\n').Length ?? 0;
-            int customOptionY = this._rule.Y + 1 + titleLines + state.ListSelectionOptions.Count;
-            int cursorCol = 2 + state.ListSelectionCustomInputText.Length + 1;
+            int titleLines = props.ListTitle?.Split('\n').Length ?? 0;
+            int customOptionY = this._rule.Y + 1 + titleLines + props.Items.Count;
+            int cursorCol = 2 + state.ListInputText.Length + 1;
             System.Console.Write(AnsiEscapes.MoveCursor(customOptionY, cursorCol));
         }
     }

dotnet/samples/02-agents/Harness/Harness_Shared_Console/HarnessAppComponentState.cs

@@ -1,125 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using Harness.ConsoleReactiveFramework;
-using Microsoft.Extensions.AI;
-
-namespace Harness.Shared.Console;
-
-/// <summary>
-/// Determines which component is shown in the bottom panel.
-/// </summary>
-public enum BottomPanelMode
-{
-    /// <summary>Show the text input component for user input.</summary>
-    TextInput,
-
-    /// <summary>Show the list selection component for interactive prompts.</summary>
-    ListSelection,
-
-    /// <summary>Show a disabled input indicator during agent streaming.</summary>
-    Streaming,
-}
-
-/// <summary>
-/// Internal state for <see cref="HarnessAppComponent"/>. All UI fields that may
-/// change after construction live here; they are mutated exclusively via
-/// <see cref="ConsoleReactiveComponent{TProps,TState}.SetState"/> by the
-/// owning <see cref="HarnessConsoleUXStateDriver"/>.
-/// </summary>
-public record HarnessAppComponentState : ConsoleReactiveState
-{
-    // --- Console dimensions ---
-
-    /// <summary>Gets the current console width in columns.</summary>
-    public int ConsoleWidth { get; init; }
-
-    /// <summary>Gets the current console height in rows.</summary>
-    public int ConsoleHeight { get; init; }
-
-    // --- Bottom panel mode ---
-
-    /// <summary>Gets the bottom panel mode.</summary>
-    public BottomPanelMode Mode { get; init; } = BottomPanelMode.TextInput;
-
-    /// <summary>
-    /// Gets the queue of follow-up questions waiting for user answers. The head
-    /// (<c>[0]</c>) is the question currently being displayed; subsequent items
-    /// are dispatched in order as each is answered. While this queue is non-empty,
-    /// the next user submission is treated as the answer to the head question
-    /// instead of going to the agent runner's normal input handler.
-    /// </summary>
-    public IReadOnlyList<FollowUpQuestion> PendingQuestions { get; init; } = [];
-
-    /// <summary>
-    /// Gets the accumulated follow-up response messages collected during the
-    /// current agent turn — both direct <see cref="FollowUpMessage"/>s emitted
-    /// by observers and continuation results from answered questions. Consumed
-    /// by the runner via <see cref="IUXStateDriver.TakeFollowUpResponses"/>
-    /// before the next agent invocation.
-    /// </summary>
-    public IReadOnlyList<ChatMessage> AccumulatedFollowUpResponses { get; init; } = [];
-
-    // --- Text input (active in TextInput / Streaming modes) ---
-
-    /// <summary>Gets the prompt string for text input mode.</summary>
-    public string Prompt { get; init; } = "> ";
-
-    /// <summary>Gets the placeholder text shown when the input is empty.</summary>
-    public string Placeholder { get; init; } = "";
-
-    /// <summary>Gets the current input text being typed.</summary>
-    public string InputText { get; init; } = "";
-
-    /// <summary>Gets a value indicating whether input is enabled during streaming.</summary>
-    public bool InputEnabled { get; init; }
-
-    /// <summary>Gets the prompt to show during streaming when input is disabled.</summary>
-    public string StreamingPrompt { get; init; } = "(agent is running...)";
-
-    // --- List selection (active in ListSelection mode) ---
-
-    /// <summary>Gets the title text displayed above the list selection (for interactive prompts).</summary>
-    public string? ListSelectionTitle { get; init; }
-
-    /// <summary>Gets the list selection options.</summary>
-    public IReadOnlyList<string> ListSelectionOptions { get; init; } = [];
-
-    /// <summary>Gets the highlighted option index in list selection mode.</summary>
-    public int ListSelectionIndex { get; init; }
-
-    /// <summary>Gets the placeholder text for the custom text input option in the list.</summary>
-    public string? ListSelectionCustomTextPlaceholder { get; init; }
-
-    /// <summary>Gets the current text being typed into the list's custom text option.</summary>
-    public string ListSelectionCustomInputText { get; init; } = "";
-
-    /// <summary>Gets the highlight color for the active list item.</summary>
-    public ConsoleColor ListHighlightColor { get; init; } = ConsoleColor.Cyan;
-
-    // --- Scroll / output area ---
-
-    /// <summary>Gets the items rendered in the scroll-area. Each item is a pre-rendered
-    /// console string (may include ANSI escape sequences and newlines).</summary>
-    public IReadOnlyList<string> ScrollAreaContentItems { get; init; } = [];
-
-    /// <summary>Gets the queued input items to display above the rule. Each item is a
-    /// pre-rendered console string (may include ANSI escape sequences and newlines).</summary>
-    public IReadOnlyList<string> QueuedItems { get; init; } = [];
-
-    // --- Agent mode + status display ---
-
-    /// <summary>Gets the foreground color for the rule borders and mode label.</summary>
-    public ConsoleColor? ModeColor { get; init; }
-
-    /// <summary>Gets the current mode name displayed below the bottom rule (e.g. "plan").</summary>
-    public string? ModeText { get; init; }
-
-    /// <summary>Gets the help text displayed below the bottom rule (available commands).</summary>
-    public string? HelpText { get; init; }
-
-    /// <summary>Gets a value indicating whether the agent status spinner is visible.</summary>
-    public bool ShowSpinner { get; init; }
-
-    /// <summary>Gets the formatted token usage text to display in the status bar.</summary>
-    public string? UsageText { get; init; }
-}

dotnet/samples/02-agents/Harness/Harness_Shared_Console/HarnessConsole.cs

@@ -1,7 +1,9 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using Harness.ConsoleReactiveComponents;
+using Harness.Shared.Console.Commands;
+using Harness.Shared.Console.Observers;
 using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
 
 namespace Harness.Shared.Console;
 
@@ -13,58 +15,244 @@ public static class HarnessConsole
 {
     /// <summary>
     /// Runs an interactive console session with the specified agent.
-    /// Constructs the reactive UI component and the <see cref="HarnessAgentRunner"/>,
-    /// wires them together, and awaits the component's <see cref="HarnessAppComponent.ShutdownTask"/>
-    /// (which completes when the user types <c>/exit</c>).
+    /// Supports streaming output, tool call display, spinner animation,
+    /// optional planning UX with structured output, and the <c>/todos</c> command.
     /// </summary>
     /// <param name="agent">The agent to interact with.</param>
-    /// <param name="userPrompt">A short prompt to the user, displayed as a placeholder in the input area.</param>
+    /// <param name="title">The title displayed in the console header.</param>
+    /// <param name="userPrompt">A short prompt to the user, displayed below the title.</param>
     /// <param name="options">Optional configuration options for the console session.</param>
-    public static async Task RunAgentAsync(AIAgent agent, string userPrompt, HarnessConsoleOptions? options = null)
+    public static async Task RunAgentAsync(AIAgent agent, string title, string userPrompt, HarnessConsoleOptions? options = null)
     {
         options ??= new();
 
-        // Null means use defaults; an explicit (possibly empty) list means use exactly what was provided.
-        var observers = options.Observers
-            ?? HarnessConsoleOptions.BuildDefaultObservers();
-        var commandHandlers = options.CommandHandlers
-            ?? HarnessConsoleOptions.BuildDefaultCommandHandlers(agent, options.ModeColors);
+        if (options.EnablePlanningUx
+            && (string.IsNullOrWhiteSpace(options.PlanningModeName) || string.IsNullOrWhiteSpace(options.ExecutionModeName)))
+        {
+            throw new ArgumentException(
+                "When EnablePlanningUx is true, both PlanningModeName and ExecutionModeName must be configured.",
+                nameof(options));
+        }
 
+        var todoProvider = agent.GetService<TodoProvider>();
         var modeProvider = agent.GetService<AgentModeProvider>();
         var messageInjector = agent.GetService<MessageInjectingChatClient>();
 
+        var commandHandlers = new List<CommandHandler>
+        {
+            new TodoCommandHandler(todoProvider),
+            new ModeCommandHandler(modeProvider, options.ModeColors),
+        };
+
         AgentSession session = await agent.CreateSessionAsync();
 
-        using var component = new HarnessAppComponent(
+        using var ux = new HarnessUXContainer(
             placeholder: userPrompt,
             initialMode: modeProvider?.GetMode(session),
             inputEnabled: messageInjector is not null,
-            runnerFactory: ux => new HarnessAgentRunner(
-                agent: agent,
-                session: session,
-                modeProvider: modeProvider,
-                messageInjector: messageInjector,
-                commandHandlers: commandHandlers,
-                observers: observers,
-                ux: ux),
             modeColors: options.ModeColors);
 
-        // Trigger the initial render of the component now that state is seeded.
-        component.Render();
+        // Streaming-mode submissions are enqueued for injection; the queued display
+        // is then refreshed from the injector's current pending list.
+        ux.StreamingInputReceived += (sender, e) =>
+        {
+            if (messageInjector is null)
+            {
+                return;
+            }
 
-        try
+            messageInjector.EnqueueMessages(session, [new ChatMessage(ChatRole.User, e.Text)]);
+            ux.ShowQueuedMessages(messageInjector.GetPendingMessages(session));
+        };
+
+        var commandHelp = commandHandlers
+            .Select(h => h.GetHelpText())
+            .Where(t => t is not null)
+            .Append("exit (quit)")!;
+
+        ux.Initialize(title, commandHelp!, messageInjector is not null);
+
+        string userInput = await ux.WaitForInputAsync();
+
+        while (!string.IsNullOrWhiteSpace(userInput) && !userInput.Equals("exit", StringComparison.OrdinalIgnoreCase))
         {
-            await component.ShutdownTask.ConfigureAwait(false);
-        }
-        finally
-        {
-            component.Deactivate();
+            ux.WriteUserInputEcho(userInput);
+
+            // Check command handlers first — first one to handle wins.
+            bool handled = false;
+            foreach (var handler in commandHandlers)
+            {
+                if (await handler.TryHandleAsync(userInput, session, ux).ConfigureAwait(false))
+                {
+                    handled = true;
+                    break;
+                }
+            }
+
+            if (!handled)
+            {
+                await RunAgentTurnAsync(agent, session, modeProvider, messageInjector, options, ux, userInput);
+            }
+
+            ux.CurrentMode = modeProvider?.GetMode(session);
+            userInput = await ux.WaitForInputAsync();
         }
 
+        ux.Deactivate();
         System.Console.ResetColor();
-        System.Console.Write(AnsiEscapes.ResetScrollRegion);
-        System.Console.Write(AnsiEscapes.EraseEntireScreen);
-        System.Console.Write(AnsiEscapes.MoveCursor(1, 1));
         System.Console.WriteLine("Goodbye!");
     }
+
+    /// <summary>
+    /// Runs one or more agent invocations for a single user turn, using the current
+    /// observers. Re-invokes automatically for tool approvals and mode-driven follow-ups
+    /// (e.g., planning clarification loops).
+    /// </summary>
+    private static async Task RunAgentTurnAsync(
+        AIAgent agent,
+        AgentSession session,
+        AgentModeProvider? modeProvider,
+        MessageInjectingChatClient? messageInjector,
+        HarnessConsoleOptions options,
+        HarnessUXContainer ux,
+        string userInput)
+    {
+        IList<ChatMessage>? nextMessages = [new ChatMessage(ChatRole.User, userInput)];
+        IReadOnlyList<ChatMessage> lastPendingMessages = messageInjector?.GetPendingMessages(session) ?? [];
+
+        while (nextMessages is not null)
+        {
+            var observers = CreateObservers(options, modeProvider, session);
+
+            var runOptions = new AgentRunOptions();
+            foreach (var observer in observers)
+            {
+                observer.ConfigureRunOptions(runOptions);
+            }
+
+            ux.CurrentMode = modeProvider?.GetMode(session);
+            ux.BeginStreaming();
+            ux.BeginStreamingOutput();
+
+            try
+            {
+                await foreach (var update in agent.RunStreamingAsync(nextMessages, session, runOptions))
+                {
+                    // Update mode color if the mode changed during streaming.
+                    if (modeProvider is not null)
+                    {
+                        string currentMode = modeProvider.GetMode(session);
+                        if (currentMode != ux.CurrentMode)
+                        {
+                            ux.CurrentMode = currentMode;
+                        }
+                    }
+
+                    foreach (var content in update.Contents)
+                    {
+                        foreach (var observer in observers)
+                        {
+                            await observer.OnContentAsync(ux, content);
+                        }
+                    }
+
+                    if (!string.IsNullOrEmpty(update.Text))
+                    {
+                        foreach (var observer in observers)
+                        {
+                            await observer.OnTextAsync(ux, update.Text);
+                        }
+                    }
+
+                    SyncQueuedMessageDisplay(messageInjector, session, ux, ref lastPendingMessages);
+                }
+            }
+            catch (Exception ex)
+            {
+                await ux.WriteInfoLineAsync($"❌ Stream error: {ex.GetType().Name}:\n{ex}", ConsoleColor.Red);
+            }
+
+            // Final sync after streaming — messages may have been consumed during the last iteration.
+            SyncQueuedMessageDisplay(messageInjector, session, ux, ref lastPendingMessages);
+
+            // Stop spinner before observer completions (which may prompt for input).
+            ux.StopSpinner();
+
+            // Close the streaming output to provide visual separation from observer output.
+            await ux.EndStreamingOutputAsync();
+
+            var combinedMessages = new List<ChatMessage>();
+            bool hasObserverMessages = false;
+            foreach (var observer in observers)
+            {
+                var messages = await observer.OnStreamCompleteAsync(ux, agent, session, options);
+                if (messages is { Count: > 0 })
+                {
+                    combinedMessages.AddRange(messages);
+                    hasObserverMessages = true;
+                }
+            }
+
+            await ux.WriteNoTextWarningAsync(hasFollowUpMessages: hasObserverMessages);
+
+            ux.EndStreaming();
+
+            nextMessages = combinedMessages.Count > 0 ? combinedMessages : null;
+        }
+    }
+
+    /// <summary>
+    /// Synchronizes the queued items display with the message injector's pending messages.
+    /// Messages that have been consumed (drained by the service) are echoed to the output
+    /// area as regular user-input entries.
+    /// </summary>
+    private static void SyncQueuedMessageDisplay(
+        MessageInjectingChatClient? messageInjector,
+        AgentSession session,
+        HarnessUXContainer ux,
+        ref IReadOnlyList<ChatMessage> lastPendingMessages)
+    {
+        if (messageInjector is null)
+        {
+            return;
+        }
+
+        var pending = messageInjector.GetPendingMessages(session);
+
+        // If previously pending messages exceed current pending count, some were consumed.
+        int consumedCount = lastPendingMessages.Count - pending.Count;
+        for (int i = 0; i < consumedCount && i < lastPendingMessages.Count; i++)
+        {
+            string text = lastPendingMessages[i].Text ?? string.Empty;
+            ux.WriteUserInputEcho(text);
+        }
+
+        lastPendingMessages = pending;
+        ux.ShowQueuedMessages(pending);
+    }
+
+    private static List<ConsoleObserver> CreateObservers(HarnessConsoleOptions options, AgentModeProvider? modeProvider, AgentSession session)
+    {
+        var observers = new List<ConsoleObserver>
+        {
+            new ToolCallDisplayObserver(),
+            new ToolApprovalObserver(),
+            new ErrorDisplayObserver(),
+            new ReasoningDisplayObserver(),
+            new UsageDisplayObserver(options.MaxContextWindowTokens, options.MaxOutputTokens),
+        };
+
+        if (options.EnablePlanningUx
+            && modeProvider is not null
+            && string.Equals(modeProvider.GetMode(session), options.PlanningModeName, StringComparison.OrdinalIgnoreCase))
+        {
+            observers.Add(new PlanningOutputObserver(modeProvider));
+        }
+        else
+        {
+            observers.Add(new TextOutputObserver());
+        }
+
+        return observers;
+    }
 }

dotnet/samples/02-agents/Harness/Harness_Shared_Console/HarnessConsoleOptions.cs

@@ -1,11 +1,5 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using System.Collections.ObjectModel;
-using Harness.Shared.Console.Commands;
-using Harness.Shared.Console.Observers;
-using Harness.Shared.Console.ToolFormatters;
-using Microsoft.Agents.AI;
-
 namespace Harness.Shared.Console;
 
 /// <summary>
@@ -14,120 +8,45 @@ namespace Harness.Shared.Console;
 public class HarnessConsoleOptions
 {
     /// <summary>
-    /// Gets or sets the list of console observers that participate in the agent response
-    /// streaming lifecycle. Use the factory methods on this class to create common observer sets.
-    /// When <see langword="null"/> (the default), a default set of observers is used.
-    /// Set to an empty list to disable all observers.
+    /// Gets or sets the optional maximum context window size in tokens.
+    /// When set, token usage is displayed as a percentage of the budget.
     /// </summary>
-    public IReadOnlyList<ConsoleObserver>? Observers { get; set; }
+    public int? MaxContextWindowTokens { get; set; }
 
     /// <summary>
-    /// Gets or sets the list of command handlers to check before sending user input to the agent.
-    /// Use <see cref="BuildDefaultCommandHandlers"/> to create the default set.
-    /// When <see langword="null"/> (the default), a default set of handlers is used.
-    /// Set to an empty list to disable all command handlers.
+    /// Gets or sets the optional maximum output tokens.
+    /// Used with <see cref="MaxContextWindowTokens"/> to show input/output budget breakdown.
     /// </summary>
-    public IReadOnlyList<CommandHandler>? CommandHandlers { get; set; }
+    public int? MaxOutputTokens { get; set; }
 
     /// <summary>
-    /// The default mode-to-color mapping used when no custom <see cref="ModeColors"/> are provided.
+    /// Gets or sets a value indicating whether the planning UX is enabled.
+    /// When <see langword="true"/> and the agent is in the mode specified by <see cref="PlanningModeName"/>,
+    /// the console uses structured output to present clarification questions and approval requests
+    /// instead of streaming free-form text.
     /// </summary>
-    public static readonly IReadOnlyDictionary<string, ConsoleColor> DefaultModeColors = new ReadOnlyDictionary<string, ConsoleColor>(
-        new Dictionary<string, ConsoleColor>(StringComparer.OrdinalIgnoreCase)
-        {
-            ["plan"] = ConsoleColor.Cyan,
-            ["execute"] = ConsoleColor.Green,
-        });
+    /// <value>Defaults to <see langword="false"/>.</value>
+    public bool EnablePlanningUx { get; set; }
+
+    /// <summary>
+    /// Gets or sets the name of the agent mode that activates the planning UX.
+    /// Must be set when <see cref="EnablePlanningUx"/> is <see langword="true"/>.
+    /// </summary>
+    public string? PlanningModeName { get; set; }
+
+    /// <summary>
+    /// Gets or sets the name of the agent mode to switch to when the user approves a plan.
+    /// Must be set when <see cref="EnablePlanningUx"/> is <see langword="true"/>.
+    /// </summary>
+    public string? ExecutionModeName { get; set; }
 
     /// <summary>
     /// Gets or sets a mapping of agent mode names to console colors.
     /// When a mode is not found in this dictionary, the default color (<see cref="ConsoleColor.Gray"/>) is used.
     /// </summary>
-    public Dictionary<string, ConsoleColor> ModeColors { get; set; } = new(DefaultModeColors, StringComparer.OrdinalIgnoreCase);
-
-    /// <summary>
-    /// Creates the default set of observers without planning support.
-    /// Includes tool call display, tool approval, error display, reasoning display,
-    /// usage display, and text output.
-    /// </summary>
-    /// <param name="maxContextWindowTokens">Optional maximum context window size in tokens for usage display.</param>
-    /// <param name="maxOutputTokens">Optional maximum output tokens for usage display.</param>
-    /// <param name="toolFormatters">Optional tool call formatters. When <see langword="null"/>,
-    /// each observer uses the default formatters from <see cref="ToolCallFormatter.BuildDefaultToolFormatters"/>.</param>
-    /// <returns>A list of observers for a standard (non-planning) console session.</returns>
-    public static List<ConsoleObserver> BuildDefaultObservers(
-        int? maxContextWindowTokens = null,
-        int? maxOutputTokens = null,
-        IReadOnlyList<ToolCallFormatter>? toolFormatters = null)
+    public Dictionary<string, ConsoleColor> ModeColors { get; set; } = new(StringComparer.OrdinalIgnoreCase)
     {
-        return
-        [
-            new ToolCallDisplayObserver(toolFormatters),
-            new ToolApprovalObserver(toolFormatters),
-            new ErrorDisplayObserver(),
-            new ReasoningDisplayObserver(),
-            new UsageDisplayObserver(maxContextWindowTokens, maxOutputTokens),
-            new TextOutputObserver(),
-        ];
-    }
-
-    /// <summary>
-    /// Creates the default set of observers with planning support.
-    /// Includes a <see cref="PlanningOutputObserver"/> instead of <see cref="TextOutputObserver"/>.
-    /// </summary>
-    /// <param name="agent">The agent, used to resolve <see cref="AgentModeProvider"/>.</param>
-    /// <param name="planModeName">The mode name that represents the planning mode.</param>
-    /// <param name="executionModeName">The mode name to switch to when the user approves a plan.</param>
-    /// <param name="modeColors">Optional mode-to-color mapping for display.
-    /// Defaults to <see cref="DefaultModeColors"/> when <see langword="null"/>.</param>
-    /// <param name="maxContextWindowTokens">Optional maximum context window size in tokens for usage display.</param>
-    /// <param name="maxOutputTokens">Optional maximum output tokens for usage display.</param>
-    /// <param name="toolFormatters">Optional tool call formatters. When <see langword="null"/>,
-    /// each observer uses the default formatters from <see cref="ToolCallFormatter.BuildDefaultToolFormatters"/>.</param>
-    /// <returns>A list of observers for a planning-enabled console session.</returns>
-    public static List<ConsoleObserver> BuildObserversWithPlanning(
-        AIAgent agent,
-        string planModeName,
-        string executionModeName,
-        IReadOnlyDictionary<string, ConsoleColor>? modeColors = null,
-        int? maxContextWindowTokens = null,
-        int? maxOutputTokens = null,
-        IReadOnlyList<ToolCallFormatter>? toolFormatters = null)
-    {
-        var modeProvider = agent.GetService<AgentModeProvider>()
-            ?? throw new InvalidOperationException("Planning requires an AgentModeProvider service on the agent.");
-
-        return
-        [
-            new ToolCallDisplayObserver(toolFormatters),
-            new ToolApprovalObserver(toolFormatters),
-            new ErrorDisplayObserver(),
-            new ReasoningDisplayObserver(),
-            new UsageDisplayObserver(maxContextWindowTokens, maxOutputTokens),
-            new PlanningOutputObserver(modeProvider, planModeName, executionModeName, modeColors ?? DefaultModeColors),
-        ];
-    }
-
-    /// <summary>
-    /// Creates the default set of command handlers.
-    /// Includes exit, todo, and mode command handlers.
-    /// </summary>
-    /// <param name="agent">The agent, used to resolve <see cref="TodoProvider"/> and <see cref="AgentModeProvider"/>.</param>
-    /// <param name="modeColors">Optional mode-to-color mapping for the mode command display.
-    /// Defaults to <see cref="DefaultModeColors"/> when <see langword="null"/>.</param>
-    /// <returns>A list of command handlers for a standard console session.</returns>
-    public static List<CommandHandler> BuildDefaultCommandHandlers(
-        AIAgent agent,
-        IReadOnlyDictionary<string, ConsoleColor>? modeColors = null)
-    {
-        var todoProvider = agent.GetService<TodoProvider>();
-        var modeProvider = agent.GetService<AgentModeProvider>();
-
-        return
-        [
-            new ExitCommandHandler(),
-            new TodoCommandHandler(todoProvider),
-            new ModeCommandHandler(modeProvider, modeColors ?? DefaultModeColors),
-        ];
-    }
+        ["plan"] = ConsoleColor.Cyan,
+        ["execute"] = ConsoleColor.Green,
+    };
 }

dotnet/samples/02-agents/Harness/Harness_Shared_Console/HarnessConsoleUXStateDriver.cs

@@ -1,408 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using Harness.ConsoleReactiveComponents;
-using Microsoft.Extensions.AI;
-
-namespace Harness.Shared.Console;
-
-/// <summary>
-/// Default <see cref="IUXStateDriver"/> implementation. Owned by
-/// <see cref="HarnessAppComponent"/>; mutates the component's state via a
-/// <c>SetState</c>-style callback. Each public operation updates state and lets
-/// the component's render-skip optimization handle the actual draw.
-/// </summary>
-internal sealed class HarnessConsoleUXStateDriver : IUXStateDriver
-{
-    private readonly Func<HarnessAppComponentState> _getState;
-    private readonly Action<HarnessAppComponentState> _setState;
-    private readonly Action _requestShutdown;
-    private readonly IReadOnlyDictionary<string, ConsoleColor>? _modeColors;
-    private readonly List<string> _outputItems = [];
-    private readonly object _stateLock = new();
-
-    private OutputEntryType? _lastEntryType;
-    private bool _hasReceivedAnyText;
-    private OutputEntry? _currentStreamingEntry;
-    private int _currentStreamingEntryIndex = -1;
-    private string? _currentMode;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="HarnessConsoleUXStateDriver"/> class.
-    /// </summary>
-    /// <param name="getState">Returns the component's current state.</param>
-    /// <param name="setState">Replaces the component's state and triggers a re-render.</param>
-    /// <param name="requestShutdown">Callback invoked when a command handler requests application shutdown.</param>
-    /// <param name="modeColors">Optional mapping of mode names to console colors.</param>
-    public HarnessConsoleUXStateDriver(
-        Func<HarnessAppComponentState> getState,
-        Action<HarnessAppComponentState> setState,
-        Action requestShutdown,
-        IReadOnlyDictionary<string, ConsoleColor>? modeColors = null)
-    {
-        this._getState = getState;
-        this._setState = setState;
-        this._requestShutdown = requestShutdown;
-        this._modeColors = modeColors;
-        this._currentMode = getState().ModeText;
-    }
-
-    /// <inheritdoc/>
-    public string? CurrentMode
-    {
-        get => this._currentMode;
-        set
-        {
-            this.UpdateState(s =>
-            {
-                this._currentMode = value;
-                return s with
-                {
-                    ModeColor = ModeColors.Get(value, this._modeColors),
-                    ModeText = value,
-                };
-            });
-        }
-    }
-
-    /// <inheritdoc/>
-    public void BeginStreaming() =>
-        this.UpdateState(s => s with
-        {
-            Mode = BottomPanelMode.Streaming,
-            ShowSpinner = true,
-        });
-
-    /// <inheritdoc/>
-    public void StopSpinner() =>
-        this.UpdateState(s => s with { ShowSpinner = false });
-
-    /// <inheritdoc/>
-    public void EndStreaming() =>
-        this.UpdateState(s => s with
-        {
-            Mode = BottomPanelMode.TextInput,
-            ShowSpinner = false,
-        });
-
-    /// <inheritdoc/>
-    public void BeginStreamingOutput()
-    {
-        lock (this._stateLock)
-        {
-            this._hasReceivedAnyText = false;
-            this._currentStreamingEntry = null;
-            this._currentStreamingEntryIndex = -1;
-        }
-    }
-
-    /// <inheritdoc/>
-    public void SetUsageText(string usageText) =>
-        this.UpdateState(s => s with { UsageText = usageText });
-
-    /// <inheritdoc/>
-    public void SetQueuedMessages(IReadOnlyList<ChatMessage> pending)
-    {
-        var newQueued = new List<string>(pending.Count);
-        foreach (var msg in pending)
-        {
-            string text = msg.Text ?? string.Empty;
-            newQueued.Add(RenderEntry($"  💬 {text}\n", ConsoleColor.DarkGray));
-        }
-
-        this.UpdateState(s => s with { QueuedItems = newQueued });
-    }
-
-    /// <inheritdoc/>
-    public void QueueFollowUpQuestions(IReadOnlyList<FollowUpQuestion> questions)
-    {
-        if (questions.Count == 0)
-        {
-            return;
-        }
-
-        this.UpdateState(s =>
-        {
-            bool wasEmpty = s.PendingQuestions.Count == 0;
-
-            var combined = new List<FollowUpQuestion>(s.PendingQuestions.Count + questions.Count);
-            combined.AddRange(s.PendingQuestions);
-            combined.AddRange(questions);
-
-            HarnessAppComponentState next = s with { PendingQuestions = combined };
-
-            if (wasEmpty)
-            {
-                next = this.ConfigureForHeadQuestion(next, combined[0]);
-            }
-
-            return next;
-        });
-    }
-
-    /// <inheritdoc/>
-    public void AddFollowUpResponse(ChatMessage response)
-    {
-        this.UpdateState(s =>
-        {
-            var combined = new List<ChatMessage>(s.AccumulatedFollowUpResponses.Count + 1);
-            combined.AddRange(s.AccumulatedFollowUpResponses);
-            combined.Add(response);
-            return s with { AccumulatedFollowUpResponses = combined };
-        });
-    }
-
-    /// <inheritdoc/>
-    public void AdvanceFollowUpQuestion()
-    {
-        this.UpdateState(s =>
-        {
-            if (s.PendingQuestions.Count == 0)
-            {
-                return s;
-            }
-
-            var remaining = s.PendingQuestions.Skip(1).ToList();
-            HarnessAppComponentState next = s with { PendingQuestions = remaining };
-
-            if (remaining.Count > 0)
-            {
-                return this.ConfigureForHeadQuestion(next, remaining[0]);
-            }
-
-            return next with
-            {
-                Mode = BottomPanelMode.TextInput,
-                ListSelectionOptions = [],
-                ListSelectionTitle = null,
-                ListSelectionCustomTextPlaceholder = null,
-                ListSelectionIndex = 0,
-                ListSelectionCustomInputText = "",
-            };
-        });
-    }
-
-    /// <inheritdoc/>
-    public IReadOnlyList<ChatMessage> TakeFollowUpResponses()
-    {
-        return this.UpdateState(s =>
-        {
-            IReadOnlyList<ChatMessage> responses = s.AccumulatedFollowUpResponses;
-            if (responses.Count == 0)
-            {
-                return (s, responses);
-            }
-
-            return (s with { AccumulatedFollowUpResponses = [] }, responses);
-        });
-    }
-
-    /// <summary>
-    /// Configures the bottom-panel display fields on the supplied state for the
-    /// given head question. For text questions, also writes the prompt as an
-    /// info line above the input row as a side effect.
-    /// </summary>
-    private HarnessAppComponentState ConfigureForHeadQuestion(HarnessAppComponentState state, FollowUpQuestion question)
-    {
-        if (question is ChoiceFollowUpQuestion choice)
-        {
-            return state with
-            {
-                Mode = BottomPanelMode.ListSelection,
-                ListSelectionOptions = choice.Choices.ToList(),
-                ListSelectionTitle = choice.Prompt,
-                ListSelectionCustomTextPlaceholder = choice.AllowCustomText ? "✏️  Type a custom response..." : null,
-                ListSelectionIndex = 0,
-                ListSelectionCustomInputText = "",
-            };
-        }
-
-        // Text question — prompt is rendered as an info line above the input row.
-        // We append entries and capture the scroll snapshot inline so the caller's
-        // single _setState picks up both the new output and the UI mode change.
-        ConsoleColor ruleColor = ModeColors.Get(this._currentMode, this._modeColors);
-        List<string> scrollSnapshot = this.AppendOutputEntriesAndSnapshot(
-            new OutputEntry(OutputEntryType.InfoLine, "\n", ruleColor),
-            new OutputEntry(OutputEntryType.InfoLine, $"  {question.Prompt}", ruleColor));
-
-        return state with
-        {
-            Mode = BottomPanelMode.TextInput,
-            ListSelectionOptions = [],
-            ListSelectionTitle = null,
-            ListSelectionCustomTextPlaceholder = null,
-            ListSelectionIndex = 0,
-            ListSelectionCustomInputText = "",
-            ScrollAreaContentItems = scrollSnapshot,
-        };
-    }
-
-    /// <inheritdoc/>
-    public void WriteUserInputEcho(string text)
-    {
-        this.UpdateState(s =>
-        {
-            List<string> snapshot = this.AppendOutputEntriesAndSnapshot(new OutputEntry(
-                OutputEntryType.UserInput,
-                $"\nYou: {text}\n\n",
-                ConsoleColor.Green));
-            return s with { ScrollAreaContentItems = snapshot };
-        });
-    }
-
-    /// <inheritdoc/>
-    public Task WriteInfoAsync(string text, ConsoleColor? color = null) =>
-        this.WriteInfoCoreAsync(text, color, newLine: false);
-
-    /// <inheritdoc/>
-    public Task WriteInfoLineAsync(string text, ConsoleColor? color = null) =>
-        this.WriteInfoCoreAsync(text, color, newLine: true);
-
-    private Task WriteInfoCoreAsync(string text, ConsoleColor? color, bool newLine)
-    {
-        this.UpdateState(s =>
-        {
-            // Add a blank line separator when transitioning from streaming text or user input.
-            string prefix = this._lastEntryType is OutputEntryType.StreamingText or OutputEntryType.StreamFooter
-                ? "\n  "
-                : "  ";
-
-            string fullText = newLine ? prefix + text + "\n\n" : prefix + text;
-            List<string> snapshot = this.AppendOutputEntriesAndSnapshot(new OutputEntry(
-                OutputEntryType.InfoLine,
-                fullText,
-                color ?? ModeColors.Get(this._currentMode, this._modeColors)));
-            return s with { ScrollAreaContentItems = snapshot };
-        });
-        return Task.CompletedTask;
-    }
-
-    /// <inheritdoc/>
-    public Task WriteTextAsync(string text, ConsoleColor? color = null)
-    {
-        this.UpdateState(s =>
-        {
-            this._lastEntryType = OutputEntryType.StreamingText;
-            this._hasReceivedAnyText = true;
-
-            ConsoleColor effectiveColor = color ?? ModeColors.Get(this._currentMode, this._modeColors);
-
-            if (this._currentStreamingEntry is not null
-                && this._currentStreamingEntryIndex == this._outputItems.Count - 1)
-            {
-                // The streaming entry is still the last item — safe to replace in place.
-                this._currentStreamingEntry = this._currentStreamingEntry with
-                {
-                    Text = this._currentStreamingEntry.Text + text,
-                };
-                this._outputItems[^1] = RenderEntry(this._currentStreamingEntry.Text, this._currentStreamingEntry.Color);
-            }
-            else
-            {
-                // Either the first text delta or other entries (tool calls, info lines)
-                // were appended after the previous streaming entry — start a fresh one.
-                const string Prefix = "\n";
-                this._currentStreamingEntry = new OutputEntry(OutputEntryType.StreamingText, Prefix + text, effectiveColor);
-                this._outputItems.Add(RenderEntry(this._currentStreamingEntry.Text, this._currentStreamingEntry.Color));
-                this._currentStreamingEntryIndex = this._outputItems.Count - 1;
-            }
-
-            return s with { ScrollAreaContentItems = new List<string>(this._outputItems) };
-        });
-
-        return Task.CompletedTask;
-    }
-
-    /// <inheritdoc/>
-    public Task EndStreamingOutputAsync()
-    {
-        this.UpdateState(s =>
-        {
-            if (this._hasReceivedAnyText)
-            {
-                this._outputItems.Add(RenderEntry("\n", null));
-                this._currentStreamingEntry = null;
-                this._lastEntryType = OutputEntryType.StreamFooter;
-                return s with { ScrollAreaContentItems = new List<string>(this._outputItems) };
-            }
-
-            return s;
-        });
-
-        return Task.CompletedTask;
-    }
-
-    /// <inheritdoc/>
-    public Task WriteNoTextWarningAsync(bool hasFollowUpActions)
-    {
-        if (!this._hasReceivedAnyText && !hasFollowUpActions)
-        {
-            this.UpdateState(s =>
-            {
-                List<string> snapshot = this.AppendOutputEntriesAndSnapshot(new OutputEntry(
-                    OutputEntryType.StreamFooter,
-                    "  (no text response from agent)\n",
-                    ConsoleColor.DarkYellow));
-                return s with { ScrollAreaContentItems = snapshot };
-            });
-        }
-
-        return Task.CompletedTask;
-    }
-
-    /// <summary>
-    /// Wraps the supplied text with ANSI foreground color escape sequences (or returns
-    /// the text unchanged when no color is specified). Output is appended to
-    /// <see cref="_outputItems"/> and consumed verbatim by <see cref="TextScrollPanel"/>
-    /// and <see cref="TextPanel"/>.
-    /// </summary>
-    private static string RenderEntry(string text, ConsoleColor? color) =>
-        color.HasValue
-            ? $"{AnsiEscapes.SetForegroundColor(color.Value)}{text}{AnsiEscapes.ResetAttributes}"
-            : text;
-
-    private void UpdateState(Func<HarnessAppComponentState, HarnessAppComponentState> update)
-    {
-        lock (this._stateLock)
-        {
-            this._setState(update(this._getState()));
-        }
-    }
-
-    private T UpdateState<T>(Func<HarnessAppComponentState, (HarnessAppComponentState State, T Result)> update)
-    {
-        lock (this._stateLock)
-        {
-            var (newState, result) = update(this._getState());
-            this._setState(newState);
-            return result;
-        }
-    }
-
-    /// <summary>
-    /// Appends one or more output entries to the output list, updates
-    /// <see cref="_lastEntryType"/> to the last entry's type, and returns a
-    /// snapshot of <see cref="_outputItems"/>. Must be called inside a locked
-    /// context (e.g. within an <see cref="UpdateState"/> callback).
-    /// </summary>
-    private List<string> AppendOutputEntriesAndSnapshot(params OutputEntry[] entries)
-    {
-        this.AppendOutputEntriesCore(entries);
-        return new List<string>(this._outputItems);
-    }
-
-    private void AppendOutputEntriesCore(OutputEntry[] entries)
-    {
-        foreach (OutputEntry entry in entries)
-        {
-            this._outputItems.Add(RenderEntry(entry.Text, entry.Color));
-        }
-
-        if (entries.Length > 0)
-        {
-            this._lastEntryType = entries[^1].Type;
-        }
-    }
-
-    /// <inheritdoc/>
-    public void RequestShutdown() => this._requestShutdown();
-}

dotnet/samples/02-agents/Harness/Harness_Shared_Console/HarnessUXContainer.cs

@@ -0,0 +1,478 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Harness.ConsoleReactiveComponents;
+using Microsoft.Extensions.AI;
+
+namespace Harness.Shared.Console;
+
+/// <summary>
+/// Event arguments raised when the user submits text while the bottom panel is in
+/// streaming mode (i.e. an agent turn is in progress).
+/// </summary>
+public sealed class StreamingInputReceivedEventArgs : EventArgs
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="StreamingInputReceivedEventArgs"/> class.
+    /// </summary>
+    /// <param name="text">The submitted text.</param>
+    public StreamingInputReceivedEventArgs(string text)
+    {
+        this.Text = text;
+    }
+
+    /// <summary>
+    /// Gets the submitted text.
+    /// </summary>
+    public string Text { get; }
+}
+
+/// <summary>
+/// Façade over the harness UI: owns the <see cref="HarnessAppComponent"/>, manages
+/// its props, dispatches input submissions, and provides the high-level read/write
+/// operations used by observers, command handlers, and the harness loop.
+/// </summary>
+/// <remarks>
+/// All callers interact with the UI exclusively through this class. The underlying
+/// <see cref="HarnessAppComponent"/> and its props are an implementation detail and
+/// must not be exposed.
+/// </remarks>
+public sealed class HarnessUXContainer : IDisposable
+{
+    /// <summary>
+    /// The prompt displayed in the bottom-panel input area.
+    /// </summary>
+    private const string UserPrompt = "> ";
+
+    private readonly IReadOnlyDictionary<string, ConsoleColor>? _modeColors;
+    private readonly List<object> _outputItems = [];
+    private readonly HarnessAppComponent _appComponent;
+    private readonly object _outputLock = new();
+
+    private TaskCompletionSource<string>? _pendingInputTcs;
+    private OutputEntryType? _lastEntryType;
+    private bool _hasReceivedAnyText;
+    private OutputEntry? _currentStreamingEntry;
+    private string? _currentMode;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="HarnessUXContainer"/> class.
+    /// </summary>
+    /// <param name="placeholder">Placeholder text shown when the input is empty.</param>
+    /// <param name="initialMode">The current agent mode, used to colour the rule and prompt.</param>
+    /// <param name="inputEnabled">Whether the bottom-panel input accepts keystrokes during streaming.</param>
+    /// <param name="modeColors">Optional mapping of mode names to console colors.</param>
+    public HarnessUXContainer(
+        string placeholder,
+        string? initialMode,
+        bool inputEnabled,
+        IReadOnlyDictionary<string, ConsoleColor>? modeColors = null)
+    {
+        this._modeColors = modeColors;
+        this._currentMode = initialMode;
+
+        this._appComponent = new HarnessAppComponent(RenderOutputEntry)
+        {
+            Props = new HarnessAppComponentProps
+            {
+                ScrollItems = this._outputItems,
+                Mode = BottomPanelMode.TextInput,
+                Prompt = UserPrompt,
+                Placeholder = placeholder,
+                ModeColor = ModeColors.Get(initialMode, modeColors),
+                ModeText = initialMode,
+                InputEnabled = inputEnabled,
+            },
+        };
+
+        this._appComponent.InputSubmitted += this.OnInputSubmitted;
+    }
+
+    /// <summary>
+    /// Raised when the user submits text while the bottom panel is in streaming mode.
+    /// Subscribers typically enqueue the text into a message-injecting chat client.
+    /// </summary>
+    public event EventHandler<StreamingInputReceivedEventArgs>? StreamingInputReceived;
+
+    /// <summary>
+    /// Gets or sets the current agent mode (e.g. "plan", "execute"). Updating this
+    /// also refreshes the rule colour and bottom-panel prompt to match the new mode.
+    /// </summary>
+    public string? CurrentMode
+    {
+        get => this._currentMode;
+        set
+        {
+            this._currentMode = value;
+            this._appComponent.Props = this._appComponent.Props! with
+            {
+                ModeColor = ModeColors.Get(value, this._modeColors),
+                ModeText = value,
+            };
+            this._appComponent.Render();
+        }
+    }
+
+    /// <summary>
+    /// Performs the initial screen clear, sets the help text in the mode-and-help bar,
+    /// and adds the title to the output area.
+    /// </summary>
+    /// <param name="title">The title displayed in the console header.</param>
+    /// <param name="commandHelpTexts">The command help strings displayed in the mode-and-help bar.</param>
+    /// <param name="messageInjectionActive">Whether streaming-time message injection is enabled.</param>
+    public void Initialize(string title, IEnumerable<string> commandHelpTexts, bool messageInjectionActive)
+    {
+        // Set the help text on the mode-and-help bar (persists below the rule).
+        this._appComponent.Props = this._appComponent.Props! with
+        {
+            HelpText = string.Join(", ", commandHelpTexts),
+            ModeText = this._currentMode,
+        };
+
+        System.Console.Write(AnsiEscapes.EraseEntireScreen);
+        System.Console.Write(AnsiEscapes.EraseScrollbackBuffer);
+        this._appComponent.Render();
+
+        this.AppendOutputEntries(
+            new OutputEntry(OutputEntryType.InfoLine, $"=== {title} ===\n", ConsoleColor.White),
+            new OutputEntry(OutputEntryType.InfoLine, "\n"));
+    }
+
+    /// <summary>
+    /// Restores the cursor and exits the alternate screen, ending the interactive UI.
+    /// </summary>
+    public void Deactivate() => this._appComponent.Deactivate();
+
+    /// <summary>
+    /// Switches the bottom panel to streaming mode and starts the spinner.
+    /// </summary>
+    public void BeginStreaming()
+    {
+        this._appComponent.Props = this._appComponent.Props! with
+        {
+            Mode = BottomPanelMode.Streaming,
+            ShowSpinner = true,
+        };
+        this._appComponent.Render();
+    }
+
+    /// <summary>
+    /// Stops the spinner without leaving streaming mode. Use between the end of the
+    /// stream and any observer-driven prompts (e.g. tool approvals).
+    /// </summary>
+    public void StopSpinner()
+    {
+        this._appComponent.Props = this._appComponent.Props! with { ShowSpinner = false };
+        this._appComponent.Render();
+    }
+
+    /// <summary>
+    /// Switches the bottom panel back to text-input mode and stops the spinner.
+    /// </summary>
+    public void EndStreaming()
+    {
+        this._appComponent.Props = this._appComponent.Props! with
+        {
+            Mode = BottomPanelMode.TextInput,
+            ShowSpinner = false,
+        };
+        this._appComponent.Render();
+    }
+
+    /// <summary>
+    /// Resets per-turn streaming bookkeeping in preparation for a new agent turn.
+    /// </summary>
+    public void BeginStreamingOutput()
+    {
+        this._hasReceivedAnyText = false;
+        this._currentStreamingEntry = null;
+    }
+
+    /// <summary>
+    /// Sets the formatted usage text shown on the agent status bar.
+    /// </summary>
+    public void SetUsageText(string usageText)
+    {
+        this._appComponent.Props = this._appComponent.Props! with { UsageText = usageText };
+        this._appComponent.Render();
+    }
+
+    /// <summary>
+    /// Clears the usage text from the agent status bar.
+    /// </summary>
+    public void ClearUsageText()
+    {
+        this._appComponent.Props = this._appComponent.Props! with { UsageText = null };
+        this._appComponent.Render();
+    }
+
+    /// <summary>
+    /// Replaces the queued-message display with one entry per pending message.
+    /// </summary>
+    public void ShowQueuedMessages(IReadOnlyList<ChatMessage> pending)
+    {
+        var newQueued = new List<object>(pending.Count);
+        foreach (var msg in pending)
+        {
+            string text = msg.Text ?? string.Empty;
+            newQueued.Add(new OutputEntry(OutputEntryType.UserInput, $"  💬 {text}\n", ConsoleColor.DarkGray));
+        }
+
+        this._appComponent.Props = this._appComponent.Props! with { QueuedItems = newQueued };
+        this._appComponent.Render();
+    }
+
+    /// <summary>
+    /// Echoes a submitted user input as a regular user-input entry in the output area,
+    /// using the current mode-aware prompt prefix.
+    /// </summary>
+    /// <param name="text">The user-entered text.</param>
+    public void WriteUserInputEcho(string text)
+    {
+        this.AppendOutputEntries(new OutputEntry(
+            OutputEntryType.UserInput,
+            $"\nYou: {text}\n",
+            ConsoleColor.Green));
+    }
+
+    /// <summary>
+    /// Writes informational output as an output entry, without a trailing newline.
+    /// </summary>
+    public Task WriteInfoAsync(string text, ConsoleColor? color = null) =>
+        this.WriteInfoCoreAsync(text, color, newLine: false);
+
+    /// <summary>
+    /// Writes informational output as an output entry, followed by a newline.
+    /// </summary>
+    public Task WriteInfoLineAsync(string text, ConsoleColor? color = null) =>
+        this.WriteInfoCoreAsync(text, color, newLine: true);
+
+    private Task WriteInfoCoreAsync(string text, ConsoleColor? color, bool newLine)
+    {
+        // Add a blank line separator when transitioning from streaming text or user input.
+        string prefix = this._lastEntryType is OutputEntryType.StreamingText or OutputEntryType.StreamFooter
+            ? "\n\n  "
+            : "  ";
+
+        string fullText = newLine ? prefix + text + "\n" : prefix + text;
+        this.AppendOutputEntries(new OutputEntry(
+            OutputEntryType.InfoLine,
+            fullText,
+            color ?? ModeColors.Get(this.CurrentMode, this._modeColors)));
+        return Task.CompletedTask;
+    }
+
+    /// <summary>
+    /// Writes streaming text output from the agent. Successive calls accumulate into a
+    /// single streaming entry that is re-rendered by the text panel.
+    /// </summary>
+    public Task WriteTextAsync(string text, ConsoleColor? color = null)
+    {
+        lock (this._outputLock)
+        {
+            this._lastEntryType = OutputEntryType.StreamingText;
+            this._hasReceivedAnyText = true;
+
+            ConsoleColor effectiveColor = color ?? ModeColors.Get(this.CurrentMode, this._modeColors);
+
+            if (this._currentStreamingEntry is not null)
+            {
+                this._currentStreamingEntry = this._currentStreamingEntry with
+                {
+                    Text = this._currentStreamingEntry.Text + text,
+                };
+                this._outputItems[^1] = this._currentStreamingEntry;
+            }
+            else
+            {
+                const string Prefix = "\n";
+                this._currentStreamingEntry = new OutputEntry(OutputEntryType.StreamingText, Prefix + text, effectiveColor);
+                this._outputItems.Add(this._currentStreamingEntry);
+            }
+
+            this._appComponent.Props = this._appComponent.Props! with
+            {
+                ScrollItems = new List<object>(this._outputItems),
+            };
+        }
+
+        this._appComponent.Render();
+        return Task.CompletedTask;
+    }
+
+    /// <summary>
+    /// Writes a blank-line separator to visually close the streaming output section.
+    /// Call before observer completions so their output is visually separated.
+    /// </summary>
+    public Task EndStreamingOutputAsync()
+    {
+        lock (this._outputLock)
+        {
+            this._outputItems.Add(new OutputEntry(OutputEntryType.StreamFooter, "\n"));
+            this._currentStreamingEntry = null;
+            this._lastEntryType = OutputEntryType.StreamFooter;
+            this._appComponent.Props = this._appComponent.Props! with
+            {
+                ScrollItems = new List<object>(this._outputItems),
+            };
+        }
+
+        this._appComponent.Render();
+        return Task.CompletedTask;
+    }
+
+    /// <summary>
+    /// Shows a "(no text response from agent)" warning if no text was received
+    /// and no observer produced follow-up messages. Call after observer completions.
+    /// </summary>
+    /// <param name="hasFollowUpMessages">Whether any observer produced follow-up messages.</param>
+    public Task WriteNoTextWarningAsync(bool hasFollowUpMessages)
+    {
+        if (!this._hasReceivedAnyText && !hasFollowUpMessages)
+        {
+            this.AppendOutputEntries(new OutputEntry(
+                OutputEntryType.StreamFooter,
+                "  (no text response from agent)\n",
+                ConsoleColor.DarkYellow));
+        }
+
+        return Task.CompletedTask;
+    }
+
+    /// <summary>
+    /// Reads a line of input from the user. If <paramref name="prompt"/> is supplied
+    /// it is rendered as an info line above the input row before reading.
+    /// </summary>
+    public async Task<string?> ReadLineAsync(string? prompt = null, ConsoleColor? promptColor = null)
+    {
+        if (prompt is not null)
+        {
+            ConsoleColor ruleColor = ModeColors.Get(this.CurrentMode, this._modeColors);
+            this.AppendOutputEntries(
+                new OutputEntry(OutputEntryType.InfoLine, "\n", ruleColor),
+                new OutputEntry(OutputEntryType.InfoLine, $"  {prompt}", promptColor ?? ruleColor));
+        }
+
+        this._appComponent.Props = this._appComponent.Props! with { Mode = BottomPanelMode.TextInput };
+        this._appComponent.Render();
+
+        string input = await this.WaitForInputAsync();
+
+        this.AppendOutputEntries(new OutputEntry(
+            OutputEntryType.UserInput,
+            $"\nYou: {input}\n",
+            ConsoleColor.Green));
+
+        return input;
+    }
+
+    /// <summary>
+    /// Presents a selection prompt with the given choices and waits for the user's
+    /// selection. The title is displayed above the list in the bottom panel. After
+    /// selection the bottom panel is restored to text-input mode and both the question
+    /// and selection are echoed in the output area.
+    /// </summary>
+    public async Task<string> ReadSelectionAsync(string title, IList<string> choices)
+    {
+        this._appComponent.Props = this._appComponent.Props! with
+        {
+            Mode = BottomPanelMode.ListSelection,
+            Items = choices.ToList(),
+            ListTitle = title,
+            ListCustomTextPlaceholder = "✏️  Type a custom response...",
+        };
+        this._appComponent.Render();
+
+        string selection = await this.WaitForInputAsync();
+
+        this._appComponent.Props = this._appComponent.Props with { Mode = BottomPanelMode.TextInput };
+
+        this.AppendOutputEntries(
+            new OutputEntry(
+                OutputEntryType.InfoLine,
+                $"\n  {title}\n",
+                ModeColors.Get(this.CurrentMode, this._modeColors)),
+            new OutputEntry(
+                OutputEntryType.UserInput,
+                $"\nYou: {selection}\n",
+                ConsoleColor.Green));
+
+        return selection;
+    }
+
+    /// <summary>
+    /// Awaits the next non-streaming user input submission.
+    /// </summary>
+    public Task<string> WaitForInputAsync()
+    {
+        this._pendingInputTcs = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
+        return this._pendingInputTcs.Task;
+    }
+
+    private void OnInputSubmitted(object? sender, InputSubmittedEventArgs e)
+    {
+        if (e.Mode == BottomPanelMode.Streaming)
+        {
+            this.StreamingInputReceived?.Invoke(this, new StreamingInputReceivedEventArgs(e.Text));
+        }
+        else
+        {
+            var waiter = this._pendingInputTcs;
+            this._pendingInputTcs = null;
+            waiter?.TrySetResult(e.Text);
+        }
+    }
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        this._appComponent.InputSubmitted -= this.OnInputSubmitted;
+        this._appComponent.Deactivate();
+        this._appComponent.Dispose();
+    }
+
+    /// <summary>
+    /// Renders an <see cref="OutputEntry"/> to a string with ANSI color codes.
+    /// Used as the render delegate for the <see cref="HarnessAppComponent"/>.
+    /// </summary>
+    private static string RenderOutputEntry(object item)
+    {
+        if (item is not OutputEntry entry)
+        {
+            return item?.ToString() ?? string.Empty;
+        }
+
+        if (entry.Color.HasValue)
+        {
+            return $"{AnsiEscapes.SetForegroundColor(entry.Color.Value)}{entry.Text}{AnsiEscapes.ResetAttributes}";
+        }
+
+        return entry.Text;
+    }
+
+    /// <summary>
+    /// Appends one or more output entries to the output list under lock,
+    /// updates <see cref="_lastEntryType"/> to the last entry's type, and renders.
+    /// </summary>
+    private void AppendOutputEntries(params OutputEntry[] entries)
+    {
+        lock (this._outputLock)
+        {
+            foreach (OutputEntry entry in entries)
+            {
+                this._outputItems.Add(entry);
+            }
+
+            if (entries.Length > 0)
+            {
+                this._lastEntryType = entries[^1].Type;
+            }
+
+            this._appComponent.Props = this._appComponent.Props! with
+            {
+                ScrollItems = new List<object>(this._outputItems),
+            };
+        }
+
+        this._appComponent.Render();
+    }
+}

dotnet/samples/02-agents/Harness/Harness_Shared_Console/IUXStateDriver.cs

@@ -1,120 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using Microsoft.Extensions.AI;
-
-namespace Harness.Shared.Console;
-
-/// <summary>
-/// Abstraction over the harness UI state. All callers (observers, command handlers,
-/// the agent runner) interact with the UI exclusively through this interface, which
-/// internally translates each operation into a <c>SetState</c> call on the underlying
-/// reactive component.
-/// </summary>
-/// <remarks>
-/// This interface is intentionally narrow: it does not expose blocking input methods.
-/// The agent runner orchestrates input flow via <see cref="FollowUpQuestion"/>
-/// objects returned from observers.
-/// </remarks>
-public interface IUXStateDriver
-{
-    /// <summary>
-    /// Gets or sets the current agent mode (e.g. "plan", "execute"). Setting also
-    /// refreshes the rule colour and bottom-panel prompt to match the new mode.
-    /// </summary>
-    string? CurrentMode { get; set; }
-
-    /// <summary>
-    /// Echoes a submitted user input as a regular user-input entry in the output area.
-    /// </summary>
-    void WriteUserInputEcho(string text);
-
-    /// <summary>
-    /// Writes informational output as an output entry, without a trailing newline.
-    /// </summary>
-    Task WriteInfoAsync(string text, ConsoleColor? color = null);
-
-    /// <summary>
-    /// Writes informational output as an output entry, followed by a newline.
-    /// </summary>
-    Task WriteInfoLineAsync(string text, ConsoleColor? color = null);
-
-    /// <summary>
-    /// Writes streaming text output from the agent. Successive calls accumulate into a
-    /// single streaming entry that is re-rendered by the text panel.
-    /// </summary>
-    Task WriteTextAsync(string text, ConsoleColor? color = null);
-
-    /// <summary>
-    /// Writes a blank-line separator to visually close the streaming output section.
-    /// </summary>
-    Task EndStreamingOutputAsync();
-
-    /// <summary>
-    /// Shows a "(no text response from agent)" warning if no text was received
-    /// and no observer produced follow-up actions.
-    /// </summary>
-    Task WriteNoTextWarningAsync(bool hasFollowUpActions);
-
-    /// <summary>
-    /// Switches the bottom panel to streaming mode and starts the spinner.
-    /// </summary>
-    void BeginStreaming();
-
-    /// <summary>
-    /// Stops the spinner without leaving streaming mode.
-    /// </summary>
-    void StopSpinner();
-
-    /// <summary>
-    /// Switches the bottom panel back to text-input mode and stops the spinner.
-    /// </summary>
-    void EndStreaming();
-
-    /// <summary>
-    /// Resets per-turn streaming bookkeeping in preparation for a new agent turn.
-    /// </summary>
-    void BeginStreamingOutput();
-
-    /// <summary>
-    /// Sets the formatted usage text shown on the agent status bar.
-    /// </summary>
-    void SetUsageText(string usageText);
-
-    /// <summary>
-    /// Replaces the queued-message display with one entry per pending message.
-    /// </summary>
-    void SetQueuedMessages(IReadOnlyList<ChatMessage> pending);
-
-    /// <summary>
-    /// Appends the supplied questions to the pending follow-up question queue in
-    /// component state. If the queue was empty, the bottom-panel display is
-    /// reconfigured to present the new head question.
-    /// </summary>
-    void QueueFollowUpQuestions(IReadOnlyList<FollowUpQuestion> questions);
-
-    /// <summary>
-    /// Appends a message to the accumulated follow-up response list in component state.
-    /// Called by the runner for direct <see cref="FollowUpMessage"/> outputs and by
-    /// the component when a question's continuation produces a response.
-    /// </summary>
-    void AddFollowUpResponse(ChatMessage response);
-
-    /// <summary>
-    /// Pops the head of the pending follow-up question queue. Reconfigures the
-    /// bottom-panel display for the new head, or restores the default text-input
-    /// mode if the queue is now empty.
-    /// </summary>
-    void AdvanceFollowUpQuestion();
-
-    /// <summary>
-    /// Returns the current accumulated follow-up responses and clears them in state.
-    /// Called by the runner immediately before invoking the next agent turn.
-    /// </summary>
-    IReadOnlyList<ChatMessage> TakeFollowUpResponses();
-
-    /// <summary>
-    /// Signals that the application should shut down. Completes the shutdown task
-    /// on the owning component.
-    /// </summary>
-    void RequestShutdown();
-}

dotnet/samples/02-agents/Harness/Harness_Shared_Console/Observers/ConsoleObserver.cs

@@ -18,41 +18,36 @@ public abstract class ConsoleObserver
     /// Override to set options such as <see cref="AgentRunOptions.ResponseFormat"/>.
     /// </summary>
     /// <param name="options">The run options to configure.</param>
-    /// <param name="agent">The agent being interacted with.</param>
-    /// <param name="session">The current agent session.</param>
-    public virtual void ConfigureRunOptions(AgentRunOptions options, AIAgent agent, AgentSession session)
+    public virtual void ConfigureRunOptions(AgentRunOptions options)
     {
     }
 
     /// <summary>
     /// Called for each <see cref="AIContent"/> item in the response stream.
     /// </summary>
-    /// <param name="ux">The UX state driver, used for rendering output.</param>
+    /// <param name="ux">The harness UX container, used for rendering output and interacting with the user.</param>
     /// <param name="content">The content item from the stream.</param>
-    /// <param name="agent">The agent being interacted with.</param>
-    /// <param name="session">The current agent session.</param>
-    public virtual Task OnContentAsync(IUXStateDriver ux, AIContent content, AIAgent agent, AgentSession session) => Task.CompletedTask;
+    public virtual Task OnContentAsync(HarnessUXContainer ux, AIContent content) => Task.CompletedTask;
 
     /// <summary>
     /// Called for each text update in the response stream.
     /// </summary>
-    /// <param name="ux">The UX state driver, used for rendering output.</param>
+    /// <param name="ux">The harness UX container, used for rendering output and interacting with the user.</param>
     /// <param name="text">The text from the update.</param>
-    /// <param name="agent">The agent being interacted with.</param>
-    /// <param name="session">The current agent session.</param>
-    public virtual Task OnTextAsync(IUXStateDriver ux, string text, AIAgent agent, AgentSession session) => Task.CompletedTask;
+    public virtual Task OnTextAsync(HarnessUXContainer ux, string text) => Task.CompletedTask;
 
     /// <summary>
-    /// Called after the response stream completes. Returns a heterogeneous list of
-    /// follow-up actions (questions to ask the user, and/or messages to add directly to
-    /// the next agent invocation), or <see langword="null"/> if no follow-up is needed.
+    /// Called after the response stream completes. Returns messages to include in the
+    /// next agent invocation, or <see langword="null"/> if no re-invocation is needed.
     /// </summary>
-    /// <param name="ux">The UX state driver, used for rendering output.</param>
+    /// <param name="ux">The harness UX container, used for rendering output and interacting with the user.</param>
     /// <param name="agent">The agent being interacted with.</param>
     /// <param name="session">The current agent session.</param>
-    /// <returns>Follow-up actions to process after the stream completes, or <see langword="null"/>.</returns>
-    public virtual Task<IList<FollowUpAction>?> OnStreamCompleteAsync(
-        IUXStateDriver ux,
+    /// <param name="options">The console options.</param>
+    /// <returns>Messages to send to the agent, or <see langword="null"/> if no action is needed.</returns>
+    public virtual Task<IList<ChatMessage>?> OnStreamCompleteAsync(
+        HarnessUXContainer ux,
         AIAgent agent,
-        AgentSession session) => Task.FromResult<IList<FollowUpAction>?>(null);
+        AgentSession session,
+        HarnessConsoleOptions options) => Task.FromResult<IList<ChatMessage>?>(null);
 }

dotnet/samples/02-agents/Harness/Harness_Shared_Console/Observers/ErrorDisplayObserver.cs

@@ -1,6 +1,5 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
 
 namespace Harness.Shared.Console.Observers;
@@ -8,10 +7,10 @@ namespace Harness.Shared.Console.Observers;
 /// <summary>
 /// Displays error content (❌) from the response stream.
 /// </summary>
-public sealed class ErrorDisplayObserver : ConsoleObserver
+internal sealed class ErrorDisplayObserver : ConsoleObserver
 {
     /// <inheritdoc/>
-    public override async Task OnContentAsync(IUXStateDriver ux, AIContent content, AIAgent agent, AgentSession session)
+    public override async Task OnContentAsync(HarnessUXContainer ux, AIContent content)
     {
         if (content is ErrorContent errorContent)
         {

dotnet/samples/02-agents/Harness/Harness_Shared_Console/Observers/PlanningOutputObserver.cs

@@ -2,77 +2,51 @@
 
 using System.Text;
 using System.Text.Json;
-using Harness.ConsoleReactiveComponents;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
 
 namespace Harness.Shared.Console.Observers;
 
 /// <summary>
-/// Planning observer that is mode-aware: in planning mode it configures structured
-/// JSON output, collects streamed text, and deserializes it as a <see cref="PlanningResponse"/>;
-/// in execution mode it passes text straight through to <see cref="IUXStateDriver.WriteTextAsync"/>
-/// for live streaming display.
+/// Planning observer that configures structured output, collects streamed text,
+/// and deserializes it as a <see cref="PlanningResponse"/>. Renders clarification
+/// questions and approval prompts, and manages mode switching when the user approves a plan.
 /// </summary>
-public sealed class PlanningOutputObserver : ConsoleObserver
+internal sealed class PlanningOutputObserver : ConsoleObserver
 {
     private readonly StringBuilder _textCollector = new();
     private readonly AgentModeProvider _modeProvider;
-    private readonly string _planModeName;
-    private readonly string _executionModeName;
-    private readonly IReadOnlyDictionary<string, ConsoleColor>? _modeColors;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PlanningOutputObserver"/> class.
     /// </summary>
     /// <param name="modeProvider">The mode provider for switching modes on approval.</param>
-    /// <param name="planModeName">The mode name that represents the planning mode.</param>
-    /// <param name="executionModeName">The mode name to switch to when the user approves a plan.</param>
-    /// <param name="modeColors">Optional mode-to-color mapping for display.</param>
-    public PlanningOutputObserver(AgentModeProvider modeProvider, string planModeName, string executionModeName, IReadOnlyDictionary<string, ConsoleColor>? modeColors = null)
+    public PlanningOutputObserver(AgentModeProvider modeProvider)
     {
         this._modeProvider = modeProvider;
-        this._planModeName = planModeName;
-        this._executionModeName = executionModeName;
-        this._modeColors = modeColors;
     }
 
     /// <inheritdoc/>
-    public override void ConfigureRunOptions(AgentRunOptions options, AIAgent agent, AgentSession session)
+    public override void ConfigureRunOptions(AgentRunOptions options)
     {
-        if (this.IsPlanningMode(this._modeProvider.GetMode(session)))
-        {
-            options.ResponseFormat = ChatResponseFormat.ForJsonSchema<PlanningResponse>();
-        }
+        options.ResponseFormat = ChatResponseFormat.ForJsonSchema<PlanningResponse>();
     }
 
     /// <inheritdoc/>
-    public override Task OnTextAsync(IUXStateDriver ux, string text, AIAgent agent, AgentSession session)
+    public override Task OnTextAsync(HarnessUXContainer ux, string text)
     {
-        if (this.IsPlanningMode(ux.CurrentMode))
-        {
-            // Planning mode: collect text silently for JSON parsing after the stream.
-            this._textCollector.Append(text);
-            return Task.CompletedTask;
-        }
-
-        // Execution mode: stream text directly to the console.
-        return ux.WriteTextAsync(text);
+        // Collect text silently instead of displaying it.
+        this._textCollector.Append(text);
+        return Task.CompletedTask;
     }
 
     /// <inheritdoc/>
-    public override async Task<IList<FollowUpAction>?> OnStreamCompleteAsync(
-        IUXStateDriver ux,
+    public override async Task<IList<ChatMessage>?> OnStreamCompleteAsync(
+        HarnessUXContainer ux,
         AIAgent agent,
-        AgentSession session)
+        AgentSession session,
+        HarnessConsoleOptions options)
     {
-        if (!this.IsPlanningMode(ux.CurrentMode))
-        {
-            // Execution mode: text was already streamed live; nothing to parse.
-            this._textCollector.Clear();
-            return null;
-        }
-
         // Read collected text from our stream observation.
         string collectedText = this._textCollector.ToString();
         this._textCollector.Clear();
@@ -101,9 +75,10 @@ public sealed class PlanningOutputObserver : ConsoleObserver
             return null;
         }
 
+        // Render based on response type.
         if (planningResponse.Type == PlanningResponseType.Clarification)
         {
-            return BuildClarificationActions(planningResponse);
+            return AsUserMessages(await this.RenderClarificationsAndCollectResponsesAsync(ux, planningResponse));
         }
 
         if (planningResponse.Type == PlanningResponseType.Approval)
@@ -115,87 +90,67 @@ public sealed class PlanningOutputObserver : ConsoleObserver
                 return null;
             }
 
-            return new List<FollowUpAction> { this.BuildApprovalAction(question, session) };
+            string response = await this.RenderApprovalAndCollectResponseAsync(ux, question, options);
+            if (response == "Approved")
+            {
+                this._modeProvider.SetMode(session, options.ExecutionModeName!);
+
+                await ux.WriteInfoLineAsync($"✅ Switched to {options.ExecutionModeName} mode.",
+                    ModeColors.Get(options.ExecutionModeName, options.ModeColors));
+            }
+
+            return AsUserMessages(response);
         }
 
         await ux.WriteInfoLineAsync($"(unexpected response type: {planningResponse.Type})", ConsoleColor.DarkYellow);
         return null;
     }
 
-    private static List<FollowUpAction> BuildClarificationActions(PlanningResponse response)
+    private static IList<ChatMessage>? AsUserMessages(string? text) =>
+        text is not null ? [new ChatMessage(ChatRole.User, text)] : null;
+
+    private async Task<string?> RenderClarificationsAndCollectResponsesAsync(HarnessUXContainer ux, PlanningResponse response)
     {
-        var actions = new List<FollowUpAction>(response.Questions.Count);
+        var answers = new List<string>();
 
         foreach (var question in response.Questions)
         {
-            string prompt = question.Message;
-
-            async Task<ChatMessage?> Continuation(string answer, IUXStateDriver ux)
-            {
-                if (string.IsNullOrWhiteSpace(answer))
-                {
-                    string noAnswer = $"🔹 {prompt}\n   └─ {AnsiEscapes.SetForegroundColor(ConsoleColor.DarkGray)}(no answer){AnsiEscapes.ResetAttributes}";
-                    await ux.WriteInfoLineAsync(noAnswer, ConsoleColor.Gray).ConfigureAwait(false);
-                    return null;
-                }
-
-                string formatted = $"🔹 {prompt}\n   └─ {AnsiEscapes.SetForegroundColor(ConsoleColor.Green)}{answer}{AnsiEscapes.ResetAttributes}";
-                await ux.WriteInfoLineAsync(formatted, ConsoleColor.Gray).ConfigureAwait(false);
-
-                return new ChatMessage(ChatRole.User, $"Q: {prompt}\nA: {answer}");
-            }
-
+            string? answer;
             if (question.Choices is { Count: > 0 })
             {
-                actions.Add(new ChoiceFollowUpQuestion(
-                    Prompt: prompt,
-                    Choices: question.Choices,
-                    AllowCustomText: true,
-                    Continuation: Continuation));
+                answer = await ux.ReadSelectionAsync(
+                    question.Message,
+                    question.Choices);
             }
             else
             {
-                actions.Add(new TextFollowUpQuestion(
-                    Prompt: prompt,
-                    Continuation: Continuation));
+                answer = (await ux.ReadLineAsync(question.Message))?.Trim();
+            }
+
+            if (!string.IsNullOrWhiteSpace(answer))
+            {
+                answers.Add($"Q: {question.Message}\nA: {answer}");
             }
         }
 
-        return actions;
+        return answers.Count > 0 ? string.Join("\n\n", answers) : null;
     }
 
-    private ChoiceFollowUpQuestion BuildApprovalAction(PlanningQuestion question, AgentSession session)
+    private async Task<string> RenderApprovalAndCollectResponseAsync(HarnessUXContainer ux, PlanningQuestion question, HarnessConsoleOptions options)
     {
-        const string ApproveOption = "Approve and switch to execute mode";
-        var choices = new List<string> { ApproveOption };
+        var choices = new List<string>
+        {
+            "Approve and switch to execute mode",
+        };
 
-        return new ChoiceFollowUpQuestion(
-            Prompt: question.Message,
-            Choices: choices,
-            AllowCustomText: true,
-            Continuation: async (selection, ux) =>
-            {
-                string formatted = $"🔹 {question.Message}\n   └─ {AnsiEscapes.SetForegroundColor(ConsoleColor.Green)}{selection}{AnsiEscapes.ResetAttributes}";
-                await ux.WriteInfoLineAsync(formatted, ConsoleColor.Gray).ConfigureAwait(false);
+        string selection = await ux.ReadSelectionAsync(question.Message, choices);
 
-                if (selection == ApproveOption)
-                {
-                    this._modeProvider.SetMode(session, this._executionModeName);
-                    await ux.WriteInfoLineAsync(
-                        $"✅ Switched to {this._executionModeName} mode.",
-                        ModeColors.Get(this._executionModeName, this._modeColors)).ConfigureAwait(false);
-                    return new ChatMessage(ChatRole.User, "Approved");
-                }
+        if (selection == choices[0])
+        {
+            return "Approved";
+        }
 
-                // Custom freeform input — treat as suggested changes.
-                return new ChatMessage(ChatRole.User, selection);
-            });
+        // Custom freeform input — treat as suggested changes.
+        return selection;
     }
-
-    /// <summary>
-    /// Returns <see langword="true"/> when the current mode matches the configured plan mode name.
-    /// A <see langword="null"/> mode (no mode provider) is also treated as planning mode.
-    /// </summary>
-    private bool IsPlanningMode(string? currentMode) =>
-        currentMode is null || string.Equals(currentMode, this._planModeName, StringComparison.OrdinalIgnoreCase);
 }

dotnet/samples/02-agents/Harness/Harness_Shared_Console/Observers/ReasoningDisplayObserver.cs

@@ -1,6 +1,5 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
 
 namespace Harness.Shared.Console.Observers;
@@ -8,10 +7,10 @@ namespace Harness.Shared.Console.Observers;
 /// <summary>
 /// Displays reasoning content in dark magenta from the response stream.
 /// </summary>
-public sealed class ReasoningDisplayObserver : ConsoleObserver
+internal sealed class ReasoningDisplayObserver : ConsoleObserver
 {
     /// <inheritdoc/>
-    public override async Task OnContentAsync(IUXStateDriver ux, AIContent content, AIAgent agent, AgentSession session)
+    public override async Task OnContentAsync(HarnessUXContainer ux, AIContent content)
     {
         if (content is TextReasoningContent reasoning && !string.IsNullOrEmpty(reasoning.Text))
         {

dotnet/samples/02-agents/Harness/Harness_Shared_Console/Observers/TextOutputObserver.cs

@@ -1,17 +1,15 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using Microsoft.Agents.AI;
-
 namespace Harness.Shared.Console.Observers;
 
 /// <summary>
 /// Streams agent text output directly to the console.
 /// Used in normal (non-planning) mode.
 /// </summary>
-public sealed class TextOutputObserver : ConsoleObserver
+internal sealed class TextOutputObserver : ConsoleObserver
 {
     /// <inheritdoc/>
-    public override async Task OnTextAsync(IUXStateDriver ux, string text, AIAgent agent, AgentSession session)
+    public override async Task OnTextAsync(HarnessUXContainer ux, string text)
     {
         await ux.WriteTextAsync(text);
     }

dotnet/samples/02-agents/Harness/Harness_Shared_Console/Observers/ToolApprovalObserver.cs

@@ -1,7 +1,5 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using Harness.ConsoleReactiveComponents;
-using Harness.Shared.Console.ToolFormatters;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
 
@@ -9,103 +7,86 @@ namespace Harness.Shared.Console.Observers;
 
 /// <summary>
 /// Collects <see cref="ToolApprovalRequestContent"/> items during the response stream,
-/// displays approval-needed notifications inline, and after the stream completes returns
-/// one <see cref="ChoiceFollowUpQuestion"/> per pending approval request. Each question's
-/// continuation produces a separate <see cref="ChatMessage"/> carrying the approval
-/// response content.
+/// displays approval-needed notifications inline, and prompts the user for approval
+/// decisions after the stream completes.
 /// </summary>
-public sealed class ToolApprovalObserver : ConsoleObserver
+internal sealed class ToolApprovalObserver : ConsoleObserver
 {
     private readonly List<ToolApprovalRequestContent> _approvalRequests = [];
-    private readonly IReadOnlyList<ToolCallFormatter> _formatters;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="ToolApprovalObserver"/> class.
-    /// </summary>
-    /// <param name="formatters">Optional list of tool formatters. When <see langword="null"/>,
-    /// the default formatters from <see cref="ToolCallFormatter.BuildDefaultToolFormatters"/> are used.</param>
-    public ToolApprovalObserver(IReadOnlyList<ToolCallFormatter>? formatters = null)
-    {
-        this._formatters = formatters ?? ToolCallFormatter.BuildDefaultToolFormatters();
-    }
 
     /// <inheritdoc/>
-    public override async Task OnContentAsync(IUXStateDriver ux, AIContent content, AIAgent agent, AgentSession session)
+    public override async Task OnContentAsync(HarnessUXContainer ux, AIContent content)
     {
         if (content is ToolApprovalRequestContent approvalRequest)
         {
             this._approvalRequests.Add(approvalRequest);
             string toolName = approvalRequest.ToolCall is FunctionCallContent fc
-                ? ToolCallFormatter.Format(this._formatters, fc)
+                ? ToolCallFormatter.Format(fc)
                 : approvalRequest.ToolCall?.ToString() ?? "unknown";
             await ux.WriteInfoLineAsync($"⚠️ Approval needed: {toolName}", ConsoleColor.Yellow);
         }
     }
 
     /// <inheritdoc/>
-    public override Task<IList<FollowUpAction>?> OnStreamCompleteAsync(
-        IUXStateDriver ux,
+    public override async Task<IList<ChatMessage>?> OnStreamCompleteAsync(
+        HarnessUXContainer ux,
         AIAgent agent,
-        AgentSession session)
+        AgentSession session,
+        HarnessConsoleOptions options)
     {
         if (this._approvalRequests.Count == 0)
         {
-            return Task.FromResult<IList<FollowUpAction>?>(null);
-        }
-
-        var actions = new List<FollowUpAction>(this._approvalRequests.Count);
-        foreach (var request in this._approvalRequests)
-        {
-            actions.Add(this.BuildApprovalQuestion(request));
+            return null;
         }
 
+        var messages = await PromptForApprovalsAsync(ux, this._approvalRequests);
         this._approvalRequests.Clear();
-        return Task.FromResult<IList<FollowUpAction>?>(actions);
+        return messages;
     }
 
-    private ChoiceFollowUpQuestion BuildApprovalQuestion(ToolApprovalRequestContent request)
+    private static async Task<List<ChatMessage>?> PromptForApprovalsAsync(HarnessUXContainer ux, List<ToolApprovalRequestContent> approvalRequests)
     {
-        string toolName = request.ToolCall is FunctionCallContent fc
-            ? ToolCallFormatter.Format(this._formatters, fc)
-            : request.ToolCall?.ToString() ?? "unknown";
-
-        var choices = new List<string>
+        if (approvalRequests.Count == 0)
         {
-            "Approve this call",
-            "Always approve this tool (any arguments)",
-            "Always approve this tool with these arguments",
-            "Deny",
-        };
+            return null;
+        }
 
-        string prompt = $"🔐 Tool approval: {toolName}";
+        var responses = new List<AIContent>();
+        foreach (var request in approvalRequests)
+        {
+            string toolName = request.ToolCall is FunctionCallContent fc
+                ? ToolCallFormatter.Format(fc)
+                : request.ToolCall?.ToString() ?? "unknown";
 
-        return new ChoiceFollowUpQuestion(
-            Prompt: prompt,
-            Choices: choices,
-            AllowCustomText: false,
-            Continuation: async (selection, ux) =>
+            var choices = new List<string>
             {
-                AIContent response = selection switch
-                {
-                    "Always approve this tool (any arguments)" => request.CreateAlwaysApproveToolResponse("User chose to always approve this tool"),
-                    "Always approve this tool with these arguments" => request.CreateAlwaysApproveToolWithArgumentsResponse("User chose to always approve this tool with these arguments"),
-                    "Deny" => request.CreateResponse(approved: false, reason: "User denied"),
-                    _ => request.CreateResponse(approved: true, reason: "User approved"),
-                };
+                "Approve this call",
+                "Always approve this tool (any arguments)",
+                "Always approve this tool with these arguments",
+                "Deny",
+            };
 
-                string action = selection switch
-                {
-                    "Always approve this tool (any arguments)" => "✅ Always approved (any args)",
-                    "Always approve this tool with these arguments" => "✅ Always approved (these args)",
-                    "Deny" => "❌ Denied",
-                    _ => "✅ Approved",
-                };
+            string selection = await ux.ReadSelectionAsync($"🔐 Tool approval: {toolName}", choices);
+            AIContent response = selection switch
+            {
+                "Always approve this tool (any arguments)" => request.CreateAlwaysApproveToolResponse("User chose to always approve this tool"),
+                "Always approve this tool with these arguments" => request.CreateAlwaysApproveToolWithArgumentsResponse("User chose to always approve this tool with these arguments"),
+                "Deny" => request.CreateResponse(approved: false, reason: "User denied"),
+                _ => request.CreateResponse(approved: true, reason: "User approved"),
+            };
 
-                ConsoleColor answerColor = selection == "Deny" ? ConsoleColor.Red : ConsoleColor.Green;
-                string formatted = $"🔹 {prompt}\n   └─ {AnsiEscapes.SetForegroundColor(answerColor)}{action}{AnsiEscapes.ResetAttributes}";
-                await ux.WriteInfoLineAsync(formatted, ConsoleColor.Gray).ConfigureAwait(false);
+            string action = selection switch
+            {
+                "Always approve this tool (any arguments)" => "✅ Always approved (any args)",
+                "Always approve this tool with these arguments" => "✅ Always approved (these args)",
+                "Deny" => "❌ Denied",
+                _ => "✅ Approved",
+            };
+            await ux.WriteInfoLineAsync($"   {action}", ConsoleColor.DarkGray);
 
-                return new ChatMessage(ChatRole.User, [response]);
-            });
+            responses.Add(response);
+        }
+
+        return [new ChatMessage(ChatRole.User, responses)];
     }
 }

dotnet/samples/02-agents/Harness/Harness_Shared_Console/Observers/ToolCallDisplayObserver.cs

@@ -1,7 +1,5 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using Harness.Shared.Console.ToolFormatters;
-using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
 
 namespace Harness.Shared.Console.Observers;
@@ -10,30 +8,14 @@ namespace Harness.Shared.Console.Observers;
 /// Displays tool call notifications (🔧) for <see cref="FunctionCallContent"/>
 /// and <see cref="ToolCallContent"/> items in the response stream.
 /// </summary>
-public sealed class ToolCallDisplayObserver : ConsoleObserver
+internal sealed class ToolCallDisplayObserver : ConsoleObserver
 {
-    private readonly IReadOnlyList<ToolCallFormatter> _formatters;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="ToolCallDisplayObserver"/> class.
-    /// </summary>
-    /// <param name="formatters">Optional list of tool formatters. When <see langword="null"/>,
-    /// the default formatters from <see cref="ToolCallFormatter.BuildDefaultToolFormatters"/> are used.</param>
-    public ToolCallDisplayObserver(IReadOnlyList<ToolCallFormatter>? formatters = null)
-    {
-        this._formatters = formatters ?? ToolCallFormatter.BuildDefaultToolFormatters();
-    }
-
     /// <inheritdoc/>
-    public override async Task OnContentAsync(IUXStateDriver ux, AIContent content, AIAgent agent, AgentSession session)
+    public override async Task OnContentAsync(HarnessUXContainer ux, AIContent content)
     {
         if (content is FunctionCallContent functionCall)
         {
-            await ux.WriteInfoLineAsync($"🔧 Calling tool: {ToolCallFormatter.Format(this._formatters, functionCall)}...", ConsoleColor.DarkYellow);
-        }
-        else if (content is WebSearchToolCallContent)
-        {
-            // Handled by OpenAIResponsesWebSearchDisplayObserver when present; skip here to avoid duplication.
+            await ux.WriteInfoLineAsync($"🔧 Calling tool: {ToolCallFormatter.Format(functionCall)}...", ConsoleColor.DarkYellow);
         }
         else if (content is ToolCallContent toolCall)
         {

dotnet/samples/02-agents/Harness/Harness_Shared_Console/Observers/ToolCallFormatter.cs

@@ -0,0 +1,288 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Text;
+using System.Text.Json;
+using Microsoft.Extensions.AI;
+
+namespace Harness.Shared.Console.Observers;
+
+/// <summary>
+/// Formats <see cref="FunctionCallContent"/> instances into human-readable strings
+/// for console display.
+/// </summary>
+public static class ToolCallFormatter
+{
+    /// <summary>
+    /// Returns a formatted string for the given tool call, with human-readable
+    /// details for known tools (todos, mode, sub-agents, web tools).
+    /// </summary>
+    /// <param name="call">The function call content to format.</param>
+    /// <returns>A formatted string describing the tool call.</returns>
+    public static string Format(FunctionCallContent call)
+    {
+        string? detail = call.Name switch
+        {
+            // Todo tools
+            "TodoList_Add" => FormatAddTodos(call),
+            "TodoList_Complete" => FormatIdList(call, "ids", "Complete"),
+            "TodoList_Remove" => FormatIdList(call, "ids", "Remove"),
+            "TodoList_GetRemaining" => null,
+            "TodoList_GetAll" => null,
+
+            // Mode tools
+            "AgentMode_Set" => FormatStringArg(call, "mode"),
+            "AgentMode_Get" => null,
+
+            // Sub-agent tools
+            "SubAgents_StartTask" => FormatStartSubTask(call),
+            "SubAgents_WaitForFirstCompletion" => FormatIdList(call, "taskIds", "Wait for"),
+            "SubAgents_GetTaskResults" => FormatSingleId(call, "taskId"),
+            "SubAgents_GetAllTasks" => null,
+            "SubAgents_ContinueTask" => FormatContinueTask(call),
+            "SubAgents_ClearCompletedTask" => FormatSingleId(call, "taskId"),
+
+            // File memory tools
+            "FileMemory_SaveFile" => FormatSaveFile(call),
+            "FileMemory_ReadFile" => FormatStringArg(call, "fileName"),
+            "FileMemory_DeleteFile" => FormatStringArg(call, "fileName"),
+            "FileMemory_ListFiles" => null,
+            "FileMemory_SearchFiles" => FormatSearchFiles(call),
+
+            // External tools
+            "web_search" => FormatStringArg(call, "query"),
+            "DownloadUri" => FormatStringArg(call, "uri"),
+
+            _ => FormatFallback(call),
+        };
+
+        return detail is not null ? $"{call.Name} {detail}" : call.Name;
+    }
+
+    private static string? FormatAddTodos(FunctionCallContent call)
+    {
+        if (call.Arguments?.TryGetValue("todos", out object? todosObj) != true || todosObj is null)
+        {
+            return null;
+        }
+
+        var titles = new List<string>();
+
+        if (todosObj is JsonElement jsonArray && jsonArray.ValueKind == JsonValueKind.Array)
+        {
+            foreach (JsonElement item in jsonArray.EnumerateArray())
+            {
+                string? title = item.TryGetProperty("title", out JsonElement titleElement)
+                    ? titleElement.GetString()
+                    : null;
+
+                if (!string.IsNullOrEmpty(title))
+                {
+                    titles.Add(title);
+                }
+            }
+        }
+
+        if (titles.Count == 0)
+        {
+            return null;
+        }
+
+        var sb = new StringBuilder();
+        sb.Append($"({titles.Count} item{(titles.Count == 1 ? "" : "s")})");
+        foreach (string title in titles)
+        {
+            sb.Append($"\n    • {title}");
+        }
+
+        return sb.ToString();
+    }
+
+    private static string? FormatIdList(FunctionCallContent call, string paramName, string verb)
+    {
+        List<int>? ids = GetIntList(call, paramName);
+        if (ids is null || ids.Count == 0)
+        {
+            return null;
+        }
+
+        return $"({verb} #{string.Join(", #", ids)})";
+    }
+
+    private static string? FormatSingleId(FunctionCallContent call, string paramName)
+    {
+        int? id = GetInt(call, paramName);
+        return id.HasValue ? $"(task #{id.Value})" : null;
+    }
+
+    private static string? FormatStartSubTask(FunctionCallContent call)
+    {
+        string? agentName = GetString(call, "agentName");
+        string? description = GetString(call, "description");
+
+        if (agentName is null && description is null)
+        {
+            return null;
+        }
+
+        var sb = new StringBuilder("(");
+        if (agentName is not null)
+        {
+            sb.Append($"agent: {agentName}");
+        }
+
+        if (description is not null)
+        {
+            if (agentName is not null)
+            {
+                sb.Append(", ");
+            }
+
+            sb.Append($"\"{Truncate(description, 60)}\"");
+        }
+
+        sb.Append(')');
+        return sb.ToString();
+    }
+
+    private static string? FormatContinueTask(FunctionCallContent call)
+    {
+        int? taskId = GetInt(call, "taskId");
+        string? text = GetString(call, "text");
+
+        if (!taskId.HasValue)
+        {
+            return null;
+        }
+
+        return text is not null
+            ? $"(task #{taskId.Value}, \"{Truncate(text, 50)}\")"
+            : $"(task #{taskId.Value})";
+    }
+
+    private static string? FormatSaveFile(FunctionCallContent call)
+    {
+        string? fileName = GetString(call, "fileName");
+        string? description = GetString(call, "description");
+
+        if (fileName is null)
+        {
+            return null;
+        }
+
+        return string.IsNullOrEmpty(description)
+            ? $"({fileName})"
+            : $"({fileName}, with description)";
+    }
+
+    private static string? FormatSearchFiles(FunctionCallContent call)
+    {
+        string? pattern = GetString(call, "regexPattern");
+        string? filePattern = GetString(call, "filePattern");
+
+        if (pattern is null)
+        {
+            return null;
+        }
+
+        return string.IsNullOrEmpty(filePattern)
+            ? $"(/{pattern}/)"
+            : $"(/{pattern}/ in {filePattern})";
+    }
+
+    private static string? FormatStringArg(FunctionCallContent call, string paramName)
+    {
+        string? value = GetString(call, paramName);
+        return value is not null ? $"({value})" : null;
+    }
+
+    private static string? FormatFallback(FunctionCallContent call)
+    {
+        if (call.Arguments is null || call.Arguments.Count == 0)
+        {
+            return null;
+        }
+
+        var parts = new List<string>();
+        foreach (var kvp in call.Arguments)
+        {
+            string? stringValue = kvp.Value switch
+            {
+                JsonElement je => je.ValueKind switch
+                {
+                    JsonValueKind.String => je.GetString(),
+                    JsonValueKind.Number => je.GetRawText(),
+                    JsonValueKind.True => "true",
+                    JsonValueKind.False => "false",
+                    _ => null,
+                },
+                not null => kvp.Value.ToString(),
+                _ => null,
+            };
+
+            if (stringValue is not null)
+            {
+                parts.Add($"{kvp.Key}: {Truncate(stringValue, 40)}");
+            }
+        }
+
+        return parts.Count > 0 ? $"({string.Join(", ", parts)})" : null;
+    }
+
+    private static string? GetString(FunctionCallContent call, string paramName)
+    {
+        if (call.Arguments?.TryGetValue(paramName, out object? value) != true || value is null)
+        {
+            return null;
+        }
+
+        return value switch
+        {
+            JsonElement je when je.ValueKind == JsonValueKind.String => je.GetString(),
+            string s => s,
+            _ => value.ToString(),
+        };
+    }
+
+    private static int? GetInt(FunctionCallContent call, string paramName)
+    {
+        if (call.Arguments?.TryGetValue(paramName, out object? value) != true || value is null)
+        {
+            return null;
+        }
+
+        return value switch
+        {
+            JsonElement je when je.ValueKind == JsonValueKind.Number => je.GetInt32(),
+            int i => i,
+            _ => int.TryParse(value.ToString(), out int parsed) ? parsed : null,
+        };
+    }
+
+    private static List<int>? GetIntList(FunctionCallContent call, string paramName)
+    {
+        if (call.Arguments?.TryGetValue(paramName, out object? value) != true || value is null)
+        {
+            return null;
+        }
+
+        var result = new List<int>();
+
+        if (value is JsonElement je && je.ValueKind == JsonValueKind.Array)
+        {
+            foreach (JsonElement item in je.EnumerateArray())
+            {
+                if (item.ValueKind == JsonValueKind.Number)
+                {
+                    result.Add(item.GetInt32());
+                }
+            }
+        }
+
+        return result.Count > 0 ? result : null;
+    }
+
+    private static string Truncate(string text, int maxLength)
+    {
+        return text.Length <= maxLength ? text : string.Concat(text.AsSpan(0, maxLength), "…");
+    }
+}

dotnet/samples/02-agents/Harness/Harness_Shared_Console/Observers/UsageDisplayObserver.cs

@@ -1,6 +1,5 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
 
 namespace Harness.Shared.Console.Observers;
@@ -8,7 +7,7 @@ namespace Harness.Shared.Console.Observers;
 /// <summary>
 /// Displays token usage statistics (📊) from the response stream.
 /// </summary>
-public sealed class UsageDisplayObserver : ConsoleObserver
+internal sealed class UsageDisplayObserver : ConsoleObserver
 {
     private readonly int? _maxContextWindowTokens;
     private readonly int? _maxOutputTokens;
@@ -25,7 +24,7 @@ public sealed class UsageDisplayObserver : ConsoleObserver
     }
 
     /// <inheritdoc/>
-    public override Task OnContentAsync(IUXStateDriver ux, AIContent content, AIAgent agent, AgentSession session)
+    public override Task OnContentAsync(HarnessUXContainer ux, AIContent content)
     {
         if (content is UsageContent usage)
         {

dotnet/samples/02-agents/Harness/Harness_Shared_Console/OutputEntry.cs

@@ -5,7 +5,7 @@ namespace Harness.Shared.Console;
 /// <summary>
 /// Represents the type of an output entry in the console conversation.
 /// </summary>
-internal enum OutputEntryType
+public enum OutputEntryType
 {
     /// <summary>User input echo (e.g. "You: hello").</summary>
     UserInput,
@@ -25,10 +25,9 @@ internal enum OutputEntryType
 
 /// <summary>
 /// Represents a single output entry in the console conversation history.
-/// Used internally by <see cref="HarnessConsoleUXStateDriver"/> to track
-/// the in-progress streaming entry and last-entry type for spacing decisions.
+/// These entries are rendered by the <see cref="HarnessAppComponent"/> via its render delegate.
 /// </summary>
 /// <param name="Type">The type of output entry.</param>
 /// <param name="Text">The text content of the entry.</param>
 /// <param name="Color">Optional foreground color for rendering.</param>
-internal sealed record OutputEntry(OutputEntryType Type, string Text, ConsoleColor? Color = null);
+public record OutputEntry(OutputEntryType Type, string Text, ConsoleColor? Color = null);

dotnet/samples/02-agents/Harness/Harness_Shared_Console/ToolFormatters/FallbackToolFormatter.cs

@@ -1,51 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System.Text.Json;
-using Microsoft.Extensions.AI;
-
-namespace Harness.Shared.Console.ToolFormatters;
-
-/// <summary>
-/// Catch-all formatter that handles any tool not matched by a more specific formatter.
-/// Displays a generic summary of the tool's arguments. This formatter should always be
-/// placed last in the formatter list.
-/// </summary>
-public sealed class FallbackToolFormatter : ToolCallFormatter
-{
-    /// <inheritdoc/>
-    public override bool CanFormat(FunctionCallContent call) => true;
-
-    /// <inheritdoc/>
-    public override string? FormatDetail(FunctionCallContent call)
-    {
-        if (call.Arguments is null || call.Arguments.Count == 0)
-        {
-            return null;
-        }
-
-        var parts = new List<string>();
-        foreach (var kvp in call.Arguments)
-        {
-            string? stringValue = kvp.Value switch
-            {
-                JsonElement je => je.ValueKind switch
-                {
-                    JsonValueKind.String => je.GetString(),
-                    JsonValueKind.Number => je.GetRawText(),
-                    JsonValueKind.True => "true",
-                    JsonValueKind.False => "false",
-                    _ => null,
-                },
-                not null => kvp.Value.ToString(),
-                _ => null,
-            };
-
-            if (stringValue is not null)
-            {
-                parts.Add($"{kvp.Key}: {Truncate(stringValue, 40)}");
-            }
-        }
-
-        return parts.Count > 0 ? $"({string.Join(", ", parts)})" : null;
-    }
-}

dotnet/samples/02-agents/Harness/Harness_Shared_Console/ToolFormatters/FileMemoryToolFormatter.cs

@@ -1,61 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using Microsoft.Extensions.AI;
-
-namespace Harness.Shared.Console.ToolFormatters;
-
-/// <summary>
-/// Formats <c>FileMemory_*</c> tool calls, showing file names and search patterns
-/// with tree-view corners for save operations.
-/// </summary>
-public sealed class FileMemoryToolFormatter : ToolCallFormatter
-{
-    /// <inheritdoc/>
-    public override bool CanFormat(FunctionCallContent call) => call.Name.StartsWith("FileMemory_", StringComparison.Ordinal);
-
-    /// <inheritdoc/>
-    public override string? FormatDetail(FunctionCallContent call) => call.Name switch
-    {
-        "FileMemory_SaveFile" => FormatSaveFile(call),
-        "FileMemory_ReadFile" => FormatStringArg(call, "fileName"),
-        "FileMemory_DeleteFile" => FormatStringArg(call, "fileName"),
-        "FileMemory_SearchFiles" => FormatSearchFiles(call),
-        _ => null,
-    };
-
-    private static string? FormatSaveFile(FunctionCallContent call)
-    {
-        string? fileName = GetStringArgumentValue(call, "fileName");
-        string? description = GetStringArgumentValue(call, "description");
-
-        if (fileName is null)
-        {
-            return null;
-        }
-
-        return string.IsNullOrEmpty(description)
-            ? $"\n   └─ {fileName}"
-            : $"\n   └─ {fileName} (with description)";
-    }
-
-    private static string? FormatSearchFiles(FunctionCallContent call)
-    {
-        string? pattern = GetStringArgumentValue(call, "regexPattern");
-        string? filePattern = GetStringArgumentValue(call, "filePattern");
-
-        if (pattern is null)
-        {
-            return null;
-        }
-
-        return string.IsNullOrEmpty(filePattern)
-            ? $"(/{pattern}/)"
-            : $"(/{pattern}/ in {filePattern})";
-    }
-
-    private static string? FormatStringArg(FunctionCallContent call, string paramName)
-    {
-        string? value = GetStringArgumentValue(call, paramName);
-        return value is not null ? $"({value})" : null;
-    }
-}

dotnet/samples/02-agents/Harness/Harness_Shared_Console/ToolFormatters/ModeToolFormatter.cs

@@ -1,27 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using Microsoft.Extensions.AI;
-
-namespace Harness.Shared.Console.ToolFormatters;
-
-/// <summary>
-/// Formats <c>AgentMode_*</c> tool calls, showing the target mode for Set operations.
-/// </summary>
-public sealed class ModeToolFormatter : ToolCallFormatter
-{
-    /// <inheritdoc/>
-    public override bool CanFormat(FunctionCallContent call) => call.Name.StartsWith("AgentMode_", StringComparison.Ordinal);
-
-    /// <inheritdoc/>
-    public override string? FormatDetail(FunctionCallContent call) => call.Name switch
-    {
-        "AgentMode_Set" => FormatStringArg(call, "mode"),
-        _ => null,
-    };
-
-    private static string? FormatStringArg(FunctionCallContent call, string paramName)
-    {
-        string? value = GetStringArgumentValue(call, paramName);
-        return value is not null ? $"({value})" : null;
-    }
-}

dotnet/samples/02-agents/Harness/Harness_Shared_Console/ToolFormatters/SubAgentToolFormatter.cs

@@ -1,101 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System.Text;
-using Microsoft.Extensions.AI;
-
-namespace Harness.Shared.Console.ToolFormatters;
-
-/// <summary>
-/// Formats <c>SubAgents_*</c> tool calls with human-readable details
-/// for task start, continue, wait, and result retrieval operations.
-/// </summary>
-public sealed class SubAgentToolFormatter : ToolCallFormatter
-{
-    /// <inheritdoc/>
-    public override bool CanFormat(FunctionCallContent call) => call.Name.StartsWith("SubAgents_", StringComparison.Ordinal);
-
-    /// <inheritdoc/>
-    public override string? FormatDetail(FunctionCallContent call) => call.Name switch
-    {
-        "SubAgents_StartTask" => FormatStartSubTask(call),
-        "SubAgents_WaitForFirstCompletion" => FormatIdList(call, "taskIds", "Wait for"),
-        "SubAgents_GetTaskResults" => FormatSingleId(call, "taskId"),
-        "SubAgents_ContinueTask" => FormatContinueTask(call),
-        "SubAgents_ClearCompletedTask" => FormatSingleId(call, "taskId"),
-        _ => null,
-    };
-
-    private static string? FormatStartSubTask(FunctionCallContent call)
-    {
-        string? agentName = GetStringArgumentValue(call, "agentName");
-        string? description = GetStringArgumentValue(call, "description");
-
-        if (agentName is null && description is null)
-        {
-            return null;
-        }
-
-        var sb = new StringBuilder();
-
-        if (agentName is not null && description is not null)
-        {
-            sb.Append($"\n   ├─ Agent: {agentName}");
-            sb.Append($"\n   └─ \"{Truncate(description, 80)}\"");
-        }
-        else if (agentName is not null)
-        {
-            sb.Append($"\n   └─ Agent: {agentName}");
-        }
-        else
-        {
-            sb.Append($"\n   └─ \"{Truncate(description!, 80)}\"");
-        }
-
-        return sb.ToString();
-    }
-
-    private static string? FormatIdList(FunctionCallContent call, string paramName, string verb)
-    {
-        List<int>? ids = GetIntListArgumentValue(call, paramName);
-        if (ids is null || ids.Count == 0)
-        {
-            return null;
-        }
-
-        var sb = new StringBuilder();
-        for (int i = 0; i < ids.Count; i++)
-        {
-            string connector = i < ids.Count - 1 ? "├─" : "└─";
-            sb.Append($"\n   {connector} {verb} #{ids[i]}");
-        }
-
-        return sb.ToString();
-    }
-
-    private static string? FormatSingleId(FunctionCallContent call, string paramName)
-    {
-        int? id = GetIntArgumentValue(call, paramName);
-        return id.HasValue ? $"(task #{id.Value})" : null;
-    }
-
-    private static string? FormatContinueTask(FunctionCallContent call)
-    {
-        int? taskId = GetIntArgumentValue(call, "taskId");
-        string? text = GetStringArgumentValue(call, "text");
-
-        if (!taskId.HasValue)
-        {
-            return null;
-        }
-
-        if (text is not null)
-        {
-            var sb = new StringBuilder();
-            sb.Append($"\n   ├─ Task #{taskId.Value}");
-            sb.Append($"\n   └─ \"{Truncate(text, 80)}\"");
-            return sb.ToString();
-        }
-
-        return $"\n   └─ Task #{taskId.Value}";
-    }
-}

dotnet/samples/02-agents/Harness/Harness_Shared_Console/ToolFormatters/TodoToolFormatter.cs

@@ -1,84 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System.Text;
-using System.Text.Json;
-using Microsoft.Extensions.AI;
-
-namespace Harness.Shared.Console.ToolFormatters;
-
-/// <summary>
-/// Formats <c>TodoList_*</c> tool calls with tree-view output for added items
-/// and structured output for complete/remove operations.
-/// </summary>
-public sealed class TodoToolFormatter : ToolCallFormatter
-{
-    /// <inheritdoc/>
-    public override bool CanFormat(FunctionCallContent call) => call.Name.StartsWith("TodoList_", StringComparison.Ordinal);
-
-    /// <inheritdoc/>
-    public override string? FormatDetail(FunctionCallContent call) => call.Name switch
-    {
-        "TodoList_Add" => FormatAddTodos(call),
-        "TodoList_Complete" => FormatIdList(call, "ids", "Complete"),
-        "TodoList_Remove" => FormatIdList(call, "ids", "Remove"),
-        _ => null,
-    };
-
-    private static string? FormatAddTodos(FunctionCallContent call)
-    {
-        if (call.Arguments?.TryGetValue("todos", out object? todosObj) != true || todosObj is null)
-        {
-            return null;
-        }
-
-        var titles = new List<string>();
-
-        if (todosObj is JsonElement jsonArray && jsonArray.ValueKind == JsonValueKind.Array)
-        {
-            foreach (JsonElement item in jsonArray.EnumerateArray())
-            {
-                string? title = item.TryGetProperty("title", out JsonElement titleElement)
-                    ? titleElement.GetString()
-                    : null;
-
-                if (!string.IsNullOrEmpty(title))
-                {
-                    titles.Add(title);
-                }
-            }
-        }
-
-        if (titles.Count == 0)
-        {
-            return null;
-        }
-
-        var sb = new StringBuilder();
-        sb.Append($"({titles.Count} item{(titles.Count == 1 ? "" : "s")})");
-        for (int i = 0; i < titles.Count; i++)
-        {
-            string connector = i < titles.Count - 1 ? "├─" : "└─";
-            sb.Append($"\n   {connector} {titles[i]}");
-        }
-
-        return sb.ToString();
-    }
-
-    private static string? FormatIdList(FunctionCallContent call, string paramName, string verb)
-    {
-        List<int>? ids = GetIntListArgumentValue(call, paramName);
-        if (ids is null || ids.Count == 0)
-        {
-            return null;
-        }
-
-        var sb = new StringBuilder();
-        for (int i = 0; i < ids.Count; i++)
-        {
-            string connector = i < ids.Count - 1 ? "├─" : "└─";
-            sb.Append($"\n   {connector} {verb} #{ids[i]}");
-        }
-
-        return sb.ToString();
-    }
-}

dotnet/samples/02-agents/Harness/Harness_Shared_Console/ToolFormatters/ToolCallFormatter.cs

@@ -1,135 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System.Text.Json;
-using Microsoft.Extensions.AI;
-
-namespace Harness.Shared.Console.ToolFormatters;
-
-/// <summary>
-/// Base class for tool call formatters that produce human-readable display strings
-/// for <see cref="FunctionCallContent"/> items shown in the console.
-/// </summary>
-public abstract class ToolCallFormatter
-{
-    /// <summary>
-    /// Returns <see langword="true"/> if this formatter can handle the given function call.
-    /// </summary>
-    /// <param name="call">The function call content to check.</param>
-    /// <returns><see langword="true"/> if this formatter should be used; otherwise <see langword="false"/>.</returns>
-    public abstract bool CanFormat(FunctionCallContent call);
-
-    /// <summary>
-    /// Returns the detail portion of the formatted output for the given tool call,
-    /// or <see langword="null"/> if only the tool name should be displayed.
-    /// </summary>
-    /// <param name="call">The function call content to format.</param>
-    /// <returns>A detail string to append after the tool name, or <see langword="null"/>.</returns>
-    public abstract string? FormatDetail(FunctionCallContent call);
-
-    /// <summary>
-    /// Formats a tool call using the first matching formatter from the provided list.
-    /// Returns <c>"{toolName} {detail}"</c> when a formatter produces detail,
-    /// or just <c>"{toolName}"</c> otherwise.
-    /// </summary>
-    internal static string Format(IReadOnlyList<ToolCallFormatter> formatters, FunctionCallContent call)
-    {
-        foreach (var formatter in formatters)
-        {
-            if (formatter.CanFormat(call))
-            {
-                string? detail = formatter.FormatDetail(call);
-                return detail is not null ? $"{call.Name} {detail}" : call.Name;
-            }
-        }
-
-        return call.Name;
-    }
-
-    /// <summary>
-    /// Creates the default list of tool call formatters. The <see cref="FallbackToolFormatter"/>
-    /// is always last. Users can call this method and combine the result with their own formatters.
-    /// </summary>
-    /// <returns>A list of all built-in tool call formatters.</returns>
-    public static List<ToolCallFormatter> BuildDefaultToolFormatters()
-    {
-        return
-        [
-            new TodoToolFormatter(),
-            new ModeToolFormatter(),
-            new SubAgentToolFormatter(),
-            new FileMemoryToolFormatter(),
-            new WebSearchToolFormatter(),
-            new FallbackToolFormatter(),
-        ];
-    }
-
-    /// <summary>
-    /// Extracts a string argument value from a function call.
-    /// </summary>
-    protected static string? GetStringArgumentValue(FunctionCallContent call, string paramName)
-    {
-        if (call.Arguments?.TryGetValue(paramName, out object? value) != true || value is null)
-        {
-            return null;
-        }
-
-        return value switch
-        {
-            JsonElement je when je.ValueKind == JsonValueKind.String => je.GetString(),
-            string s => s,
-            _ => value.ToString(),
-        };
-    }
-
-    /// <summary>
-    /// Extracts an integer argument value from a function call.
-    /// </summary>
-    protected static int? GetIntArgumentValue(FunctionCallContent call, string paramName)
-    {
-        if (call.Arguments?.TryGetValue(paramName, out object? value) != true || value is null)
-        {
-            return null;
-        }
-
-        return value switch
-        {
-            JsonElement je when je.ValueKind == JsonValueKind.Number => je.GetInt32(),
-            int i => i,
-            _ => int.TryParse(value.ToString(), out int parsed) ? parsed : null,
-        };
-    }
-
-    /// <summary>
-    /// Extracts a list of integer argument values from a function call.
-    /// </summary>
-    protected static List<int>? GetIntListArgumentValue(FunctionCallContent call, string paramName)
-    {
-        if (call.Arguments?.TryGetValue(paramName, out object? value) != true || value is null)
-        {
-            return null;
-        }
-
-        var result = new List<int>();
-
-        if (value is JsonElement je && je.ValueKind == JsonValueKind.Array)
-        {
-            foreach (JsonElement item in je.EnumerateArray())
-            {
-                if (item.ValueKind == JsonValueKind.Number)
-                {
-                    result.Add(item.GetInt32());
-                }
-            }
-        }
-
-        return result.Count > 0 ? result : null;
-    }
-
-    /// <summary>
-    /// Truncates a string to the specified maximum length, appending an ellipsis if truncated.
-    /// </summary>
-    protected static string Truncate(string text, int maxLength)
-    {
-        return text.Length <= maxLength ? text : string.Concat(text.AsSpan(0, maxLength), "…");
-    }
-}

dotnet/samples/02-agents/Harness/Harness_Shared_Console/ToolFormatters/WebSearchToolFormatter.cs

@@ -1,22 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using Microsoft.Extensions.AI;
-
-namespace Harness.Shared.Console.ToolFormatters;
-
-/// <summary>
-/// Formats <c>web_search</c> tool calls, showing the search query.
-/// </summary>
-public sealed class WebSearchToolFormatter : ToolCallFormatter
-{
-    /// <inheritdoc/>
-    public override bool CanFormat(FunctionCallContent call) =>
-        call.Name is "web_search";
-
-    /// <inheritdoc/>
-    public override string? FormatDetail(FunctionCallContent call)
-    {
-        string? value = GetStringArgumentValue(call, "query");
-        return value is not null ? $"({value})" : null;
-    }
-}

dotnet/samples/02-agents/Harness/Harness_Step01_Research/DownloadUriToolFormatter.cs

@@ -1,23 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using Harness.Shared.Console.ToolFormatters;
-using Microsoft.Extensions.AI;
-
-namespace SampleApp;
-
-/// <summary>
-/// Formats <c>DownloadUri</c> tool calls, showing the target URI.
-/// </summary>
-public sealed class DownloadUriToolFormatter : ToolCallFormatter
-{
-    /// <inheritdoc/>
-    public override bool CanFormat(FunctionCallContent call) =>
-        call.Name is "DownloadUri";
-
-    /// <inheritdoc/>
-    public override string? FormatDetail(FunctionCallContent call)
-    {
-        string? value = GetStringArgumentValue(call, "uri");
-        return value is not null ? $"({value})" : null;
-    }
-}

dotnet/samples/02-agents/Harness/Harness_Step01_Research/OpenAIResponsesWebSearchDisplayObserver.cs

@@ -1,206 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-#pragma warning disable OPENAI001 // Suppress experimental API warnings for Responses API usage.
-
-using System.Text;
-using Harness.Shared.Console;
-using Harness.Shared.Console.Observers;
-using Microsoft.Agents.AI;
-using Microsoft.Extensions.AI;
-using OpenAI.Responses;
-
-namespace SampleApp;
-
-/// <summary>
-/// Displays web search activity in the scroll area. Shows search queries,
-/// page opens, and find-in-page actions as they stream in from the API.
-/// </summary>
-internal sealed class OpenAIResponsesWebSearchDisplayObserver : ConsoleObserver
-{
-    private const int MaxQueryDisplayLength = 120;
-
-    /// <inheritdoc/>
-    public override async Task OnContentAsync(IUXStateDriver ux, AIContent content, AIAgent agent, AgentSession session)
-    {
-        if (content is WebSearchToolResultContent resultContent
-            && resultContent.RawRepresentation is WebSearchCallResponseItem wscri)
-        {
-            await WriteActionAsync(ux, wscri, resultContent.Outputs);
-        }
-    }
-
-    private static async Task WriteActionAsync(IUXStateDriver ux, WebSearchCallResponseItem wscri, IList<AIContent>? outputs)
-    {
-        WebSearchAction? action = wscri.Action;
-        if (action is null)
-        {
-            await ux.WriteInfoLineAsync("🌐 Web Search Tool (no action details)", ConsoleColor.DarkCyan);
-            return;
-        }
-
-        switch (action)
-        {
-            case WebSearchFindInPageAction findInPage:
-                await WriteFindInPageAsync(ux, findInPage);
-                break;
-
-            case WebSearchOpenPageAction openPage:
-                await WriteOpenPageAsync(ux, openPage);
-                break;
-
-            case WebSearchSearchAction search:
-                await WriteSearchAsync(ux, search, outputs);
-                break;
-
-            default:
-                await ux.WriteInfoLineAsync("🌐 Web Search Tool (unknown action)", ConsoleColor.DarkCyan);
-                break;
-        }
-    }
-
-    private static async Task WriteSearchAsync(IUXStateDriver ux, WebSearchSearchAction search, IList<AIContent>? outputs)
-    {
-        // Read queries directly from the typed action.
-        IList<string> queries = search.Queries;
-
-        if (queries.Count == 0)
-        {
-            await ux.WriteInfoLineAsync("🌐 Web Search Tool: search", ConsoleColor.DarkCyan);
-            return;
-        }
-
-        var sb = new StringBuilder();
-        sb.Append("🌐 Web Search Tool: search");
-
-        // Show the search queries.
-        bool hasResults = outputs is { Count: > 0 };
-        for (int i = 0; i < queries.Count; i++)
-        {
-            string connector = (i < queries.Count - 1 || hasResults) ? "├─" : "└─";
-            string query = Truncate(queries[i], MaxQueryDisplayLength);
-            sb.Append($"\n   {connector} \"{query}\"");
-        }
-
-        // Show search result sources (URLs + titles) when available.
-        // Sources come from M.E.AI's Outputs when IncludedResponseProperty.WebSearchCallActionSources is set,
-        // or directly from the SDK's WebSearchSearchAction.Sources.
-        if (hasResults)
-        {
-            sb.Append("\n   │");
-            for (int i = 0; i < outputs!.Count; i++)
-            {
-                string connector = i < outputs.Count - 1 ? "├─" : "└─";
-                string line = FormatOutput(outputs[i]);
-                sb.Append($"\n   {connector} {line}");
-            }
-        }
-        else if (search.Sources is { Count: > 0 } sources)
-        {
-            sb.Append("\n   │");
-            for (int i = 0; i < sources.Count; i++)
-            {
-                string connector = i < sources.Count - 1 ? "├─" : "└─";
-                string line = FormatSource(sources[i]);
-                sb.Append($"\n   {connector} {line}");
-            }
-        }
-
-        await ux.WriteInfoLineAsync(sb.ToString(), ConsoleColor.DarkCyan);
-    }
-
-    private static async Task WriteOpenPageAsync(IUXStateDriver ux, WebSearchOpenPageAction openPage)
-    {
-        string url = openPage.Uri?.AbsoluteUri ?? "(unknown)";
-        await ux.WriteInfoLineAsync(
-            $"🌐 Web Search Tool: open page\n   └─ {url}",
-            ConsoleColor.DarkCyan);
-    }
-
-    private static async Task WriteFindInPageAsync(IUXStateDriver ux, WebSearchFindInPageAction findInPage)
-    {
-        string url = findInPage.Uri?.AbsoluteUri ?? "(unknown)";
-        string pattern = findInPage.Pattern ?? "(unknown)";
-
-        await ux.WriteInfoLineAsync(
-            $"🌐 Web Search Tool: find in page\n   ├─ \"{Truncate(pattern, MaxQueryDisplayLength)}\"\n   └─ {url}",
-            ConsoleColor.DarkCyan);
-    }
-
-    /// <summary>
-    /// Formats a single search result source from the SDK's <see cref="WebSearchActionSource"/> for display.
-    /// </summary>
-    private static string FormatSource(WebSearchActionSource source)
-    {
-        if (source is WebSearchActionUriSource uriSource)
-        {
-            string url = uriSource.Uri?.AbsoluteUri ?? "(unknown)";
-
-            // WebSearchActionUriSource doesn't expose a title property,
-            // but the API may include one in the raw response JSON.
-            string? title = GetTitleFromRawRepresentation(uriSource);
-
-            return title is not null
-                ? $"{Truncate(title, MaxQueryDisplayLength)} — {url}"
-                : url;
-        }
-
-        return source.ToString() ?? "(unknown source)";
-    }
-
-    /// <summary>
-    /// Formats a single search result output from M.E.AI's <see cref="AIContent"/> for display.
-    /// </summary>
-    private static string FormatOutput(AIContent output)
-    {
-        if (output is UriContent uriContent)
-        {
-            string url = uriContent.Uri?.AbsoluteUri ?? "(unknown)";
-
-            // Try to extract a title from the raw JSON of the source.
-            // The SDK's WebSearchActionUriSource doesn't expose a title property,
-            // but the API may include one in the raw response.
-            string? title = GetTitleFromRawRepresentation(uriContent.RawRepresentation)
-                ?? (uriContent.AdditionalProperties?.TryGetValue("title", out var t) is true ? t?.ToString() : null);
-
-            return title is not null
-                ? $"{Truncate(title, MaxQueryDisplayLength)} — {url}"
-                : url;
-        }
-
-        return output.ToString() ?? "(unknown output)";
-    }
-
-    /// <summary>
-    /// Attempts to extract a "title" field from a raw representation object by serializing it to JSON.
-    /// The SDK's <see cref="WebSearchActionUriSource"/> doesn't expose a title property,
-    /// but the API may include one in the raw JSON — this is forward-compatible for when
-    /// the SDK adds title support.
-    /// </summary>
-    private static string? GetTitleFromRawRepresentation(object? rawRepresentation)
-    {
-        if (rawRepresentation is null)
-        {
-            return null;
-        }
-
-        try
-        {
-            var data = System.ClientModel.Primitives.ModelReaderWriter.Write(rawRepresentation);
-            using var doc = System.Text.Json.JsonDocument.Parse(data);
-            if (doc.RootElement.TryGetProperty("title", out var titleEl)
-                && titleEl.ValueKind == System.Text.Json.JsonValueKind.String)
-            {
-                return titleEl.GetString();
-            }
-        }
-        catch
-        {
-            // Serialization may not be supported for this object type.
-        }
-
-        return null;
-    }
-
-    private static string Truncate(string text, int maxLength)
-        => text.Length <= maxLength ? text : string.Concat(text.AsSpan(0, maxLength - 1), "…");
-}

dotnet/samples/02-agents/Harness/Harness_Step01_Research/Program.cs

@@ -8,8 +8,7 @@
 //
 // Special commands:
 //   /todos  — Display the current todo list without invoking the agent.
-//   /mode   — Get or set the current agent mode.
-//   /exit   — End the session.
+//   exit    — End the session.
 
 #pragma warning disable OPENAI001 // Suppress experimental API warnings for Responses API usage.
 #pragma warning disable MAAI001  // Suppress experimental API warnings for Agents AI experiments.
@@ -17,7 +16,6 @@
 using System.ClientModel.Primitives;
 using Azure.Identity;
 using Harness.Shared.Console;
-using Harness.Shared.Console.ToolFormatters;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
 using OpenAI;
@@ -160,17 +158,13 @@ AIAgent agent =
 // Run the interactive console session using the shared HarnessConsole helper.
 await HarnessConsole.RunAgentAsync(
     agent,
+    title: "Research Assistant",
     userPrompt: "Enter a research topic to get started.",
     new HarnessConsoleOptions
     {
-        Observers = [
-            new OpenAIResponsesWebSearchDisplayObserver(),
-            .. HarnessConsoleOptions.BuildObserversWithPlanning(
-                agent,
-                planModeName: "plan",
-                executionModeName: "execute",
-                maxContextWindowTokens: MaxContextWindowTokens,
-                maxOutputTokens: MaxOutputTokens,
-                toolFormatters: [new DownloadUriToolFormatter(), .. ToolCallFormatter.BuildDefaultToolFormatters()])],
-        CommandHandlers = HarnessConsoleOptions.BuildDefaultCommandHandlers(agent),
+        MaxContextWindowTokens = MaxContextWindowTokens,
+        MaxOutputTokens = MaxOutputTokens,
+        EnablePlanningUx = true,
+        PlanningModeName = "plan",
+        ExecutionModeName = "execute"
     });

dotnet/samples/02-agents/Harness/Harness_Step02_Research_WithSubAgents/Program.cs

@@ -6,7 +6,7 @@
 // equipped with Foundry's hosted web search tool.
 //
 // Special commands:
-//   /exit    — End the session.
+//   exit    — End the session.
 
 #pragma warning disable OPENAI001 // Suppress experimental API warnings for Responses API usage.
 #pragma warning disable MAAI001  // Suppress experimental API warnings for Agents AI experiments.
@@ -103,4 +103,5 @@ AIAgent parentAgent =
 // Run the interactive console session.
 await HarnessConsole.RunAgentAsync(
     parentAgent,
+    title: "Stock Price Researcher (SubAgents Demo)",
     userPrompt: "Enter a list of stock tickers (e.g., BAC, MSFT, BA):");

dotnet/samples/02-agents/Harness/Harness_Step03_DataProcessing/Program.cs

@@ -8,7 +8,7 @@
 // Ask the agent to analyze the data, produce summaries, or create new output files.
 //
 // Special commands:
-//   /exit — End the session.
+//   exit — End the session.
 
 #pragma warning disable OPENAI001 // Suppress experimental API warnings for Responses API usage.
 #pragma warning disable MAAI001  // Suppress experimental API warnings for Agents AI experiments.
@@ -85,4 +85,5 @@ AIAgent agent =
 // Run the interactive console session.
 await HarnessConsole.RunAgentAsync(
     agent,
+    title: "Data Processing Assistant",
     userPrompt: "Ask me to analyze the data files, produce summaries, or create output files.");

dotnet/samples/03-workflows/Declarative/InvokeFoundryToolboxMcp/InvokeFoundryToolboxMcp.csproj

@@ -1,42 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFrameworks>net10.0</TargetFrameworks>
-    <Nullable>enable</Nullable>
-    <ImplicitUsings>enable</ImplicitUsings>
-  </PropertyGroup>
-
-  <PropertyGroup>
-    <InjectIsExternalInitOnLegacy>true</InjectIsExternalInitOnLegacy>
-    <InjectSharedFoundryAgents>true</InjectSharedFoundryAgents>
-    <InjectSharedWorkflowsExecution>true</InjectSharedWorkflowsExecution>
-    <InjectSharedWorkflowsSettings>true</InjectSharedWorkflowsSettings>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Azure.AI.Projects" />
-    <PackageReference Include="Microsoft.Extensions.Configuration" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Json" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.UserSecrets" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" />
-    <PackageReference Include="Microsoft.Extensions.Logging" />
-    <PackageReference Include="OpenAI" />
-    <PackageReference Include="System.ClientModel" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.Workflows.Declarative\Microsoft.Agents.AI.Workflows.Declarative.csproj" />
-    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.Workflows.Declarative.Foundry\Microsoft.Agents.AI.Workflows.Declarative.Foundry.csproj" />
-    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.Workflows.Declarative.Mcp\Microsoft.Agents.AI.Workflows.Declarative.Mcp.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Include="InvokeFoundryToolboxMcp.yaml">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-
-</Project>

dotnet/samples/03-workflows/Declarative/InvokeFoundryToolboxMcp/InvokeFoundryToolboxMcp.yaml

@@ -1,87 +0,0 @@
-#
-# This workflow demonstrates invoking MCP tools through a Foundry toolbox MCP proxy.
-#
-# The toolbox is provisioned with TWO different tool types:
-#   1. A Foundry built-in web_search tool
-#   2. A Microsoft Learn MCP server (microsoft_docs)
-# Both are surfaced through the same MCP-compatible toolbox endpoint.
-#
-# The workflow:
-# 1. Accepts a documentation/web search query as input
-# 2. Lists the tools exposed by the Foundry toolbox using reserved toolName: tools/list
-# 3. Invokes the microsoft_docs_search MCP tool
-# 4. Invokes the built-in web_search tool against the same toolbox endpoint
-# 5. Uses an agent to summarize and combine both result sets
-#
-# Example input:
-# How do I use Azure OpenAI with my data?
-#
-kind: Workflow
-trigger:
-
-  kind: OnConversationStart
-  id: workflow_invoke_foundry_toolbox_mcp
-  actions:
-
-    # Set the search query from user input.
-    - kind: SetVariable
-      id: set_search_query
-      variable: Local.SearchQuery
-      value: =System.LastMessage.Text
-
-    # List tools exposed by the Foundry toolbox MCP proxy.
-    - kind: InvokeMcpTool
-      id: list_toolbox_tools
-      serverUrl: =Env.FOUNDRY_TOOLBOX_MCP_SERVER_URL
-      serverLabel: foundry_toolbox
-      toolName: tools/list
-      conversationId: =System.ConversationId
-      headers:
-        Foundry-Features: Toolboxes=V1Preview
-      output:
-        autoSend: true
-        result: Local.ToolboxTools
-
-    # Invoke a specific tool exposed through the toolbox and add the result to the conversation.
-    - kind: InvokeMcpTool
-      id: search_docs_with_toolbox
-      serverUrl: =Env.FOUNDRY_TOOLBOX_MCP_SERVER_URL
-      serverLabel: foundry_toolbox
-      toolName: =Env.FOUNDRY_TOOLBOX_DOCS_SERVER_LABEL & "___microsoft_docs_search"
-      conversationId: =System.ConversationId
-      headers:
-        Foundry-Features: Toolboxes=V1Preview
-      arguments:
-        query: =Local.SearchQuery
-      output:
-        autoSend: true
-        result: Local.SearchResult
-
-    # Invoke the web_search built-in tool through the same toolbox proxy. The toolbox surfaces
-    # built-in Foundry tools (like web_search) alongside MCP tools through one MCP-compatible
-    # endpoint. Note that web_search expects argument 'search_query' (not 'query').
-    - kind: InvokeMcpTool
-      id: search_web_with_toolbox
-      serverUrl: =Env.FOUNDRY_TOOLBOX_MCP_SERVER_URL
-      serverLabel: foundry_toolbox
-      toolName: =Env.FOUNDRY_TOOLBOX_WEB_SEARCH_TOOL_NAME
-      conversationId: =System.ConversationId
-      headers:
-        Foundry-Features: Toolboxes=V1Preview
-      arguments:
-        search_query: =Local.SearchQuery
-      output:
-        autoSend: true
-        result: Local.WebSearchResult
-
-    # Use the agent to summarize what happened and answer from the toolbox result.
-    - kind: InvokeAzureAgent
-      id: summarize_toolbox_result
-      agent:
-        name: FoundryToolboxMcpAgent
-      conversationId: =System.ConversationId
-      input:
-        messages: =UserMessage("Combine the Microsoft Learn docs results and the Foundry web search results in the conversation to answer the query " & Local.SearchQuery)
-      output:
-        autoSend: true
-        messages: Local.Summary

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

@@ -1,218 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-// This sample demonstrates using InvokeMcpTool to call MCP tools through a Foundry toolbox.
-// It creates a sample toolbox that exposes Microsoft Learn MCP tools, lists the toolbox tools
-// through the reserved tools/list operation, then calls microsoft_docs_search from the workflow.
-
-using System.ClientModel;
-using System.ClientModel.Primitives;
-using System.Collections.Concurrent;
-using System.Net.Http.Headers;
-using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
-using Azure.Core;
-using Azure.Identity;
-using Microsoft.Agents.AI.Workflows.Declarative.Mcp;
-using Microsoft.Extensions.Configuration;
-using OpenAI.Responses;
-using Shared.Foundry;
-using Shared.Workflows;
-
-#pragma warning disable OPENAI001 // Experimental API
-#pragma warning disable AAIP001 // AgentToolboxes is experimental
-
-namespace Demo.Workflows.Declarative.InvokeFoundryToolboxMcp;
-
-/// <summary>
-/// Demonstrates a workflow that uses InvokeMcpTool to call MCP tools exposed through a Foundry toolbox.
-/// </summary>
-/// <remarks>
-/// This sample provisions a toolbox with Microsoft Learn MCP tools, uses the reserved
-/// <c>tools/list</c> tool name to list the toolbox tools, calls one specific toolbox tool,
-/// and has a Foundry agent summarize the results.
-/// </remarks>
-internal sealed class Program
-{
-    private const string ToolboxNameSetting = "FOUNDRY_TOOLBOX_NAME";
-    private const string ToolboxApiVersionSetting = "FOUNDRY_AGENT_TOOLSET_API_VERSION";
-    private const string ToolboxMcpServerUrlSetting = "FOUNDRY_TOOLBOX_MCP_SERVER_URL";
-    private const string DocsServerLabelSetting = "FOUNDRY_TOOLBOX_DOCS_SERVER_LABEL";
-    private const string WebSearchToolNameSetting = "FOUNDRY_TOOLBOX_WEB_SEARCH_TOOL_NAME";
-    private const string DefaultToolboxName = "declarative_foundry_toolbox_mcp";
-    private const string DefaultToolboxApiVersion = "v1";
-    private const string DefaultDocsServerLabel = "microsoft_docs";
-    private const string DefaultWebSearchToolName = "web_search";
-
-    public static async Task Main(string[] args)
-    {
-        // Initialize configuration
-        IConfiguration configuration = Application.InitializeConfig();
-        Uri foundryEndpoint = new(configuration.GetValue(Application.Settings.FoundryEndpoint));
-        string toolboxName = configuration[ToolboxNameSetting] ?? DefaultToolboxName;
-        string toolboxApiVersion = configuration[ToolboxApiVersionSetting] ?? DefaultToolboxApiVersion;
-        string docsServerLabel = configuration[DocsServerLabelSetting] ?? DefaultDocsServerLabel;
-        string webSearchToolName = configuration[WebSearchToolNameSetting] ?? DefaultWebSearchToolName;
-
-        // 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();
-
-        // Ensure sample toolbox and agent exist in Foundry
-        string toolboxEndpoint = await CreateSampleToolboxAsync(toolboxName, docsServerLabel, foundryEndpoint, credential);
-        string toolboxMcpServerUrl = BuildToolboxMcpServerUrl(toolboxEndpoint, toolboxName, toolboxApiVersion);
-        IConfiguration workflowConfiguration = new ConfigurationBuilder()
-            .AddConfiguration(configuration)
-            .AddInMemoryCollection(new Dictionary<string, string?>
-            {
-                [ToolboxMcpServerUrlSetting] = toolboxMcpServerUrl,
-                [DocsServerLabelSetting] = docsServerLabel,
-                [WebSearchToolNameSetting] = webSearchToolName,
-            })
-            .Build();
-
-        await CreateAgentAsync(foundryEndpoint, configuration, credential);
-
-        // Get input from command line or console
-        string workflowInput = Application.GetInput(args);
-
-        // Create the MCP tool handler for invoking the Foundry toolbox MCP proxy.
-        ConcurrentBag<HttpClient> createdHttpClients = [];
-        DefaultMcpToolHandler mcpToolHandler = new(
-            httpClientProvider: async (serverUrl, _) =>
-            {
-                await Task.CompletedTask.ConfigureAwait(false);
-
-                if (!string.Equals(serverUrl, toolboxMcpServerUrl, StringComparison.OrdinalIgnoreCase))
-                {
-                    return null;
-                }
-
-                FoundryToolboxBearerTokenHandler handler = new(credential)
-                {
-                    InnerHandler = new HttpClientHandler()
-                };
-                HttpClient httpClient = new(handler);
-                createdHttpClients.Add(httpClient);
-                return httpClient;
-            });
-
-        try
-        {
-            // Create the workflow factory with MCP tool provider
-            WorkflowFactory workflowFactory = new("InvokeFoundryToolboxMcp.yaml", foundryEndpoint)
-            {
-                Configuration = workflowConfiguration,
-                McpToolHandler = mcpToolHandler
-            };
-
-            // Execute the workflow
-            WorkflowRunner runner = new() { UseJsonCheckpoints = true };
-            await runner.ExecuteAsync(workflowFactory.CreateWorkflow, workflowInput);
-        }
-        finally
-        {
-            // Clean up connections and dispose created HttpClients
-            await mcpToolHandler.DisposeAsync();
-
-            foreach (HttpClient httpClient in createdHttpClients)
-            {
-                httpClient.Dispose();
-            }
-        }
-    }
-
-    private static async Task CreateAgentAsync(Uri foundryEndpoint, IConfiguration configuration, TokenCredential credential)
-    {
-        AIProjectClient aiProjectClient = new(foundryEndpoint, credential);
-
-        await aiProjectClient.CreateAgentAsync(
-            agentName: "FoundryToolboxMcpAgent",
-            agentDefinition: DefineToolboxAgent(configuration),
-            agentDescription: "Summarizes Foundry toolbox MCP tool results");
-    }
-
-    private static DeclarativeAgentDefinition DefineToolboxAgent(IConfiguration configuration)
-    {
-        return new DeclarativeAgentDefinition(configuration.GetValue(Application.Settings.FoundryModel))
-        {
-            Instructions =
-                """
-                You are a helpful assistant that explains results produced by tools exposed through a Foundry toolbox.
-                The conversation history contains output from BOTH a Microsoft Learn documentation search (MCP) and a Foundry web search.
-                Synthesize an answer that draws on both sources, calls out where they agree or differ, and notes which toolbox tool produced each fact when it is relevant.
-                Be concise.
-                """
-        };
-    }
-
-    private static async Task<string> CreateSampleToolboxAsync(string name, string serverLabel, Uri foundryEndpoint, TokenCredential credential)
-    {
-        AgentAdministrationClientOptions options = new();
-        options.AddPolicy(new FoundryFeaturesPolicy("Toolboxes=V1Preview"), PipelinePosition.PerCall);
-        AgentAdministrationClient adminClient = new(foundryEndpoint, credential, options);
-        AgentToolboxes toolboxClient = adminClient.GetAgentToolboxes();
-
-        try
-        {
-            await toolboxClient.DeleteToolboxAsync(name);
-            Console.WriteLine($"Deleted existing toolbox '{name}'");
-        }
-        catch (ClientResultException ex) when (ex.Status == 404)
-        {
-            // Toolbox does not exist.
-        }
-
-        ProjectsAgentTool webTool = ProjectsAgentTool.AsProjectTool(ResponseTool.CreateWebSearchTool());
-
-        ProjectsAgentTool mcpTool = ProjectsAgentTool.AsProjectTool(ResponseTool.CreateMcpTool(
-            serverLabel: serverLabel,
-            serverUri: new Uri("https://learn.microsoft.com/api/mcp"),
-            toolCallApprovalPolicy: new McpToolCallApprovalPolicy(GlobalMcpToolCallApprovalPolicy.NeverRequireApproval)));
-
-        ToolboxVersion created = (await toolboxClient.CreateToolboxVersionAsync(
-            name: name,
-            tools: [webTool, mcpTool],
-            description: "Sample toolbox combining Foundry web search with the Microsoft Learn MCP tools for the declarative InvokeFoundryToolboxMcp sample.")).Value;
-
-        Console.WriteLine($"Created toolbox '{created.Name}' v{created.Version} ({created.Tools.Count} tool(s))");
-
-        return $"{foundryEndpoint.ToString().TrimEnd('/')}/toolboxes";
-    }
-
-    private static string BuildToolboxMcpServerUrl(string toolboxEndpoint, string toolboxName, string apiVersion) =>
-        $"{toolboxEndpoint.TrimEnd('/')}/{toolboxName}/mcp?api-version={Uri.EscapeDataString(apiVersion)}";
-
-    private sealed class FoundryToolboxBearerTokenHandler(TokenCredential credential) : DelegatingHandler
-    {
-        private static readonly TokenRequestContext s_tokenContext =
-            new(["https://ai.azure.com/.default"]);
-
-        protected override async Task<HttpResponseMessage> SendAsync(
-            HttpRequestMessage request,
-            CancellationToken cancellationToken)
-        {
-            AccessToken token = await credential.GetTokenAsync(s_tokenContext, cancellationToken);
-            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token.Token);
-
-            return await base.SendAsync(request, cancellationToken);
-        }
-    }
-
-    private sealed class FoundryFeaturesPolicy(string feature) : PipelinePolicy
-    {
-        private const string FeatureHeader = "Foundry-Features";
-
-        public override void Process(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
-        {
-            message.Request.Headers.Add(FeatureHeader, feature);
-            ProcessNext(message, pipeline, currentIndex);
-        }
-
-        public override ValueTask ProcessAsync(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
-        {
-            message.Request.Headers.Add(FeatureHeader, feature);
-            return ProcessNextAsync(message, pipeline, currentIndex);
-        }
-    }
-}

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-ChatClientAgent/HostedChatClientAgent.csproj

@@ -18,7 +18,6 @@
   <ItemGroup>
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry\Microsoft.Agents.AI.Foundry.csproj" />
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry.Hosting\Microsoft.Agents.AI.Foundry.Hosting.csproj" />
-    <ProjectReference Include="..\Hosted_Shared_Contributor_Setup\Hosted_Shared_Contributor_Setup.csproj" />
   </ItemGroup>
 
   <!-- For end-users: uncomment the PackageReference below and remove the ProjectReference above

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-ChatClientAgent/Program.cs

@@ -4,7 +4,6 @@ using Azure.AI.Projects;
 using Azure.Core;
 using Azure.Identity;
 using DotNetEnv;
-using Hosted_Shared_Contributor_Setup;
 using Microsoft.Agents.AI;
 using Microsoft.Agents.AI.Foundry.Hosting;
 
@@ -41,7 +40,6 @@ AIAgent agent = new AIProjectClient(projectEndpoint, credential)
 // Host the agent as a Foundry Hosted Agent using the Responses API.
 var builder = WebApplication.CreateBuilder(args);
 builder.Services.AddFoundryResponses(agent);
-builder.Services.AddDevTemporaryLocalContributorSetup(); // Local Docker debugging only - must not be used in production.
 
 var app = builder.Build();
 app.MapFoundryResponses();
@@ -53,3 +51,48 @@ if (app.Environment.IsDevelopment())
 }
 
 app.Run();
+
+/// <summary>
+/// A <see cref="TokenCredential"/> for local Docker debugging only.
+///
+/// When debugging and testing a hosted agent in a local Docker container, Azure CLI
+/// and other interactive credentials are not available. This credential reads a
+/// pre-fetched bearer token from the <c>AZURE_BEARER_TOKEN</c> environment variable.
+///
+/// This should NOT be used in production — tokens expire (~1 hour) and cannot be refreshed.
+/// In production, the Foundry platform injects a managed identity automatically.
+///
+/// Generate a token on your host and pass it to the container:
+///   export AZURE_BEARER_TOKEN=$(az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv)
+///   docker run -e AZURE_BEARER_TOKEN=$AZURE_BEARER_TOKEN ...
+/// </summary>
+internal sealed class DevTemporaryTokenCredential : TokenCredential
+{
+    private const string EnvironmentVariable = "AZURE_BEARER_TOKEN";
+    private readonly string? _token;
+
+    public DevTemporaryTokenCredential()
+    {
+        this._token = Environment.GetEnvironmentVariable(EnvironmentVariable);
+    }
+
+    public override AccessToken GetToken(TokenRequestContext requestContext, CancellationToken cancellationToken)
+    {
+        return this.GetAccessToken();
+    }
+
+    public override ValueTask<AccessToken> GetTokenAsync(TokenRequestContext requestContext, CancellationToken cancellationToken)
+    {
+        return new ValueTask<AccessToken>(this.GetAccessToken());
+    }
+
+    private AccessToken GetAccessToken()
+    {
+        if (string.IsNullOrEmpty(this._token) || this._token == "DefaultAzureCredential")
+        {
+            throw new CredentialUnavailableException($"{EnvironmentVariable} environment variable is not set.");
+        }
+
+        return new AccessToken(this._token, DateTimeOffset.UtcNow.AddHours(1));
+    }
+}

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-FoundryAgent/HostedFoundryAgent.csproj

@@ -18,7 +18,6 @@
   <ItemGroup>
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry\Microsoft.Agents.AI.Foundry.csproj" />
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry.Hosting\Microsoft.Agents.AI.Foundry.Hosting.csproj" />
-    <ProjectReference Include="..\Hosted_Shared_Contributor_Setup\Hosted_Shared_Contributor_Setup.csproj" />
   </ItemGroup>
 
   <!-- For end-users: uncomment the PackageReference below and remove the ProjectReference above

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-FoundryAgent/Program.cs

@@ -5,7 +5,6 @@ using Azure.AI.Projects.Agents;
 using Azure.Core;
 using Azure.Identity;
 using DotNetEnv;
-using Hosted_Shared_Contributor_Setup;
 using Microsoft.Agents.AI.Foundry;
 using Microsoft.Agents.AI.Foundry.Hosting;
 
@@ -34,7 +33,6 @@ FoundryAgent agent = aiProjectClient.AsAIAgent(agentRecord);
 // Host the agent as a Foundry Hosted Agent using the Responses API.
 var builder = WebApplication.CreateBuilder(args);
 builder.Services.AddFoundryResponses(agent);
-builder.Services.AddDevTemporaryLocalContributorSetup(); // Local Docker debugging only - must not be used in production.
 
 var app = builder.Build();
 app.MapFoundryResponses();
@@ -46,3 +44,48 @@ if (app.Environment.IsDevelopment())
 }
 
 app.Run();
+
+/// <summary>
+/// A <see cref="TokenCredential"/> for local Docker debugging only.
+///
+/// When debugging and testing a hosted agent in a local Docker container, Azure CLI
+/// and other interactive credentials are not available. This credential reads a
+/// pre-fetched bearer token from the <c>AZURE_BEARER_TOKEN</c> environment variable.
+///
+/// This should NOT be used in production — tokens expire (~1 hour) and cannot be refreshed.
+/// In production, the Foundry platform injects a managed identity automatically.
+///
+/// Generate a token on your host and pass it to the container:
+///   export AZURE_BEARER_TOKEN=$(az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv)
+///   docker run -e AZURE_BEARER_TOKEN=$AZURE_BEARER_TOKEN ...
+/// </summary>
+internal sealed class DevTemporaryTokenCredential : TokenCredential
+{
+    private const string EnvironmentVariable = "AZURE_BEARER_TOKEN";
+    private readonly string? _token;
+
+    public DevTemporaryTokenCredential()
+    {
+        this._token = Environment.GetEnvironmentVariable(EnvironmentVariable);
+    }
+
+    public override AccessToken GetToken(TokenRequestContext requestContext, CancellationToken cancellationToken)
+    {
+        return this.GetAccessToken();
+    }
+
+    public override ValueTask<AccessToken> GetTokenAsync(TokenRequestContext requestContext, CancellationToken cancellationToken)
+    {
+        return new ValueTask<AccessToken>(this.GetAccessToken());
+    }
+
+    private AccessToken GetAccessToken()
+    {
+        if (string.IsNullOrEmpty(this._token) || this._token == "DefaultAzureCredential")
+        {
+            throw new CredentialUnavailableException($"{EnvironmentVariable} environment variable is not set.");
+        }
+
+        return new AccessToken(this._token, DateTimeOffset.UtcNow.AddHours(1));
+    }
+}

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-LocalTools/HostedLocalTools.csproj

@@ -20,7 +20,6 @@
   <ItemGroup>
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry\Microsoft.Agents.AI.Foundry.csproj" />
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry.Hosting\Microsoft.Agents.AI.Foundry.Hosting.csproj" />
-    <ProjectReference Include="..\Hosted_Shared_Contributor_Setup\Hosted_Shared_Contributor_Setup.csproj" />
   </ItemGroup>
 
   <!-- For end-users: uncomment the PackageReference below and remove the ProjectReference above

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-LocalTools/Program.cs

@@ -11,7 +11,6 @@ using Azure.AI.Projects;
 using Azure.Core;
 using Azure.Identity;
 using DotNetEnv;
-using Hosted_Shared_Contributor_Setup;
 using Microsoft.Agents.AI;
 using Microsoft.Agents.AI.Foundry.Hosting;
 using Microsoft.Extensions.AI;
@@ -113,7 +112,6 @@ AIAgent agent = new AIProjectClient(new Uri(endpoint), credential)
 
 var builder = WebApplication.CreateBuilder(args);
 builder.Services.AddFoundryResponses(agent);
-builder.Services.AddDevTemporaryLocalContributorSetup(); // Local Docker debugging only - must not be used in production.
 
 var app = builder.Build();
 app.MapFoundryResponses();
@@ -128,3 +126,39 @@ app.Run();
 // ── Types ────────────────────────────────────────────────────────────────────
 
 internal sealed record Hotel(string Name, int PricePerNight, double Rating, string Location);
+
+/// <summary>
+/// A <see cref="TokenCredential"/> for local Docker debugging only.
+/// Reads a pre-fetched bearer token from the <c>AZURE_BEARER_TOKEN</c> environment variable
+/// once at startup. This should NOT be used in production.
+///
+/// Generate a token on your host and pass it to the container:
+///   export AZURE_BEARER_TOKEN=$(az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv)
+///   docker run -e AZURE_BEARER_TOKEN=$AZURE_BEARER_TOKEN ...
+/// </summary>
+internal sealed class DevTemporaryTokenCredential : TokenCredential
+{
+    private const string EnvironmentVariable = "AZURE_BEARER_TOKEN";
+    private readonly string? _token;
+
+    public DevTemporaryTokenCredential()
+    {
+        this._token = Environment.GetEnvironmentVariable(EnvironmentVariable);
+    }
+
+    public override AccessToken GetToken(TokenRequestContext requestContext, CancellationToken cancellationToken)
+        => this.GetAccessToken();
+
+    public override ValueTask<AccessToken> GetTokenAsync(TokenRequestContext requestContext, CancellationToken cancellationToken)
+        => new(this.GetAccessToken());
+
+    private AccessToken GetAccessToken()
+    {
+        if (string.IsNullOrEmpty(this._token) || this._token == "DefaultAzureCredential")
+        {
+            throw new CredentialUnavailableException($"{EnvironmentVariable} environment variable is not set.");
+        }
+
+        return new AccessToken(this._token, DateTimeOffset.UtcNow.AddHours(1));
+    }
+}

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-McpTools/HostedMcpTools.csproj

@@ -21,7 +21,6 @@
   <ItemGroup>
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry\Microsoft.Agents.AI.Foundry.csproj" />
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry.Hosting\Microsoft.Agents.AI.Foundry.Hosting.csproj" />
-    <ProjectReference Include="..\Hosted_Shared_Contributor_Setup\Hosted_Shared_Contributor_Setup.csproj" />
   </ItemGroup>
 
   <!-- For end-users: uncomment the PackageReference below and remove the ProjectReference above

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-McpTools/Program.cs

@@ -19,7 +19,6 @@ using Azure.AI.Projects;
 using Azure.Core;
 using Azure.Identity;
 using DotNetEnv;
-using Hosted_Shared_Contributor_Setup;
 using Microsoft.Agents.AI;
 using Microsoft.Agents.AI.Foundry.Hosting;
 using Microsoft.Extensions.AI;
@@ -82,7 +81,6 @@ AIAgent agent = new AIProjectClient(projectEndpoint, credential)
 // Host the agent as a Foundry Hosted Agent using the Responses API.
 var builder = WebApplication.CreateBuilder(args);
 builder.Services.AddFoundryResponses(agent);
-builder.Services.AddDevTemporaryLocalContributorSetup(); // Local Docker debugging only - must not be used in production.
 
 var app = builder.Build();
 app.MapFoundryResponses();
@@ -94,3 +92,39 @@ if (app.Environment.IsDevelopment())
 }
 
 app.Run();
+
+/// <summary>
+/// A <see cref="TokenCredential"/> for local Docker debugging only.
+/// Reads a pre-fetched bearer token from the <c>AZURE_BEARER_TOKEN</c> environment variable
+/// once at startup. This should NOT be used in production.
+///
+/// Generate a token on your host and pass it to the container:
+///   export AZURE_BEARER_TOKEN=$(az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv)
+///   docker run -e AZURE_BEARER_TOKEN=$AZURE_BEARER_TOKEN ...
+/// </summary>
+internal sealed class DevTemporaryTokenCredential : TokenCredential
+{
+    private const string EnvironmentVariable = "AZURE_BEARER_TOKEN";
+    private readonly string? _token;
+
+    public DevTemporaryTokenCredential()
+    {
+        this._token = Environment.GetEnvironmentVariable(EnvironmentVariable);
+    }
+
+    public override AccessToken GetToken(TokenRequestContext requestContext, CancellationToken cancellationToken)
+        => this.GetAccessToken();
+
+    public override ValueTask<AccessToken> GetTokenAsync(TokenRequestContext requestContext, CancellationToken cancellationToken)
+        => new(this.GetAccessToken());
+
+    private AccessToken GetAccessToken()
+    {
+        if (string.IsNullOrEmpty(this._token) || this._token == "DefaultAzureCredential")
+        {
+            throw new CredentialUnavailableException($"{EnvironmentVariable} environment variable is not set.");
+        }
+
+        return new AccessToken(this._token, DateTimeOffset.UtcNow.AddHours(1));
+    }
+}

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-MemoryAgent/.env.example

@@ -1,12 +0,0 @@
-AZURE_AI_PROJECT_ENDPOINT=<your-azure-ai-project-endpoint>
-ASPNETCORE_URLS=http://+:8088
-ASPNETCORE_ENVIRONMENT=Development
-AZURE_AI_MODEL_DEPLOYMENT_NAME=gpt-4o
-AZURE_AI_EMBEDDING_DEPLOYMENT_NAME=text-embedding-ada-002
-AZURE_AI_MEMORY_STORE_ID=hosted-memory-sample
-AGENT_NAME=hosted-memory-agent
-AZURE_BEARER_TOKEN=DefaultAzureCredential
-# When running outside the Foundry platform the platform-injected isolation keys are absent.
-# These two variables provide fallback values for local Docker debugging only.
-HOSTED_USER_ISOLATION_KEY=local-dev-user
-HOSTED_CHAT_ISOLATION_KEY=local-dev-chat

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-MemoryAgent/Dockerfile

@@ -1,26 +0,0 @@
-# Dockerfile for end-users consuming the Agent Framework via NuGet packages.
-#
-# This Dockerfile performs a full `dotnet restore` and `dotnet publish` inside the container,
-# which only succeeds when the project references its dependencies via PackageReference (see the
-# commented-out section in HostedMemoryAgent.csproj). Contributors building from the
-# agent-framework repository source must use Dockerfile.contributor instead because
-# ProjectReference dependencies live outside this folder and cannot be restored from inside
-# this build context.
-#
-# Use the official .NET 10.0 ASP.NET runtime as a parent image
-FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS base
-WORKDIR /app
-
-FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
-WORKDIR /src
-COPY . .
-RUN dotnet restore
-RUN dotnet publish -c Release -o /app/publish
-
-# Final stage
-FROM base AS final
-WORKDIR /app
-COPY --from=build /app/publish .
-EXPOSE 8088
-ENV ASPNETCORE_URLS=http://+:8088
-ENTRYPOINT ["dotnet", "HostedMemoryAgent.dll"]

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-MemoryAgent/Dockerfile.contributor

@@ -1,23 +0,0 @@
-# Dockerfile for contributors building from the agent-framework repository source.
-#
-# This project uses ProjectReference to the local Microsoft.Agents.AI.Foundry source,
-# which means a standard multi-stage Docker build cannot resolve dependencies outside
-# this folder. Instead, pre-publish the app targeting the container runtime and copy
-# the output into the container:
-#
-#   dotnet publish -c Debug -f net10.0 -r linux-musl-x64 --self-contained false -o out
-#   docker build -f Dockerfile.contributor -t hosted-memory-agent .
-#   docker run --rm -p 8088:8088 \
-#     -e AGENT_NAME=hosted-memory-agent \
-#     -e HOSTED_USER_ISOLATION_KEY=alice \
-#     -e HOSTED_CHAT_ISOLATION_KEY=alice-chat-1 \
-#     --env-file .env hosted-memory-agent
-#
-# For end-users consuming the NuGet package (not ProjectReference), use the standard
-# Dockerfile which performs a full dotnet restore + publish inside the container.
-FROM mcr.microsoft.com/dotnet/aspnet:10.0-alpine AS final
-WORKDIR /app
-COPY out/ .
-EXPOSE 8088
-ENV ASPNETCORE_URLS=http://+:8088
-ENTRYPOINT ["dotnet", "HostedMemoryAgent.dll"]

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-MemoryAgent/HostedMemoryAgent.csproj

@@ -1,33 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
-
-  <PropertyGroup>
-    <TargetFrameworks>net10.0</TargetFrameworks>
-    <Nullable>enable</Nullable>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <CentralPackageTransitivePinningEnabled>false</CentralPackageTransitivePinningEnabled>
-    <RootNamespace>HostedMemoryAgent</RootNamespace>
-    <AssemblyName>HostedMemoryAgent</AssemblyName>
-    <NoWarn>$(NoWarn);MEAI001;OPENAI001</NoWarn>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Azure.AI.Projects" VersionOverride="2.1.0-beta.1" />
-    <PackageReference Include="Azure.Identity" />
-    <PackageReference Include="DotNetEnv" />
-  </ItemGroup>
-
-  <!-- For contributors: uses ProjectReference to build against local source -->
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry\Microsoft.Agents.AI.Foundry.csproj" />
-    <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry.Hosting\Microsoft.Agents.AI.Foundry.Hosting.csproj" />
-    <ProjectReference Include="..\Hosted_Shared_Contributor_Setup\Hosted_Shared_Contributor_Setup.csproj" />
-  </ItemGroup>
-
-  <!-- For end-users: uncomment the PackageReference below and remove the ProjectReferences above
-  <ItemGroup>
-    <PackageReference Include="Microsoft.Agents.AI.Foundry" Version="1.0.0" />
-    <PackageReference Include="Microsoft.Agents.AI.Foundry.Hosting" Version="1.0.0" />
-  </ItemGroup>
-  -->
-
-</Project>

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-MemoryAgent/Program.cs

@@ -1,88 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-// Hosted-MemoryAgent
-//
-// Demonstrates how to host an agent that uses FoundryMemoryProvider so that user-private memories
-// persist across requests and across sessions, scoped per user via the Foundry platform's
-// isolation key headers.
-//
-// Memory scope flows from request -> hosting layer -> session -> provider:
-//   1. Foundry sets x-agent-user-isolation-key on every inbound request.
-//   2. AgentFrameworkResponseHandler reads context.Isolation.UserIsolationKey via the registered
-//      HostedSessionIsolationKeyProvider and stores it on the session as a HostedSessionContext.
-//   3. FoundryMemoryProvider's stateInitializer reads HostedSessionContext.UserId and uses it as
-//      the FoundryMemoryProviderScope, partitioning memories per user.
-
-using Azure.AI.Projects;
-using Azure.Core;
-using Azure.Identity;
-using DotNetEnv;
-using Hosted_Shared_Contributor_Setup;
-using Microsoft.Agents.AI;
-using Microsoft.Agents.AI.Foundry;
-using Microsoft.Agents.AI.Foundry.Hosting;
-using Microsoft.Extensions.AI;
-
-// Load .env file if present (for local development).
-Env.TraversePath().Load();
-
-var projectEndpoint = new Uri(Environment.GetEnvironmentVariable("AZURE_AI_PROJECT_ENDPOINT")
-    ?? throw new InvalidOperationException("AZURE_AI_PROJECT_ENDPOINT is not set."));
-var agentName = Environment.GetEnvironmentVariable("AGENT_NAME")
-    ?? throw new InvalidOperationException("AGENT_NAME is not set.");
-var deployment = Environment.GetEnvironmentVariable("AZURE_AI_MODEL_DEPLOYMENT_NAME") ?? "gpt-4o";
-var embeddingDeployment = Environment.GetEnvironmentVariable("AZURE_AI_EMBEDDING_DEPLOYMENT_NAME") ?? "text-embedding-ada-002";
-var memoryStoreName = Environment.GetEnvironmentVariable("AZURE_AI_MEMORY_STORE_ID") ?? "hosted-memory-sample";
-
-// Use a chained credential: try a temporary dev token first (for local Docker debugging),
-// then fall back to DefaultAzureCredential (for local dev via dotnet run / managed identity in foundry).
-TokenCredential credential = new ChainedTokenCredential(
-    new DevTemporaryTokenCredential(),
-    new DefaultAzureCredential());
-
-AIProjectClient projectClient = new(projectEndpoint, credential);
-
-// FoundryMemoryProvider partitions memories per end user via a built-in HostedFoundryMemoryProviderScopes
-// helper that reads the platform-injected user isolation key from the HostedSessionContext that the
-// hosting layer placed on the session.
-FoundryMemoryProvider memoryProvider = new(
-    projectClient,
-    memoryStoreName,
-    stateInitializer: HostedFoundryMemoryProviderScopes.PerUser());
-
-// Provision the memory store on startup if it does not already exist. EnsureMemoryStoreCreatedAsync
-// is idempotent. Doing this once at start avoids per-request latency.
-await memoryProvider.EnsureMemoryStoreCreatedAsync(deployment, embeddingDeployment, "Memory store for the hosted travel-assistant sample.");
-
-const string AgentInstructions = """
-    You are a friendly travel assistant. When the user shares trip preferences, destinations,
-    travel companions, or constraints, remember them and use them in later turns. Use known
-    memories about the user when responding, and do not invent details.
-    """;
-
-ChatClientAgent agent = projectClient.AsAIAgent(new ChatClientAgentOptions()
-{
-    Name = agentName,
-    ChatOptions = new ChatOptions
-    {
-        ModelId = deployment,
-        Instructions = AgentInstructions
-    },
-    AIContextProviders = [memoryProvider]
-});
-
-// Host the agent as a Foundry Hosted Agent using the Responses API.
-var builder = WebApplication.CreateBuilder(args);
-builder.Services.AddFoundryResponses(agent);
-builder.Services.AddDevTemporaryLocalContributorSetup(); // Local Docker debugging only - must not be used in production.
-
-var app = builder.Build();
-app.MapFoundryResponses();
-
-// In Development, also map the OpenAI-compatible route that AIProjectClient uses.
-if (app.Environment.IsDevelopment())
-{
-    app.MapFoundryResponses("openai/v1");
-}
-
-app.Run();

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-MemoryAgent/README.md

@@ -1,155 +0,0 @@
-# Hosted-MemoryAgent
-
-A hosted Foundry agent that uses **FoundryMemoryProvider** to remember user-private details across
-requests and across sessions, scoped per end user via the Foundry platform's isolation keys. The
-agent plays a friendly travel assistant: tell it about your trip, ask follow-up questions in a new
-session, and it recalls what it learned about you.
-
-This sample exists to demonstrate two things together:
-
-1. How to host an agent that consumes a `Microsoft.Extensions.AI.AIContextProvider` (specifically
-   `FoundryMemoryProvider`) under the Foundry Responses hosting layer.
-2. How the new `HostedSessionContext` flows from the `Foundry` platform isolation headers
-   (`x-agent-user-isolation-key`, `x-agent-chat-isolation-key`) through the
-   `HostedSessionIsolationKeyProvider` into the provider's `stateInitializer`, so memories are
-   partitioned per user automatically.
-
-## Prerequisites
-
-- [.NET 10 SDK](https://dotnet.microsoft.com/download/dotnet/10.0)
-- An Azure AI Foundry project with at least one chat model deployment and one embedding model deployment
-- Azure CLI logged in (`az login`)
-
-## Configuration
-
-Copy the template and fill in your values:
-
-```bash
-cp .env.example .env
-```
-
-Required:
-
-```env
-AZURE_AI_PROJECT_ENDPOINT=https://<account>.services.ai.azure.com/api/projects/<project>
-AZURE_AI_MODEL_DEPLOYMENT_NAME=gpt-4o
-AZURE_AI_EMBEDDING_DEPLOYMENT_NAME=text-embedding-ada-002
-AZURE_AI_MEMORY_STORE_ID=hosted-memory-sample
-AGENT_NAME=hosted-memory-agent
-ASPNETCORE_URLS=http://+:8088
-ASPNETCORE_ENVIRONMENT=Development
-```
-
-For local container runs only (the platform supplies these in production):
-
-```env
-HOSTED_USER_ISOLATION_KEY=alice
-HOSTED_CHAT_ISOLATION_KEY=alice-chat-1
-```
-
-> `.env` is gitignored. The `.env.example` template is checked in as a reference.
-
-## How memory scoping works
-
-| Layer | Source of the user identity |
-|---|---|
-| Inbound request | The Foundry platform sets `x-agent-user-isolation-key` and `x-agent-chat-isolation-key` headers on every request. |
-| Hosting layer | `AgentFrameworkResponseHandler` resolves a `HostedSessionIsolationKeyProvider` from DI and calls `GetKeysAsync(context, request, ct)`. The default implementation reads `context.Isolation.UserIsolationKey` and `context.Isolation.ChatIsolationKey`. |
-| Session | The handler stores the resolved values on the session as a `HostedSessionContext` on the first request, and validates the values on every subsequent request that resumes the same conversation (mismatch returns 403). |
-| Memory provider | The sample's `stateInitializer` reads `session.GetHostedContext().UserId` and uses it as the `FoundryMemoryProviderScope`. Memories are partitioned per user. |
-
-When running outside the Foundry platform the headers are absent. The sample registers
-`DevTemporaryLocalSessionIsolationKeyProvider` (via `AddDevTemporaryLocalContributorSetup`) which
-falls back to the `HOSTED_USER_ISOLATION_KEY` and `HOSTED_CHAT_ISOLATION_KEY` environment variables,
-defaulting to a single `local-dev-*` bucket when neither is set.
-
-> **Production warning.** Never register `DevTemporaryLocalSessionIsolationKeyProvider` in
-> production. The Foundry platform sets the isolation keys for every inbound request, and
-> client-supplied environment variables can be forged.
-
-## Running directly (contributors)
-
-This project uses `ProjectReference` to build against the local Agent Framework source.
-
-```bash
-cd dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-MemoryAgent
-dotnet run
-```
-
-The agent starts on `http://localhost:8088`.
-
-### Test it
-
-```bash
-curl -X POST http://localhost:8088/responses \
-  -H "Content-Type: application/json" \
-  -d '{"input": "Hi! My name is Taylor and I am planning a hiking trip to Patagonia in November.", "model": "hosted-memory-agent"}'
-```
-
-Wait a few seconds for memory extraction, then ask a follow-up using the response id from the
-previous call as `previous_response_id`:
-
-```bash
-curl -X POST http://localhost:8088/responses \
-  -H "Content-Type: application/json" \
-  -d '{"input": "What do you already know about my upcoming trip?", "previous_response_id": "<id>", "model": "hosted-memory-agent"}'
-```
-
-## Running with Docker
-
-Since this project uses `ProjectReference`, the standard `Dockerfile` cannot resolve dependencies
-outside this folder. Use `Dockerfile.contributor` which takes a pre-published output.
-
-### 1. Publish for the container runtime (Linux Alpine)
-
-```bash
-dotnet publish -c Debug -f net10.0 -r linux-musl-x64 --self-contained false -o out
-```
-
-### 2. Build the Docker image
-
-```bash
-docker build -f Dockerfile.contributor -t hosted-memory-agent .
-```
-
-### 3. Run the container
-
-```bash
-export AZURE_BEARER_TOKEN=$(az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv)
-
-docker run --rm -p 8088:8088 \
-  -e AGENT_NAME=hosted-memory-agent \
-  -e AZURE_BEARER_TOKEN=$AZURE_BEARER_TOKEN \
-  -e HOSTED_USER_ISOLATION_KEY=alice \
-  -e HOSTED_CHAT_ISOLATION_KEY=alice-chat-1 \
-  --env-file .env \
-  hosted-memory-agent
-```
-
-### 4. Smoke test the running container
-
-A scripted smoke test that exercises memory recall and per-user isolation across two simulated
-users is provided at `scripts/smoke.ps1`. From the sample folder:
-
-```powershell
-pwsh ./scripts/smoke.ps1
-```
-
-The script publishes the project, builds the image, runs the container with two distinct
-`HOSTED_USER_ISOLATION_KEY` values, drives a multi-turn conversation per user, asserts that each
-user only sees their own memories, and exits non-zero on failure.
-
-## NuGet package users
-
-If you are consuming the Agent Framework as a NuGet package (not building from source), use the
-standard `Dockerfile` instead of `Dockerfile.contributor`. See the commented section in
-`HostedMemoryAgent.csproj` for the `PackageReference` alternative.
-
-## How it differs from sibling samples
-
-| | Hosted-ChatClientAgent | Hosted-MemoryAgent |
-|---|---|---|
-| **Agent definition** | Inline (`AsAIAgent(model, instructions)`) | Inline, plus `AIContextProviders = [memoryProvider]` |
-| **State** | None beyond the conversation history | Per-user memories persisted in Foundry Memory |
-| **Identity** | Not used | Required: `HostedSessionContext.UserId` flows into the memory scope |
-| **Local dev** | `AddDevTemporaryLocalContributorSetup()` keeps requests succeeding when isolation headers are absent | Same; additionally honours `HOSTED_USER_ISOLATION_KEY` to simulate distinct users |

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-MemoryAgent/agent.manifest.yaml

@@ -1,31 +0,0 @@
-# yaml-language-server: $schema=https://raw.githubusercontent.com/microsoft/AgentSchema/refs/heads/main/schemas/v1.0/AgentManifest.yaml
-name: hosted-memory-agent
-displayName: "Hosted Memory Agent"
-
-description: >
-  A travel-assistant hosted agent that uses FoundryMemoryProvider to remember user-private
-  preferences and details across sessions. Memory is scoped per end user via the Foundry
-  platform's isolation key headers.
-
-metadata:
-  tags:
-    - AI Agent Hosting
-    - Azure AI AgentServer
-    - Responses Protocol
-    - Streaming
-    - Agent Framework
-    - Memory
-    - Foundry Memory
-
-template:
-  name: hosted-memory-agent
-  kind: hosted
-  protocols:
-    - protocol: responses
-      version: 1.0.0
-  resources:
-    cpu: "0.25"
-    memory: 0.5Gi
-parameters:
-  properties: []
-resources: []

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-MemoryAgent/agent.yaml

@@ -1,9 +0,0 @@
-# yaml-language-server: $schema=https://raw.githubusercontent.com/microsoft/AgentSchema/refs/heads/main/schemas/v1.0/ContainerAgent.yaml
-kind: hosted
-name: hosted-memory-agent
-protocols:
-  - protocol: responses
-    version: 1.0.0
-resources:
-  cpu: "0.25"
-  memory: 0.5Gi

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-MemoryAgent/scripts/smoke.ps1

@@ -1,110 +0,0 @@
-#requires -Version 7
-<#
-.SYNOPSIS
-  Local smoke test for the Hosted-MemoryAgent sample.
-.DESCRIPTION
-  Publishes the sample, builds the contributor Docker image, runs the container twice with two
-  distinct HOSTED_USER_ISOLATION_KEY values, drives a multi-turn conversation per user via curl
-  invocations, and asserts that each user only sees their own remembered details.
-  Exits non-zero on failure.
-
-  Prerequisites:
-    - Docker
-    - az login (token is fetched from the host)
-    - .env populated with AZURE_AI_PROJECT_ENDPOINT and model deployments
-.NOTES
-  This script is for local Docker debugging only. The Foundry platform supplies the isolation
-  keys for every inbound request in production and the dev fallback used here must not be
-  enabled in production deployments.
-#>
-
-[CmdletBinding()]
-param(
-    [int]$Port = 8088,
-    [string]$ImageName = 'hosted-memory-agent-smoke',
-    [int]$RecallDelaySeconds = 25
-)
-
-$ErrorActionPreference = 'Stop'
-Set-Location -Path $PSScriptRoot/..
-
-if (-not (Test-Path .env)) {
-    throw '.env not found. Copy .env.example to .env and fill in AZURE_AI_PROJECT_ENDPOINT.'
-}
-
-Write-Host '==> Publishing sample for linux-musl-x64 ...'
-dotnet publish -c Debug -f net10.0 -r linux-musl-x64 --self-contained false -o out --tl:off | Out-Host
-if ($LASTEXITCODE -ne 0) { throw 'dotnet publish failed.' }
-
-Write-Host '==> Building docker image ...'
-docker build -f Dockerfile.contributor -t $ImageName . | Out-Host
-if ($LASTEXITCODE -ne 0) { throw 'docker build failed.' }
-
-Write-Host '==> Fetching bearer token ...'
-$bearer = az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv
-if (-not $bearer) { throw 'Failed to obtain bearer token. Run az login.' }
-
-function Start-Container([string]$UserKey, [string]$ChatKey, [string]$ContainerName) {
-    docker rm -f $ContainerName 2>$null | Out-Null
-    docker run -d --name $ContainerName -p ${Port}:8088 `
-        -e AGENT_NAME=hosted-memory-agent `
-        -e AZURE_BEARER_TOKEN=$bearer `
-        -e HOSTED_USER_ISOLATION_KEY=$UserKey `
-        -e HOSTED_CHAT_ISOLATION_KEY=$ChatKey `
-        --env-file .env `
-        $ImageName | Out-Host
-    if ($LASTEXITCODE -ne 0) { throw "docker run failed for $ContainerName." }
-    # Wait briefly for the listener to come up.
-    Start-Sleep -Seconds 6
-}
-
-function Invoke-Agent([string]$Prompt, [string]$PreviousResponseId = $null) {
-    $body = @{ input = $Prompt; model = 'hosted-memory-agent' }
-    if ($PreviousResponseId) { $body['previous_response_id'] = $PreviousResponseId }
-    $json = $body | ConvertTo-Json -Compress
-    $resp = Invoke-RestMethod -Method Post -Uri "http://localhost:$Port/responses" -ContentType 'application/json' -Body $json
-    return $resp
-}
-
-function Assert-Contains([string]$Haystack, [string]$Needle, [string]$Label) {
-    if ($Haystack -notmatch [regex]::Escape($Needle)) {
-        throw "FAILED [$Label]: expected response to contain '$Needle' but got: $Haystack"
-    }
-    Write-Host "PASS  [$Label]: response contains '$Needle'."
-}
-
-function Assert-NotContains([string]$Haystack, [string]$Needle, [string]$Label) {
-    if ($Haystack -match [regex]::Escape($Needle)) {
-        throw "FAILED [$Label]: response unexpectedly contains '$Needle': $Haystack"
-    }
-    Write-Host "PASS  [$Label]: response does not contain '$Needle'."
-}
-
-try {
-    Write-Host '==> Phase 1: alice teaches the agent her trip details ...'
-    Start-Container -UserKey 'alice' -ChatKey 'alice-chat-1' -ContainerName 'hosted-memory-smoke-alice'
-    $r1 = Invoke-Agent -Prompt 'Hi! My name is Taylor and I am planning a hiking trip to Patagonia in November.'
-    $r2 = Invoke-Agent -Prompt 'I am travelling with my sister and we love finding scenic viewpoints.' -PreviousResponseId $r1.id
-
-    Write-Host "==> Waiting $RecallDelaySeconds s for memory extraction ..."
-    Start-Sleep -Seconds $RecallDelaySeconds
-
-    $r3 = Invoke-Agent -Prompt 'What do you already know about my upcoming trip?' -PreviousResponseId $r2.id
-    $aliceText = ($r3.output | ForEach-Object { $_.content | ForEach-Object { $_.text } }) -join ' '
-    Assert-Contains $aliceText 'Patagonia' 'alice recall: Patagonia'
-
-    docker rm -f hosted-memory-smoke-alice | Out-Null
-
-    Write-Host '==> Phase 2: bob starts a fresh container with a different user isolation key ...'
-    Start-Container -UserKey 'bob' -ChatKey 'bob-chat-1' -ContainerName 'hosted-memory-smoke-bob'
-    $b1 = Invoke-Agent -Prompt 'Hello, what trip am I planning?'
-    $bobText = ($b1.output | ForEach-Object { $_.content | ForEach-Object { $_.text } }) -join ' '
-    Assert-NotContains $bobText 'Patagonia' 'bob isolation: no leak of alice memories'
-
-    Write-Host ''
-    Write-Host '==> All smoke assertions passed.'
-}
-finally {
-    docker rm -f hosted-memory-smoke-alice 2>$null | Out-Null
-    docker rm -f hosted-memory-smoke-bob 2>$null | Out-Null
-}

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-Observability/HostedObservability.csproj

@@ -20,7 +20,6 @@
   <ItemGroup>
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry\Microsoft.Agents.AI.Foundry.csproj" />
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry.Hosting\Microsoft.Agents.AI.Foundry.Hosting.csproj" />
-    <ProjectReference Include="..\Hosted_Shared_Contributor_Setup\Hosted_Shared_Contributor_Setup.csproj" />
   </ItemGroup>
 
   <!-- For end-users: uncomment the PackageReference below and remove the ProjectReference above

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-Observability/Program.cs

@@ -10,7 +10,6 @@ using Azure.AI.Projects;
 using Azure.Core;
 using Azure.Identity;
 using DotNetEnv;
-using Hosted_Shared_Contributor_Setup;
 using Microsoft.Agents.AI;
 using Microsoft.Agents.AI.Foundry.Hosting;
 using Microsoft.Extensions.AI;
@@ -61,7 +60,6 @@ AIAgent agent = new AIProjectClient(new Uri(endpoint), credential)
 
 var builder = WebApplication.CreateBuilder(args);
 builder.Services.AddFoundryResponses(agent);
-builder.Services.AddDevTemporaryLocalContributorSetup(); // Local Docker debugging only - must not be used in production.
 
 var app = builder.Build();
 app.MapFoundryResponses();
@@ -72,3 +70,39 @@ if (app.Environment.IsDevelopment())
 }
 
 app.Run();
+
+/// <summary>
+/// A <see cref="TokenCredential"/> for local Docker debugging only.
+/// Reads a pre-fetched bearer token from the <c>AZURE_BEARER_TOKEN</c> environment variable
+/// once at startup. This should NOT be used in production.
+///
+/// Generate a token on your host and pass it to the container:
+///   export AZURE_BEARER_TOKEN=$(az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv)
+///   docker run -e AZURE_BEARER_TOKEN=$AZURE_BEARER_TOKEN ...
+/// </summary>
+internal sealed class DevTemporaryTokenCredential : TokenCredential
+{
+    private const string EnvironmentVariable = "AZURE_BEARER_TOKEN";
+    private readonly string? _token;
+
+    public DevTemporaryTokenCredential()
+    {
+        this._token = Environment.GetEnvironmentVariable(EnvironmentVariable);
+    }
+
+    public override AccessToken GetToken(TokenRequestContext requestContext, CancellationToken cancellationToken)
+        => this.GetAccessToken();
+
+    public override ValueTask<AccessToken> GetTokenAsync(TokenRequestContext requestContext, CancellationToken cancellationToken)
+        => new(this.GetAccessToken());
+
+    private AccessToken GetAccessToken()
+    {
+        if (string.IsNullOrEmpty(this._token) || this._token == "DefaultAzureCredential")
+        {
+            throw new CredentialUnavailableException($"{EnvironmentVariable} environment variable is not set.");
+        }
+
+        return new AccessToken(this._token, DateTimeOffset.UtcNow.AddHours(1));
+    }
+}

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-TextRag/HostedTextRag.csproj

@@ -20,7 +20,6 @@
   <ItemGroup>
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry\Microsoft.Agents.AI.Foundry.csproj" />
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry.Hosting\Microsoft.Agents.AI.Foundry.Hosting.csproj" />
-    <ProjectReference Include="..\Hosted_Shared_Contributor_Setup\Hosted_Shared_Contributor_Setup.csproj" />
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
   </ItemGroup>
 

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-TextRag/Program.cs

@@ -8,7 +8,6 @@ using Azure.AI.Projects;
 using Azure.Core;
 using Azure.Identity;
 using DotNetEnv;
-using Hosted_Shared_Contributor_Setup;
 using Microsoft.Agents.AI;
 using Microsoft.Agents.AI.Foundry.Hosting;
 using Microsoft.Extensions.AI;
@@ -48,7 +47,6 @@ AIAgent agent = new AIProjectClient(new Uri(endpoint), credential)
 // Host the agent as a Foundry Hosted Agent using the Responses API.
 var builder = WebApplication.CreateBuilder(args);
 builder.Services.AddFoundryResponses(agent);
-builder.Services.AddDevTemporaryLocalContributorSetup(); // Local Docker debugging only - must not be used in production.
 
 var app = builder.Build();
 app.MapFoundryResponses();
@@ -99,3 +97,34 @@ static Task<IEnumerable<TextSearchProvider.TextSearchResult>> MockSearchAsync(st
 
     return Task.FromResult<IEnumerable<TextSearchProvider.TextSearchResult>>(results);
 }
+
+/// <summary>
+/// A <see cref="TokenCredential"/> for local Docker debugging only.
+/// Reads a pre-fetched bearer token from the <c>AZURE_BEARER_TOKEN</c> environment variable.
+/// This should NOT be used in production — tokens expire (~1 hour) and cannot be refreshed.
+///
+/// Generate a token on your host and pass it to the container:
+///   export AZURE_BEARER_TOKEN=$(az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv)
+///   docker run -e AZURE_BEARER_TOKEN=$AZURE_BEARER_TOKEN ...
+/// </summary>
+internal sealed class DevTemporaryTokenCredential : TokenCredential
+{
+    private const string EnvironmentVariable = "AZURE_BEARER_TOKEN";
+
+    public override AccessToken GetToken(TokenRequestContext requestContext, CancellationToken cancellationToken)
+        => GetAccessToken();
+
+    public override ValueTask<AccessToken> GetTokenAsync(TokenRequestContext requestContext, CancellationToken cancellationToken)
+        => new(GetAccessToken());
+
+    private static AccessToken GetAccessToken()
+    {
+        var token = Environment.GetEnvironmentVariable(EnvironmentVariable);
+        if (string.IsNullOrEmpty(token) || token == "DefaultAzureCredential")
+        {
+            throw new CredentialUnavailableException($"{EnvironmentVariable} environment variable is not set.");
+        }
+
+        return new AccessToken(token, DateTimeOffset.UtcNow.AddHours(1));
+    }
+}

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-Toolbox/HostedToolbox.csproj

@@ -20,7 +20,6 @@
   <ItemGroup>
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry\Microsoft.Agents.AI.Foundry.csproj" />
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry.Hosting\Microsoft.Agents.AI.Foundry.Hosting.csproj" />
-    <ProjectReference Include="..\Hosted_Shared_Contributor_Setup\Hosted_Shared_Contributor_Setup.csproj" />
   </ItemGroup>
 
   <!-- For end-users: uncomment the PackageReference below and remove the ProjectReference above

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-Toolbox/Program.cs

@@ -21,7 +21,6 @@ using Azure.AI.Projects;
 using Azure.Core;
 using Azure.Identity;
 using DotNetEnv;
-using Hosted_Shared_Contributor_Setup;
 using Microsoft.Agents.AI;
 using Microsoft.Agents.AI.Foundry.Hosting;
 
@@ -58,7 +57,6 @@ var builder = WebApplication.CreateBuilder(args);
 
 // Register the agent and response handler
 builder.Services.AddFoundryResponses(agent);
-builder.Services.AddDevTemporaryLocalContributorSetup(); // Local Docker debugging only - must not be used in production.
 
 // Register Foundry Toolbox: connects to the MCP proxy at startup and makes tools available.
 // The toolset name must match a toolset registered in your Foundry project.
@@ -77,3 +75,39 @@ if (app.Environment.IsDevelopment())
 app.Run();
 
 // ── DevTemporaryTokenCredential ───────────────────────────────────────────────
+
+/// <summary>
+/// A <see cref="TokenCredential"/> for local Docker debugging only.
+/// Reads a pre-fetched bearer token from the <c>AZURE_BEARER_TOKEN</c> environment variable
+/// once at startup. This should NOT be used in production.
+///
+/// Generate a token on your host and pass it to the container:
+///   export AZURE_BEARER_TOKEN=$(az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv)
+///   docker run -e AZURE_BEARER_TOKEN=$AZURE_BEARER_TOKEN ...
+/// </summary>
+internal sealed class DevTemporaryTokenCredential : TokenCredential
+{
+    private const string EnvironmentVariable = "AZURE_BEARER_TOKEN";
+    private readonly string? _token;
+
+    public DevTemporaryTokenCredential()
+    {
+        this._token = Environment.GetEnvironmentVariable(EnvironmentVariable);
+    }
+
+    public override AccessToken GetToken(TokenRequestContext requestContext, CancellationToken cancellationToken)
+        => this.GetAccessToken();
+
+    public override ValueTask<AccessToken> GetTokenAsync(TokenRequestContext requestContext, CancellationToken cancellationToken)
+        => new(this.GetAccessToken());
+
+    private AccessToken GetAccessToken()
+    {
+        if (string.IsNullOrEmpty(this._token) || this._token == "DefaultAzureCredential")
+        {
+            throw new CredentialUnavailableException($"{EnvironmentVariable} environment variable is not set.");
+        }
+
+        return new AccessToken(this._token, DateTimeOffset.MaxValue);
+    }
+}

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-Workflow-Handoff/HostedWorkflowHandoff.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
@@ -24,7 +24,6 @@
   <ItemGroup>
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry\Microsoft.Agents.AI.Foundry.csproj" />
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry.Hosting\Microsoft.Agents.AI.Foundry.Hosting.csproj" />
-    <ProjectReference Include="..\Hosted_Shared_Contributor_Setup\Hosted_Shared_Contributor_Setup.csproj" />
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Hosting\Microsoft.Agents.AI.Hosting.csproj" />
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Workflows\Microsoft.Agents.AI.Workflows.csproj" />

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-Workflow-Handoff/Program.cs

@@ -17,9 +17,9 @@
 
 using System.ComponentModel;
 using Azure.AI.OpenAI;
+using Azure.Core;
 using Azure.Identity;
 using DotNetEnv;
-using Hosted_Shared_Contributor_Setup;
 using Microsoft.Agents.AI;
 using Microsoft.Agents.AI.Foundry.Hosting;
 using Microsoft.Agents.AI.Hosting;
@@ -192,3 +192,30 @@ static string GetWeather(
     var condition = conditions[rng.Next(conditions.Length)];
     return $"Weather in {location}: {temp}C, {condition}. Humidity: {rng.Next(30, 90)}%. Wind: {rng.Next(5, 30)} km/h.";
 }
+
+internal sealed class DevTemporaryTokenCredential : TokenCredential
+{
+    private const string EnvironmentVariable = "AZURE_BEARER_TOKEN";
+    private readonly string? _token;
+
+    public DevTemporaryTokenCredential()
+    {
+        this._token = Environment.GetEnvironmentVariable(EnvironmentVariable);
+    }
+
+    public override AccessToken GetToken(TokenRequestContext requestContext, CancellationToken cancellationToken)
+        => this.GetAccessToken();
+
+    public override ValueTask<AccessToken> GetTokenAsync(TokenRequestContext requestContext, CancellationToken cancellationToken)
+        => new(this.GetAccessToken());
+
+    private AccessToken GetAccessToken()
+    {
+        if (string.IsNullOrEmpty(this._token) || this._token == "DefaultAzureCredential")
+        {
+            throw new CredentialUnavailableException($"{EnvironmentVariable} environment variable is not set.");
+        }
+
+        return new AccessToken(this._token, DateTimeOffset.UtcNow.AddHours(1));
+    }
+}

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-Workflow-Simple/HostedWorkflowSimple.csproj

@@ -20,7 +20,6 @@
   <ItemGroup>
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry\Microsoft.Agents.AI.Foundry.csproj" />
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry.Hosting\Microsoft.Agents.AI.Foundry.Hosting.csproj" />
-    <ProjectReference Include="..\Hosted_Shared_Contributor_Setup\Hosted_Shared_Contributor_Setup.csproj" />
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
     <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Workflows\Microsoft.Agents.AI.Workflows.csproj" />
   </ItemGroup>

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted-Workflow-Simple/Program.cs

@@ -9,7 +9,6 @@ using Azure.AI.Projects;
 using Azure.Core;
 using Azure.Identity;
 using DotNetEnv;
-using Hosted_Shared_Contributor_Setup;
 using Microsoft.Agents.AI;
 using Microsoft.Agents.AI.Foundry.Hosting;
 using Microsoft.Agents.AI.Workflows;
@@ -50,7 +49,6 @@ AIAgent agent = new WorkflowBuilder(frenchAgent)
 // Host the workflow agent as a Foundry Hosted Agent using the Responses API.
 var builder = WebApplication.CreateBuilder(args);
 builder.Services.AddFoundryResponses(agent);
-builder.Services.AddDevTemporaryLocalContributorSetup(); // Local Docker debugging only - must not be used in production.
 
 var app = builder.Build();
 app.MapFoundryResponses();
@@ -61,3 +59,39 @@ if (app.Environment.IsDevelopment())
 }
 
 app.Run();
+
+/// <summary>
+/// A <see cref="TokenCredential"/> for local Docker debugging only.
+/// Reads a pre-fetched bearer token from the <c>AZURE_BEARER_TOKEN</c> environment variable
+/// once at startup. This should NOT be used in production.
+///
+/// Generate a token on your host and pass it to the container:
+///   export AZURE_BEARER_TOKEN=$(az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv)
+///   docker run -e AZURE_BEARER_TOKEN=$AZURE_BEARER_TOKEN ...
+/// </summary>
+internal sealed class DevTemporaryTokenCredential : TokenCredential
+{
+    private const string EnvironmentVariable = "AZURE_BEARER_TOKEN";
+    private readonly string? _token;
+
+    public DevTemporaryTokenCredential()
+    {
+        this._token = Environment.GetEnvironmentVariable(EnvironmentVariable);
+    }
+
+    public override AccessToken GetToken(TokenRequestContext requestContext, CancellationToken cancellationToken)
+        => this.GetAccessToken();
+
+    public override ValueTask<AccessToken> GetTokenAsync(TokenRequestContext requestContext, CancellationToken cancellationToken)
+        => new(this.GetAccessToken());
+
+    private AccessToken GetAccessToken()
+    {
+        if (string.IsNullOrEmpty(this._token) || this._token == "DefaultAzureCredential")
+        {
+            throw new CredentialUnavailableException($"{EnvironmentVariable} environment variable is not set.");
+        }
+
+        return new AccessToken(this._token, DateTimeOffset.UtcNow.AddHours(1));
+    }
+}

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted_Shared_Contributor_Setup/DevTemporaryLocalSessionIsolationKeyProvider.cs

@@ -1,72 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using Azure.AI.AgentServer.Responses;
-using Azure.AI.AgentServer.Responses.Models;
-using Microsoft.Agents.AI.Foundry.Hosting;
-
-namespace Hosted_Shared_Contributor_Setup;
-
-/// <summary>
-/// A <see cref="HostedSessionIsolationKeyProvider"/> for local Docker debugging only.
-///
-/// When the Foundry platform's <c>x-agent-user-isolation-key</c> and
-/// <c>x-agent-chat-isolation-key</c> headers are absent (i.e., when the container is running
-/// outside the Foundry platform), the hosting layer rejects every request with a 500 because the
-/// default <see cref="HostedSessionIsolationKeyProvider"/> returns null. This provider supplies
-/// fallback values from the <c>HOSTED_USER_ISOLATION_KEY</c> and <c>HOSTED_CHAT_ISOLATION_KEY</c>
-/// environment variables, defaulting to the constants below when neither is set.
-///
-/// This should NOT be used in production. The Foundry platform sets the isolation keys for every
-/// inbound request and forging them client-side defeats the per-user partitioning. The dev
-/// fallback exists solely so a contributor can <c>docker run</c> the sample on their laptop and
-/// drive a few requests end to end.
-/// </summary>
-public sealed class DevTemporaryLocalSessionIsolationKeyProvider : HostedSessionIsolationKeyProvider
-{
-    /// <summary>
-    /// Environment variable that supplies the user isolation key when the platform header is absent.
-    /// </summary>
-    public const string UserIsolationKeyEnvironmentVariable = "HOSTED_USER_ISOLATION_KEY";
-
-    /// <summary>
-    /// Environment variable that supplies the chat isolation key when the platform header is absent.
-    /// </summary>
-    public const string ChatIsolationKeyEnvironmentVariable = "HOSTED_CHAT_ISOLATION_KEY";
-
-    /// <summary>
-    /// Default user isolation key used when neither the platform header nor the environment variable
-    /// supplies a value. All local requests collapse onto this single bucket unless overridden.
-    /// </summary>
-    public const string DefaultLocalUserIsolationKey = "local-dev-user";
-
-    /// <summary>
-    /// Default chat isolation key used when neither the platform header nor the environment variable
-    /// supplies a value.
-    /// </summary>
-    public const string DefaultLocalChatIsolationKey = "local-dev-chat";
-
-    /// <inheritdoc />
-    public override ValueTask<HostedSessionContext?> GetKeysAsync(
-        ResponseContext context,
-        CreateResponse request,
-        CancellationToken cancellationToken)
-    {
-        var userKey = !string.IsNullOrWhiteSpace(context?.Isolation?.UserIsolationKey)
-            ? context!.Isolation!.UserIsolationKey
-            : Environment.GetEnvironmentVariable(UserIsolationKeyEnvironmentVariable);
-        if (string.IsNullOrWhiteSpace(userKey))
-        {
-            userKey = DefaultLocalUserIsolationKey;
-        }
-
-        var chatKey = !string.IsNullOrWhiteSpace(context?.Isolation?.ChatIsolationKey)
-            ? context!.Isolation!.ChatIsolationKey
-            : Environment.GetEnvironmentVariable(ChatIsolationKeyEnvironmentVariable);
-        if (string.IsNullOrWhiteSpace(chatKey))
-        {
-            chatKey = DefaultLocalChatIsolationKey;
-        }
-
-        return new ValueTask<HostedSessionContext?>(new HostedSessionContext(userKey!, chatKey!));
-    }
-}

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted_Shared_Contributor_Setup/DevTemporaryTokenCredential.cs

@@ -1,57 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using Azure.Core;
-using Azure.Identity;
-
-namespace Hosted_Shared_Contributor_Setup;
-
-/// <summary>
-/// A <see cref="TokenCredential"/> for local Docker debugging only.
-///
-/// When debugging and testing a hosted agent in a local Docker container, Azure CLI
-/// and other interactive credentials are not available. This credential reads a
-/// pre-fetched bearer token from the <c>AZURE_BEARER_TOKEN</c> environment variable.
-///
-/// This should NOT be used in production. Tokens expire (around one hour) and cannot be refreshed.
-/// In production, the Foundry platform injects a managed identity automatically.
-///
-/// Generate a token on your host and pass it to the container:
-///   export AZURE_BEARER_TOKEN=$(az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv)
-///   docker run -e AZURE_BEARER_TOKEN=$AZURE_BEARER_TOKEN ...
-/// </summary>
-public sealed class DevTemporaryTokenCredential : TokenCredential
-{
-    private const string EnvironmentVariable = "AZURE_BEARER_TOKEN";
-    private readonly string? _token;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="DevTemporaryTokenCredential"/> class.
-    /// Reads the bearer token from the <c>AZURE_BEARER_TOKEN</c> environment variable when present.
-    /// </summary>
-    public DevTemporaryTokenCredential()
-    {
-        this._token = Environment.GetEnvironmentVariable(EnvironmentVariable);
-    }
-
-    /// <inheritdoc />
-    public override AccessToken GetToken(TokenRequestContext requestContext, CancellationToken cancellationToken)
-    {
-        return this.GetAccessToken();
-    }
-
-    /// <inheritdoc />
-    public override ValueTask<AccessToken> GetTokenAsync(TokenRequestContext requestContext, CancellationToken cancellationToken)
-    {
-        return new ValueTask<AccessToken>(this.GetAccessToken());
-    }
-
-    private AccessToken GetAccessToken()
-    {
-        if (string.IsNullOrEmpty(this._token) || this._token == "DefaultAzureCredential")
-        {
-            throw new CredentialUnavailableException($"{EnvironmentVariable} environment variable is not set.");
-        }
-
-        return new AccessToken(this._token, DateTimeOffset.UtcNow.AddHours(1));
-    }
-}

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted_Shared_Contributor_Setup/HostedContributorSetupExtensions.cs

@@ -1,33 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using Microsoft.Agents.AI.Foundry.Hosting;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace Hosted_Shared_Contributor_Setup;
-
-/// <summary>
-/// Registration helpers for the developer-only utilities shipped in this sample-shared project.
-/// </summary>
-public static class HostedContributorSetupExtensions
-{
-    /// <summary>
-    /// Registers developer-only services that allow a hosted Foundry agent to run outside the
-    /// Foundry platform (e.g., inside a Docker container during contributor debugging).
-    ///
-    /// <para><b>For local Docker debugging only and should not be used in production.</b></para>
-    ///
-    /// Currently this method registers a <see cref="DevTemporaryLocalSessionIsolationKeyProvider"/>
-    /// so that requests succeed when the platform's <c>x-agent-user-isolation-key</c> and
-    /// <c>x-agent-chat-isolation-key</c> headers are absent. In production those headers are
-    /// always present and the default platform isolation key provider (registered automatically by
-    /// the hosting layer) is used instead.
-    /// </summary>
-    /// <param name="services">The service collection to register the developer-only services into.</param>
-    /// <returns>The same <see cref="IServiceCollection"/> for chaining.</returns>
-    public static IServiceCollection AddDevTemporaryLocalContributorSetup(this IServiceCollection services)
-    {
-        ArgumentNullException.ThrowIfNull(services);
-        services.AddSingleton<HostedSessionIsolationKeyProvider, DevTemporaryLocalSessionIsolationKeyProvider>();
-        return services;
-    }
-}

dotnet/samples/04-hosting/FoundryHostedAgents/responses/Hosted_Shared_Contributor_Setup/Hosted_Shared_Contributor_Setup.csproj

@@ -1,27 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFrameworks>net10.0</TargetFrameworks>
-    <Nullable>enable</Nullable>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <CentralPackageTransitivePinningEnabled>false</CentralPackageTransitivePinningEnabled>
-    <RootNamespace>Hosted_Shared_Contributor_Setup</RootNamespace>
-    <AssemblyName>Hosted_Shared_Contributor_Setup</AssemblyName>
-    <NoWarn>$(NoWarn);</NoWarn>
-    <IsPackable>false</IsPackable>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Azure.Identity" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <FrameworkReference Include="Microsoft.AspNetCore.App" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry\Microsoft.Agents.AI.Foundry.csproj" />
-    <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Foundry.Hosting\Microsoft.Agents.AI.Foundry.Hosting.csproj" />
-  </ItemGroup>
-
-</Project>

dotnet/src/Microsoft.Agents.AI.AGUI/Shared/ChatResponseUpdateAGUIExtensions.cs

@@ -458,9 +458,8 @@ internal static class ChatResponseUpdateAGUIExtensions
             // This ensures all AGUI events have a valid messageId regardless of agent type.
             if (string.IsNullOrWhiteSpace(chatResponse.MessageId))
             {
-                chatResponse.MessageId = ContainsToolResult(chatResponse)
-                    ? Guid.NewGuid().ToString("N")
-                    : (streamingMessageId ??= Guid.NewGuid().ToString("N"));
+                streamingMessageId ??= Guid.NewGuid().ToString("N");
+                chatResponse.MessageId = streamingMessageId;
             }
 
             if (chatResponse is { Contents.Count: > 0 } &&
@@ -726,17 +725,4 @@ internal static class ChatResponseUpdateAGUIExtensions
             _ => JsonSerializer.Serialize(functionResultContent.Result, options.GetTypeInfo(functionResultContent.Result.GetType())),
         };
     }
-
-    private static bool ContainsToolResult(ChatResponseUpdate chatResponse)
-    {
-        foreach (AIContent content in chatResponse.Contents)
-        {
-            if (content is FunctionResultContent)
-            {
-                return true;
-            }
-        }
-
-        return false;
-    }
 }

dotnet/src/Microsoft.Agents.AI.Foundry.Hosting/AgentFrameworkResponseHandler.cs

@@ -26,12 +26,6 @@ public class AgentFrameworkResponseHandler : ResponseHandler
     private readonly ILogger<AgentFrameworkResponseHandler> _logger;
     private readonly FoundryToolboxService? _toolboxService;
 
-    /// <summary>
-    /// Cached fallback used when no <see cref="HostedSessionIsolationKeyProvider"/> is registered in DI.
-    /// Avoids a per-request allocation on the request hot path.
-    /// </summary>
-    private static readonly HostedSessionIsolationKeyProvider s_defaultIsolationKeyProvider = new PlatformHostedSessionIsolationKeyProvider();
-
     /// <summary>
     /// Initializes a new instance of the <see cref="AgentFrameworkResponseHandler"/> class
     /// that resolves agents from keyed DI services.
@@ -73,42 +67,6 @@ public class AgentFrameworkResponseHandler : ResponseHandler
                 ? await chatClientAgent.CreateSessionAsync(cancellationToken).ConfigureAwait(false)
                 : await agent.CreateSessionAsync(cancellationToken).ConfigureAwait(false);
 
-        // 2.5. Resolve and apply the per-request hosted session identity context.
-        // Fresh sessions are tagged once. Resumed sessions are validated against the live request
-        // to detect cross-user session leaks and in-process tampering of the persisted identity.
-        var isolationKeyProvider = this._serviceProvider.GetService<HostedSessionIsolationKeyProvider>()
-            ?? s_defaultIsolationKeyProvider;
-        var resolvedHostedContext = await isolationKeyProvider.GetKeysAsync(context, request, cancellationToken).ConfigureAwait(false);
-        if (resolvedHostedContext is null)
-        {
-            throw new InvalidOperationException(
-                $"The registered {nameof(HostedSessionIsolationKeyProvider)} returned null for the current request. " +
-                "Ensure the Foundry platform is providing the x-agent-user-isolation-key and x-agent-chat-isolation-key headers, " +
-                "or register a custom provider that supplies fallback values for local development.");
-        }
-
-        if (session is not null)
-        {
-            var existingHostedContext = session.GetHostedContext();
-            if (existingHostedContext is null)
-            {
-                // Fresh path: the session has no hosted context yet (either freshly created here,
-                // or freshly loaded for a conversation_id that the platform supplied without any
-                // prior hosted-agent request having stamped a context). Stamp it now.
-                session.SetHostedContext(resolvedHostedContext);
-            }
-            else if (!string.Equals(existingHostedContext.UserId, resolvedHostedContext.UserId, StringComparison.Ordinal)
-                || !string.Equals(existingHostedContext.ChatId, resolvedHostedContext.ChatId, StringComparison.Ordinal))
-            {
-                // Resume path: the persisted identity must match the live request. A mismatch
-                // signals either a cross-user session leak or in-process tampering of the
-                // persisted identity. Reject the request hard.
-                throw new ResponsesApiException(
-                    new Error("hosted_session_identity_mismatch", "Hosted session identity context mismatch"),
-                    403);
-            }
-        }
-
         // 3. Create the SDK event stream builder
         var stream = new ResponseEventStream(context, request);
 

dotnet/src/Microsoft.Agents.AI.Foundry.Hosting/HostedFoundryMemoryProviderScopes.cs

@@ -1,65 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System;
-using System.Diagnostics.CodeAnalysis;
-using Microsoft.Shared.DiagnosticIds;
-
-namespace Microsoft.Agents.AI.Foundry.Hosting;
-
-/// <summary>
-/// Built-in <see cref="FoundryMemoryProvider"/> <c>stateInitializer</c> factories that derive the
-/// <see cref="FoundryMemoryProviderScope"/> from the per-session <see cref="HostedSessionContext"/>
-/// applied by the Foundry hosting layer.
-/// </summary>
-/// <remarks>
-/// Pass the result of any of these helpers as the <c>stateInitializer</c> argument when constructing
-/// <see cref="FoundryMemoryProvider"/>:
-/// <code>
-/// new FoundryMemoryProvider(client, "my-store",
-///     stateInitializer: HostedFoundryMemoryProviderScopes.PerUser());
-/// </code>
-/// All helpers throw <see cref="InvalidOperationException"/> when
-/// <see cref="HostedSessionContextExtensions.GetHostedContext"/> returns <see langword="null"/>.
-/// That happens when the agent runs outside the Foundry hosting layer (e.g., a console app); in
-/// that case write a custom <c>stateInitializer</c> instead of using these helpers.
-/// </remarks>
-[Experimental(DiagnosticIds.Experiments.AIOpenAIResponses)]
-public static class HostedFoundryMemoryProviderScopes
-{
-    /// <summary>
-    /// Returns a <c>stateInitializer</c> that scopes memories per end user, using
-    /// <see cref="HostedSessionContext.UserId"/> as the partition key.
-    /// </summary>
-    /// <returns>A delegate suitable for the <c>stateInitializer</c> argument of <see cref="FoundryMemoryProvider"/>.</returns>
-    public static Func<AgentSession?, FoundryMemoryProvider.State> PerUser() =>
-        session => new FoundryMemoryProvider.State(new FoundryMemoryProviderScope(GetRequiredHostedContext(session).UserId));
-
-    /// <summary>
-    /// Returns a <c>stateInitializer</c> that scopes memories per conversation, using
-    /// <see cref="HostedSessionContext.ChatId"/> as the partition key. Use this when memories should
-    /// be visible to every participant in a shared conversation (for example, a Teams group chat).
-    /// </summary>
-    /// <returns>A delegate suitable for the <c>stateInitializer</c> argument of <see cref="FoundryMemoryProvider"/>.</returns>
-    public static Func<AgentSession?, FoundryMemoryProvider.State> PerChat() =>
-        session => new FoundryMemoryProvider.State(new FoundryMemoryProviderScope(GetRequiredHostedContext(session).ChatId));
-
-    /// <summary>
-    /// Returns a <c>stateInitializer</c> that scopes memories per (user, chat) pair, using
-    /// <c>"{UserId}:{ChatId}"</c> as the partition key. Use this when memories should be visible
-    /// only to the same user within the same conversation.
-    /// </summary>
-    /// <returns>A delegate suitable for the <c>stateInitializer</c> argument of <see cref="FoundryMemoryProvider"/>.</returns>
-    public static Func<AgentSession?, FoundryMemoryProvider.State> PerUserAndChat() =>
-        session =>
-        {
-            var ctx = GetRequiredHostedContext(session);
-            return new FoundryMemoryProvider.State(new FoundryMemoryProviderScope($"{ctx.UserId}:{ctx.ChatId}"));
-        };
-
-    private static HostedSessionContext GetRequiredHostedContext(AgentSession? session) =>
-        session?.GetHostedContext()
-            ?? throw new InvalidOperationException(
-                $"{nameof(HostedSessionContext)} was not provided by the hosting layer. " +
-                $"The {nameof(HostedFoundryMemoryProviderScopes)} helpers require the agent to be hosted via the Foundry hosting layer. " +
-                "If running outside a hosted Foundry container, supply a custom stateInitializer to FoundryMemoryProvider instead.");
-}

dotnet/src/Microsoft.Agents.AI.Foundry.Hosting/HostedFoundryMemoryProviderServiceCollectionExtensions.cs

@@ -1,88 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System;
-using System.Diagnostics.CodeAnalysis;
-using Azure.AI.Projects;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-using Microsoft.Shared.DiagnosticIds;
-using Microsoft.Shared.Diagnostics;
-
-namespace Microsoft.Agents.AI.Foundry.Hosting;
-
-/// <summary>
-/// Dependency-injection helpers that register a <see cref="FoundryMemoryProvider"/> wired with a
-/// <see cref="HostedFoundryMemoryProviderScopes"/> strategy.
-/// </summary>
-[Experimental(DiagnosticIds.Experiments.AIOpenAIResponses)]
-public static class HostedFoundryMemoryProviderServiceCollectionExtensions
-{
-    /// <summary>
-    /// Registers a singleton <see cref="FoundryMemoryProvider"/> wired to the supplied
-    /// <see cref="AIProjectClient"/> and the supplied <paramref name="stateInitializer"/>.
-    /// </summary>
-    /// <param name="services">The service collection.</param>
-    /// <param name="client">The <see cref="AIProjectClient"/> used to talk to Foundry Memory.</param>
-    /// <param name="memoryStoreName">The name of the memory store in Microsoft Foundry.</param>
-    /// <param name="stateInitializer">
-    /// Strategy that selects the per-session <see cref="FoundryMemoryProviderScope"/>. When
-    /// <see langword="null"/>, the extension uses <see cref="HostedFoundryMemoryProviderScopes.PerUser"/>.
-    /// Pass any other helper (or a custom delegate) to override.
-    /// </param>
-    /// <param name="options">Optional <see cref="FoundryMemoryProviderOptions"/>.</param>
-    /// <returns>The same <see cref="IServiceCollection"/> for chaining.</returns>
-    public static IServiceCollection AddHostedFoundryMemoryProvider(
-        this IServiceCollection services,
-        AIProjectClient client,
-        string memoryStoreName,
-        Func<AgentSession?, FoundryMemoryProvider.State>? stateInitializer = null,
-        FoundryMemoryProviderOptions? options = null)
-    {
-        Throw.IfNull(services);
-        Throw.IfNull(client);
-        Throw.IfNullOrWhitespace(memoryStoreName);
-
-        var initializer = stateInitializer ?? HostedFoundryMemoryProviderScopes.PerUser();
-        services.AddSingleton(sp => new FoundryMemoryProvider(
-            client,
-            memoryStoreName,
-            initializer,
-            options,
-            sp.GetService<ILoggerFactory>()));
-        return services;
-    }
-
-    /// <summary>
-    /// Registers a singleton <see cref="FoundryMemoryProvider"/> that resolves its
-    /// <see cref="AIProjectClient"/> from <see cref="IServiceProvider"/> at construction time.
-    /// Use this overload when an <see cref="AIProjectClient"/> is already registered with the
-    /// service collection.
-    /// </summary>
-    /// <param name="services">The service collection.</param>
-    /// <param name="memoryStoreName">The name of the memory store in Microsoft Foundry.</param>
-    /// <param name="stateInitializer">
-    /// Strategy that selects the per-session <see cref="FoundryMemoryProviderScope"/>. When
-    /// <see langword="null"/>, the extension uses <see cref="HostedFoundryMemoryProviderScopes.PerUser"/>.
-    /// Pass any other helper (or a custom delegate) to override.
-    /// </param>
-    /// <param name="options">Optional <see cref="FoundryMemoryProviderOptions"/>.</param>
-    /// <returns>The same <see cref="IServiceCollection"/> for chaining.</returns>
-    public static IServiceCollection AddHostedFoundryMemoryProvider(
-        this IServiceCollection services,
-        string memoryStoreName,
-        Func<AgentSession?, FoundryMemoryProvider.State>? stateInitializer = null,
-        FoundryMemoryProviderOptions? options = null)
-    {
-        Throw.IfNull(services);
-        Throw.IfNullOrWhitespace(memoryStoreName);
-
-        var initializer = stateInitializer ?? HostedFoundryMemoryProviderScopes.PerUser();
-        services.AddSingleton(sp => new FoundryMemoryProvider(
-            sp.GetRequiredService<AIProjectClient>(),
-            memoryStoreName,
-            initializer,
-            options,
-            sp.GetService<ILoggerFactory>()));
-        return services;
-    }
-}

dotnet/src/Microsoft.Agents.AI.Foundry.Hosting/HostedSessionContext.cs

@@ -1,61 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System.Diagnostics.CodeAnalysis;
-using Microsoft.Shared.DiagnosticIds;
-using Microsoft.Shared.Diagnostics;
-
-namespace Microsoft.Agents.AI.Foundry.Hosting;
-
-/// <summary>
-/// Captures the per-session identity values produced by a <see cref="HostedSessionIsolationKeyProvider"/>
-/// when a Foundry hosted agent processes a request.
-/// </summary>
-/// <remarks>
-/// <para>
-/// The <see cref="UserId"/> partitions data that belongs to the individual who initiated the request
-/// (e.g., personal memory, per-user preferences). The <see cref="ChatId"/> partitions data that belongs
-/// to the conversation (e.g., conversation history, turn state). Both values are opaque strings whose
-/// meaning is determined by the active <see cref="HostedSessionIsolationKeyProvider"/>.
-/// </para>
-/// <para>
-/// Instances are constructed by the hosting layer from the platform-provided
-/// <c>IsolationContext</c> headers and stored on the session via
-/// <see cref="HostedSessionContextExtensions.SetHostedContext"/>. Consumers (typically
-/// <see cref="AIContextProvider"/> implementations) read the values through
-/// <see cref="HostedSessionContextExtensions.GetHostedContext"/>.
-/// </para>
-/// </remarks>
-[Experimental(DiagnosticIds.Experiments.AIOpenAIResponses)]
-public sealed class HostedSessionContext
-{
-    /// <summary>
-    /// Initializes a new instance of the <see cref="HostedSessionContext"/> class.
-    /// </summary>
-    /// <param name="userId">The opaque user identity for this hosted session. Must not be null or whitespace.</param>
-    /// <param name="chatId">The opaque chat (conversation) identity for this hosted session. Must not be null or whitespace.</param>
-    /// <exception cref="System.ArgumentException">Thrown when <paramref name="userId"/> or <paramref name="chatId"/> is null or whitespace.</exception>
-    public HostedSessionContext(string userId, string chatId)
-    {
-        this.UserId = Throw.IfNullOrWhitespace(userId);
-        this.ChatId = Throw.IfNullOrWhitespace(chatId);
-    }
-
-    /// <summary>
-    /// Gets the opaque user identity for this hosted session.
-    /// </summary>
-    /// <remarks>
-    /// Stable for a given user across sessions. In production this is sourced from the
-    /// <c>x-agent-user-isolation-key</c> platform header.
-    /// </remarks>
-    public string UserId { get; }
-
-    /// <summary>
-    /// Gets the opaque chat (conversation) identity for this hosted session.
-    /// </summary>
-    /// <remarks>
-    /// In a 1:1 user-to-agent chat this typically equals <see cref="UserId"/>. In shared-surface
-    /// scenarios (e.g., a Teams group chat) it represents the common partition all participants
-    /// write to. In production this is sourced from the <c>x-agent-chat-isolation-key</c> platform header.
-    /// </remarks>
-    public string ChatId { get; }
-}

dotnet/src/Microsoft.Agents.AI.Foundry.Hosting/HostedSessionContextExtensions.cs

@@ -1,81 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System;
-using System.Diagnostics.CodeAnalysis;
-using Microsoft.Shared.DiagnosticIds;
-using Microsoft.Shared.Diagnostics;
-
-namespace Microsoft.Agents.AI.Foundry.Hosting;
-
-/// <summary>
-/// Extension methods for reading and writing the <see cref="HostedSessionContext"/> associated
-/// with an <see cref="AgentSession"/> in a Foundry hosted agent.
-/// </summary>
-/// <remarks>
-/// The hosted session context is written exactly once by the hosting layer when a session is created,
-/// and is validated against the live request on every subsequent invocation. The <see cref="SetHostedContext"/>
-/// method is intentionally <see langword="internal"/> so that only the hosting layer can establish the
-/// identity values; consumers (such as <see cref="AIContextProvider"/> implementations) read the values
-/// through the public <see cref="GetHostedContext"/> accessor.
-/// </remarks>
-[Experimental(DiagnosticIds.Experiments.AIOpenAIResponses)]
-public static class HostedSessionContextExtensions
-{
-    /// <summary>
-    /// The well-known <see cref="AgentSessionStateBag"/> key used to store the
-    /// <see cref="HostedSessionContext"/> on a session.
-    /// </summary>
-    /// <remarks>
-    /// Exposed as a constant so consumers can correlate persisted state across processes.
-    /// External code must not write to this key directly; use <see cref="SetHostedContext"/> from the
-    /// hosting assembly instead.
-    /// </remarks>
-    public const string StateKey = "Microsoft.Agents.AI.Foundry.Hosting.HostedSessionContext";
-
-    /// <summary>
-    /// Gets the <see cref="HostedSessionContext"/> previously written by the hosting layer
-    /// for this session, if any.
-    /// </summary>
-    /// <param name="session">The session to read from.</param>
-    /// <returns>
-    /// The <see cref="HostedSessionContext"/> for the session, or <see langword="null"/> when the
-    /// session was not produced by a hosted agent (or the value has not yet been written).
-    /// </returns>
-    /// <exception cref="ArgumentNullException">Thrown when <paramref name="session"/> is <see langword="null"/>.</exception>
-    public static HostedSessionContext? GetHostedContext(this AgentSession session)
-    {
-        Throw.IfNull(session);
-
-        return session.StateBag.TryGetValue<HostedSessionContext>(StateKey, out var context, HostedSessionJsonUtilities.DefaultOptions)
-            ? context
-            : null;
-    }
-
-    /// <summary>
-    /// Writes the <see cref="HostedSessionContext"/> for this session.
-    /// </summary>
-    /// <param name="session">The session to write to.</param>
-    /// <param name="context">The hosted session context to associate with <paramref name="session"/>.</param>
-    /// <remarks>
-    /// Internal to the hosting assembly. Consumers must not invoke this method directly; the hosting
-    /// layer is the single writer and uses validation against the live request to detect any tampering
-    /// that does occur via lower-level APIs. Throws when a context has already been written for this
-    /// session to enforce the write-once contract.
-    /// </remarks>
-    /// <exception cref="ArgumentNullException">Thrown when <paramref name="session"/> or <paramref name="context"/> is <see langword="null"/>.</exception>
-    /// <exception cref="InvalidOperationException">Thrown when this session already carries a <see cref="HostedSessionContext"/>.</exception>
-    internal static void SetHostedContext(this AgentSession session, HostedSessionContext context)
-    {
-        Throw.IfNull(session);
-        Throw.IfNull(context);
-
-        if (session.StateBag.TryGetValue<HostedSessionContext>(StateKey, out _, HostedSessionJsonUtilities.DefaultOptions))
-        {
-            throw new InvalidOperationException(
-                $"A {nameof(HostedSessionContext)} has already been written to this session. " +
-                "The hosted session identity is write-once; resumed sessions must validate against the existing context, not overwrite it.");
-        }
-
-        session.StateBag.SetValue(StateKey, context, HostedSessionJsonUtilities.DefaultOptions);
-    }
-}

dotnet/src/Microsoft.Agents.AI.Foundry.Hosting/HostedSessionIsolationKeyProvider.cs

@@ -1,54 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System.Diagnostics.CodeAnalysis;
-using System.Threading;
-using System.Threading.Tasks;
-using Azure.AI.AgentServer.Responses;
-using Azure.AI.AgentServer.Responses.Models;
-using Microsoft.Shared.DiagnosticIds;
-
-namespace Microsoft.Agents.AI.Foundry.Hosting;
-
-/// <summary>
-/// Resolves the per-request <see cref="HostedSessionContext"/> for a Foundry hosted agent.
-/// </summary>
-/// <remarks>
-/// <para>
-/// Implementations are invoked once per incoming Responses API request. The returned
-/// <see cref="HostedSessionContext"/> establishes the identity of a freshly created session and
-/// is validated against the live request on every subsequent invocation that resumes the same session.
-/// </para>
-/// <para>
-/// The default implementation registered when no custom <see cref="HostedSessionIsolationKeyProvider"/>
-/// is present in DI maps the platform-injected <c>x-agent-user-isolation-key</c> and
-/// <c>x-agent-chat-isolation-key</c> headers via <see cref="ResponseContext.Isolation"/>. Hosting samples and contributor-only environments
-/// can register an alternate implementation in DI to provide values when the platform headers are absent
-/// (e.g., during local Docker debugging).
-/// </para>
-/// <para>
-/// Implementations must return a <see cref="HostedSessionContext"/> whose <see cref="HostedSessionContext.UserId"/>
-/// and <see cref="HostedSessionContext.ChatId"/> are both non-null and non-whitespace. Returning either as null
-/// (or throwing from <see cref="GetKeysAsync"/>) is treated as a configuration error and surfaces as a
-/// 500 from the hosting layer.
-/// </para>
-/// </remarks>
-[Experimental(DiagnosticIds.Experiments.AIOpenAIResponses)]
-public abstract class HostedSessionIsolationKeyProvider
-{
-    /// <summary>
-    /// Resolves the <see cref="HostedSessionContext"/> for the supplied request.
-    /// </summary>
-    /// <param name="context">The per-request <see cref="ResponseContext"/> from the Azure AI Responses Server SDK.</param>
-    /// <param name="request">The <see cref="CreateResponse"/> describing the incoming request.</param>
-    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests.</param>
-    /// <returns>
-    /// A <see cref="HostedSessionContext"/> with non-null <see cref="HostedSessionContext.UserId"/> and
-    /// <see cref="HostedSessionContext.ChatId"/>, or <see langword="null"/> when the implementation cannot
-    /// produce identity keys for the current request. A <see langword="null"/> result is treated as a
-    /// configuration error by the hosting layer and surfaces as 500.
-    /// </returns>
-    public abstract ValueTask<HostedSessionContext?> GetKeysAsync(
-        ResponseContext context,
-        CreateResponse request,
-        CancellationToken cancellationToken);
-}

dotnet/src/Microsoft.Agents.AI.Foundry.Hosting/HostedSessionJsonUtilities.cs

@@ -1,39 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System.Diagnostics.CodeAnalysis;
-using System.Text.Json;
-using System.Text.Json.Serialization;
-using Microsoft.Shared.DiagnosticIds;
-
-namespace Microsoft.Agents.AI.Foundry.Hosting;
-
-/// <summary>
-/// JSON serialization utilities for hosted session identity types.
-/// </summary>
-[Experimental(DiagnosticIds.Experiments.AIOpenAIResponses)]
-internal static class HostedSessionJsonUtilities
-{
-    /// <summary>
-    /// Default JSON serializer options for hosted session state.
-    /// </summary>
-    public static JsonSerializerOptions DefaultOptions { get; } = new JsonSerializerOptions
-    {
-        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
-        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
-        WriteIndented = false,
-        TypeInfoResolver = HostedSessionJsonContext.Default
-    };
-}
-
-/// <summary>
-/// Source-generated JSON serialization context for hosted session identity types.
-/// </summary>
-[JsonSourceGenerationOptions(
-    JsonSerializerDefaults.General,
-    UseStringEnumConverter = false,
-    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
-    PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase,
-    WriteIndented = false)]
-[JsonSerializable(typeof(HostedSessionContext))]
-[Experimental(DiagnosticIds.Experiments.AIOpenAIResponses)]
-internal partial class HostedSessionJsonContext : JsonSerializerContext;

dotnet/src/Microsoft.Agents.AI.Foundry.Hosting/PlatformHostedSessionIsolationKeyProvider.cs

@@ -1,44 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System.Diagnostics.CodeAnalysis;
-using System.Threading;
-using System.Threading.Tasks;
-using Azure.AI.AgentServer.Responses;
-using Azure.AI.AgentServer.Responses.Models;
-using Microsoft.Shared.DiagnosticIds;
-
-namespace Microsoft.Agents.AI.Foundry.Hosting;
-
-/// <summary>
-/// Default <see cref="HostedSessionIsolationKeyProvider"/> implementation that maps the platform-injected
-/// <c>x-agent-user-isolation-key</c> and <c>x-agent-chat-isolation-key</c> headers from
-/// <see cref="ResponseContext.Isolation"/> into a <see cref="HostedSessionContext"/>.
-/// </summary>
-/// <remarks>
-/// This is the implementation used in production Foundry hosted environments. When running locally
-/// outside the platform, both isolation keys are <see langword="null"/>, which causes
-/// <see cref="GetKeysAsync"/> to return <see langword="null"/>. The hosting layer treats a null
-/// result as a configuration error and surfaces it as a 500 from the request. Local development
-/// should register an alternate <see cref="HostedSessionIsolationKeyProvider"/> implementation
-/// that provides fallback values for the missing headers.
-/// </remarks>
-[Experimental(DiagnosticIds.Experiments.AIOpenAIResponses)]
-internal sealed class PlatformHostedSessionIsolationKeyProvider : HostedSessionIsolationKeyProvider
-{
-    /// <inheritdoc />
-    public override ValueTask<HostedSessionContext?> GetKeysAsync(
-        ResponseContext context,
-        CreateResponse request,
-        CancellationToken cancellationToken)
-    {
-        var userKey = context?.Isolation?.UserIsolationKey;
-        var chatKey = context?.Isolation?.ChatIsolationKey;
-
-        if (string.IsNullOrWhiteSpace(userKey) || string.IsNullOrWhiteSpace(chatKey))
-        {
-            return new ValueTask<HostedSessionContext?>((HostedSessionContext?)null);
-        }
-
-        return new ValueTask<HostedSessionContext?>(new HostedSessionContext(userKey!, chatKey!));
-    }
-}

dotnet/src/Microsoft.Agents.AI.Harness/HarnessAgent.cs

@@ -17,7 +17,6 @@ namespace Microsoft.Agents.AI;
 /// <see cref="HarnessAgent"/> assembles the following pipeline from a caller-supplied <see cref="IChatClient"/>:
 /// <list type="number">
 /// <item><description><see cref="FunctionInvokingChatClient"/> — automatic function/tool invocation.</description></item>
-/// <item><description><see cref="MessageInjectingChatClient"/> — allows external code to inject messages into the conversation mid-stream.</description></item>
 /// <item><description><see cref="PerServiceCallChatHistoryPersistingChatClient"/> — persists chat history after every individual service call within a function-invocation loop.</description></item>
 /// <item><description><see cref="AIContextProviderChatClient"/> with a <see cref="CompactionProvider"/> — applies context-window compaction before each call so long function-invocation loops do not overflow the context window.</description></item>
 /// </list>
@@ -111,7 +110,6 @@ public sealed class HarnessAgent : DelegatingAIAgent
         return chatClient
             .AsBuilder()
             .UseFunctionInvocation()
-            .UseMessageInjection()
             .UsePerServiceCallChatHistoryPersistence()
             .UseAIContextProviders(compactionProvider)
             .BuildAIAgent(new ChatClientAgentOptions

dotnet/src/Microsoft.Agents.AI.OpenAI/Extensions/OpenAIResponseClientExtensions.cs

@@ -120,24 +120,9 @@ public static class OpenAIResponseClientExtensions
         return Throw.IfNull(responseClient)
             .AsIChatClient(model)
             .AsBuilder()
-            .ConfigureOptions(x =>
-            {
-                var previousFactory = x.RawRepresentationFactory;
-                x.RawRepresentationFactory = state =>
-                {
-                    var responseOptions = previousFactory?.Invoke(state) as CreateResponseOptions ?? new CreateResponseOptions();
-
-                    responseOptions.StoredOutputEnabled = false;
-
-                    if (includeReasoningEncryptedContent &&
-                        !responseOptions.IncludedProperties.Contains(IncludedResponseProperty.ReasoningEncryptedContent))
-                    {
-                        responseOptions.IncludedProperties.Add(IncludedResponseProperty.ReasoningEncryptedContent);
-                    }
-
-                    return responseOptions;
-                };
-            })
+            .ConfigureOptions(x => x.RawRepresentationFactory = _ => includeReasoningEncryptedContent
+                ? new CreateResponseOptions() { StoredOutputEnabled = false, IncludedProperties = { IncludedResponseProperty.ReasoningEncryptedContent } }
+                : new CreateResponseOptions() { StoredOutputEnabled = false })
             .Build();
     }
 }

dotnet/src/Microsoft.Agents.AI.Workflows.Declarative.Mcp/DefaultMcpToolHandler.cs

@@ -3,15 +3,12 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
-using System.IO;
 using System.Linq;
 using System.Net.Http;
 using System.Text;
-using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.AI;
-using Microsoft.Shared.Diagnostics;
 using ModelContextProtocol.Client;
 using ModelContextProtocol.Protocol;
 
@@ -27,14 +24,6 @@ namespace Microsoft.Agents.AI.Workflows.Declarative.Mcp;
 /// </remarks>
 public sealed class DefaultMcpToolHandler : IMcpToolHandler, IAsyncDisposable
 {
-    /// <summary>
-    /// Reserved <c>toolName</c> value that maps an <see cref="IMcpToolHandler.InvokeToolAsync"/> request
-    /// to the MCP protocol <c>tools/list</c> discovery operation.
-    /// </summary>
-    public const string ListToolsToolName = "tools/list";
-
-    private static readonly JsonWriterOptions s_toolListJsonWriterOptions = new() { Indented = true };
-
     private readonly Func<string, CancellationToken, Task<HttpClient?>>? _httpClientProvider;
     private readonly Dictionary<string, McpClient> _clients = [];
     private readonly Dictionary<string, HttpClient> _ownedHttpClients = [];
@@ -64,17 +53,8 @@ public sealed class DefaultMcpToolHandler : IMcpToolHandler, IAsyncDisposable
         CancellationToken cancellationToken = default)
     {
         // TODO: Handle connectionName and server label appropriately when Hosted scenario supports them. For now, ignore
-        if (IsListToolsToolName(toolName))
-        {
-            ThrowIfListToolsArgumentsSpecified(arguments);
-            McpClient listToolsClient = await this.GetOrCreateClientAsync(serverUrl, serverLabel, headers, cancellationToken).ConfigureAwait(false);
-            IList<McpClientTool> tools = await listToolsClient.ListToolsAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
-            return CreateListToolsResultContent(tools.Select(tool => tool.ProtocolTool));
-        }
-
-        McpClient client = await this.GetOrCreateClientAsync(serverUrl, serverLabel, headers, cancellationToken).ConfigureAwait(false);
-
         McpServerToolResultContent resultContent = new(Guid.NewGuid().ToString());
+        McpClient client = await this.GetOrCreateClientAsync(serverUrl, serverLabel, headers, cancellationToken).ConfigureAwait(false);
 
         // Convert IDictionary to IReadOnlyDictionary for CallToolAsync
         IReadOnlyDictionary<string, object?>? readOnlyArguments = arguments is null
@@ -92,23 +72,6 @@ public sealed class DefaultMcpToolHandler : IMcpToolHandler, IAsyncDisposable
         return resultContent;
     }
 
-    internal static bool IsListToolsToolName(string toolName) =>
-        string.Equals(toolName, ListToolsToolName, StringComparison.Ordinal);
-
-    internal static McpServerToolResultContent CreateListToolsResultContent(IEnumerable<Tool> tools)
-    {
-        Throw.IfNull(tools);
-
-        McpServerToolResultContent resultContent = new(Guid.NewGuid().ToString())
-        {
-            Outputs = []
-        };
-
-        resultContent.Outputs.Add(new TextContent(SerializeToolsList(tools)));
-
-        return resultContent;
-    }
-
     /// <inheritdoc/>
     public async ValueTask DisposeAsync()
     {
@@ -220,16 +183,6 @@ public sealed class DefaultMcpToolHandler : IMcpToolHandler, IAsyncDisposable
         return hashCode.ToString(CultureInfo.InvariantCulture);
     }
 
-    private static void ThrowIfListToolsArgumentsSpecified(IDictionary<string, object?>? arguments)
-    {
-        if (arguments is { Count: > 0 })
-        {
-            throw new ArgumentException(
-                $"The reserved MCP '{ListToolsToolName}' operation does not accept tool arguments.",
-                nameof(arguments));
-        }
-    }
-
     private static void PopulateResultContent(McpServerToolResultContent resultContent, CallToolResult result)
     {
         // Ensure Outputs list is initialized
@@ -277,17 +230,6 @@ public sealed class DefaultMcpToolHandler : IMcpToolHandler, IAsyncDisposable
             TextContentBlock text => new TextContent(text.Text),
             ImageContentBlock image => CreateDataContent(image.Data, image.MimeType ?? "image/*"),
             AudioContentBlock audio => CreateDataContent(audio.Data, audio.MimeType ?? "audio/*"),
-            EmbeddedResourceBlock embedded => ConvertEmbeddedResource(embedded),
-            _ => new TextContent(block.ToString() ?? string.Empty),
-        };
-    }
-
-    private static AIContent ConvertEmbeddedResource(EmbeddedResourceBlock block)
-    {
-        return block.Resource switch
-        {
-            TextResourceContents text => new TextContent(text.Text),
-            BlobResourceContents blob => CreateDataContent(blob.Blob, blob.MimeType ?? "application/octet-stream"),
             _ => new TextContent(block.ToString() ?? string.Empty),
         };
     }
@@ -313,39 +255,4 @@ public sealed class DefaultMcpToolHandler : IMcpToolHandler, IAsyncDisposable
 
         return new DataContent($"data:{mediaType};base64,{base64}", mediaType);
     }
-
-    private static string SerializeToolsList(IEnumerable<Tool> tools)
-    {
-        using MemoryStream stream = new();
-        using (Utf8JsonWriter writer = new(stream, s_toolListJsonWriterOptions))
-        {
-            writer.WriteStartObject();
-            writer.WriteStartArray("tools");
-
-            foreach (Tool tool in tools)
-            {
-                writer.WriteStartObject();
-                writer.WriteString("name", tool.Name);
-                writer.WriteString("description", tool.Description);
-                writer.WritePropertyName("inputSchema");
-                tool.InputSchema.WriteTo(writer);
-                writer.WritePropertyName("outputSchema");
-                if (tool.OutputSchema is JsonElement outputSchema)
-                {
-                    outputSchema.WriteTo(writer);
-                }
-                else
-                {
-                    writer.WriteNullValue();
-                }
-
-                writer.WriteEndObject();
-            }
-
-            writer.WriteEndArray();
-            writer.WriteEndObject();
-        }
-
-        return Encoding.UTF8.GetString(stream.GetBuffer(), 0, (int)stream.Length);
-    }
 }

dotnet/src/Microsoft.Agents.AI.Workflows/HandoffWorkflowBuilder.cs

@@ -54,8 +54,6 @@ public class HandoffWorkflowBuilderCore<TBuilder> where TBuilder : HandoffWorkfl
     private bool _emitAgentResponseUpdateEvents;
     private HandoffToolCallFilteringBehavior _toolCallFilteringBehavior = HandoffToolCallFilteringBehavior.HandoffOnly;
     private bool _returnToPrevious;
-    private string? _name;
-    private string? _description;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="HandoffsWorkflowBuilder"/> class with no handoff relationships.
@@ -99,20 +97,6 @@ public class HandoffWorkflowBuilderCore<TBuilder> where TBuilder : HandoffWorkfl
         return (TBuilder)this;
     }
 
-    /// <inheritdoc cref="WorkflowBuilder.WithName(string)"/>
-    public TBuilder WithName(string name)
-    {
-        this._name = name;
-        return (TBuilder)this;
-    }
-
-    /// <inheritdoc cref="WorkflowBuilder.WithDescription(string)"/>
-    public TBuilder WithDescription(string description)
-    {
-        this._description = description;
-        return (TBuilder)this;
-    }
-
     /// <summary>
     /// Sets a value indicating whether agent streaming update events should be emitted during execution.
     /// If <see langword="null"/>, the value will be taken from the <see cref="TurnToken"/>
@@ -346,16 +330,7 @@ public class HandoffWorkflowBuilderCore<TBuilder> where TBuilder : HandoffWorkfl
             builder.AddEdge(start, executors[this._initialAgent.Id]);
         }
 
-        if (!string.IsNullOrWhiteSpace(this._name))
-        {
-            builder.WithName(this._name);
-        }
-
-        if (!string.IsNullOrWhiteSpace(this._description))
-        {
-            builder.WithDescription(this._description);
-        }
-
+        // Build the workflow.
         return builder.WithOutputFrom(end).Build();
     }
 }

dotnet/src/Microsoft.Agents.AI.Workflows/MagenticWorkflowBuilder.cs

@@ -1,6 +1,5 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Threading.Tasks;
@@ -141,15 +140,7 @@ public class MagenticWorkflowBuilder(AIAgent managerAgent)
     }
 
     /// <inheritdoc cref="WorkflowBuilder.Build"/>
-    public Workflow Build()
-    {
-        if (this._team.Count == 0)
-        {
-            throw new InvalidOperationException("At least one participant must be added via AddParticipants() before building the workflow.");
-        }
-
-        return this.ReduceToWorkflowBuilder().Build();
-    }
+    public Workflow Build() => this.ReduceToWorkflowBuilder().Build();
 
     private TaskLimits Limits => new(
         MaxRoundCount: this._maxRounds,

dotnet/src/Microsoft.Agents.AI.Workflows/Specialized/Magentic/MagenticOrchestrator.cs

@@ -101,7 +101,6 @@ internal class MagenticOrchestrator(AIAgent managerAgent, List<AIAgent> team, Ta
         return base.ConfigureProtocol(protocolBuilder)
                    .SendsMessage<ChatMessage>()
                    .SendsMessage<ResetChatSignal>()
-                   .YieldsOutput<List<ChatMessage>>()
                    .ConfigureRoutes(ConfigureRoutes);
 
         void ConfigureRoutes(RouteBuilder routeBuilder) => routeBuilder.AddPortHandler<MagenticPlanReviewRequest, MagenticPlanReviewResponse>(
@@ -110,7 +109,7 @@ internal class MagenticOrchestrator(AIAgent managerAgent, List<AIAgent> team, Ta
                 out this._planReviewPort);
     }
 
-    private ValueTask SubmitPlanReviewRequestAsync(MagenticTaskContext taskContext, IWorkflowContext workflowContext, bool replanAfterStall = false)
+    private ValueTask SubmitPlanReviewRequestAsync(MagenticTaskContext taskContext, IWorkflowContext workflowContext)
     {
         MagenticProgressLedger? progressLedger = taskContext.ProgressLedger;
         if (progressLedger?.IsStarted is not true)
@@ -118,7 +117,7 @@ internal class MagenticOrchestrator(AIAgent managerAgent, List<AIAgent> team, Ta
             progressLedger = null;
         }
 
-        MagenticPlanReviewRequest request = new(taskContext.TaskLedger!.CurrentPlan, progressLedger, replanAfterStall);
+        MagenticPlanReviewRequest request = new(taskContext.TaskLedger!.CurrentPlan, progressLedger, taskContext.IsStalled);
 
         return this._planReviewPort!.PostRequestAsync(request);
     }
@@ -147,7 +146,7 @@ internal class MagenticOrchestrator(AIAgent managerAgent, List<AIAgent> team, Ta
 
         if (this._taskContext.IsTerminated)
         {
-            throw new InvalidOperationException("This Magentic orchestration has already terminated. To process new messages, create a new workflow instance.");
+            throw new InvalidOperationException("Magentic Orchestration has already been terminated and cannot process new messages. Please start a new session.");
         }
 
         if (response.IsApproved)
@@ -162,7 +161,7 @@ internal class MagenticOrchestrator(AIAgent managerAgent, List<AIAgent> team, Ta
         }
     }
 
-    private async ValueTask UpdatePlanAndDelegateAsync(MagenticTaskContext taskContext, IWorkflowContext context, CancellationToken cancellationToken, bool replanAfterStall = false)
+    private async ValueTask UpdatePlanAndDelegateAsync(MagenticTaskContext taskContext, IWorkflowContext context, CancellationToken cancellationToken)
     {
         bool isReplan = taskContext.TaskLedger != null;
 
@@ -178,7 +177,7 @@ internal class MagenticOrchestrator(AIAgent managerAgent, List<AIAgent> team, Ta
 
         if (requirePlanSignoff)
         {
-            await this.SubmitPlanReviewRequestAsync(taskContext, context, replanAfterStall).ConfigureAwait(false);
+            await this.SubmitPlanReviewRequestAsync(taskContext, context).ConfigureAwait(false);
         }
         else
         {
@@ -188,22 +187,9 @@ internal class MagenticOrchestrator(AIAgent managerAgent, List<AIAgent> team, Ta
 
     protected override async ValueTask TakeTurnAsync(List<ChatMessage> messages, IWorkflowContext context, bool? emitEvents, CancellationToken cancellationToken = default)
     {
-        if (this._taskContext?.IsTerminated == true)
-        {
-            throw new InvalidOperationException("This Magentic orchestration has already terminated. To process new messages, create a new workflow instance.");
-        }
-
-        if (this._taskContext == null)
-        {
-            // First Turn: Initialize the task context and create the initial plan
-            this._taskContext = new(messages, team, limits, emitEvents, []);
-            await this.UpdatePlanAndDelegateAsync(this._taskContext, context, cancellationToken).ConfigureAwait(false);
-        }
-        else
-        {
-            // Subsequent turns: agent returned control, go directly to coordination (progress ledger only, no replan)
-            await this.RunCoordinationRoundAsync(this._taskContext, context, cancellationToken).ConfigureAwait(false);
-        }
+        // First Turn: Initialize the task context and send the initial messages to the planner agent
+        this._taskContext ??= new(messages, team, limits, emitEvents, []);
+        await this.UpdatePlanAndDelegateAsync(this._taskContext, context, cancellationToken).ConfigureAwait(false);
     }
 
     private ChatMessage? _fullTaskLedgerMessage;
@@ -302,11 +288,10 @@ internal class MagenticOrchestrator(AIAgent managerAgent, List<AIAgent> team, Ta
 
     private async ValueTask ResetAndReplanAsync(MagenticTaskContext taskContext, IWorkflowContext context, CancellationToken cancellationToken)
     {
-        bool wasStalled = taskContext.IsStalled;
         taskContext.Reset();
         await context.SendMessageAsync(new ResetChatSignal(), cancellationToken: cancellationToken).ConfigureAwait(false);
 
-        await this.UpdatePlanAndDelegateAsync(taskContext, context, cancellationToken, replanAfterStall: wasStalled).ConfigureAwait(false);
+        await this.UpdatePlanAndDelegateAsync(taskContext, context, cancellationToken).ConfigureAwait(false);
     }
 
     private async ValueTask PrepareFinalAnswerAsync(MagenticTaskContext taskContext, IWorkflowContext context, CancellationToken cancellationToken)

dotnet/src/Microsoft.Agents.AI.Workflows/Specialized/Magentic/MagenticTaskContext.cs

@@ -58,7 +58,7 @@ internal class MagenticTaskContext(List<ChatMessage> taskDefinition, List<AIAgen
 
     public bool IsTerminated { get; internal set; }
 
-    public bool IsStalled => this.TaskCounters.StallCount > this.TaskLimits.MaxStallCount;
+    public bool IsStalled => this.TaskCounters.StallCount >= this.TaskLimits.MaxStallCount;
 
     public (bool HitRoundLimit, bool HitResetLimit) CheckLimits()
     {

dotnet/src/Microsoft.Agents.AI.Workflows/SwitchBuilder.cs

@@ -36,13 +36,9 @@ public sealed class SwitchBuilder
         Throw.IfNull(executors);
 
         HashSet<int> indicies = [];
-        int executorIndex = 0;
 
         foreach (ExecutorBinding executor in executors)
         {
-            // Explicit name: null element inside the collection argument.
-            Throw.IfNull(executor, $"{nameof(executors)}[{executorIndex++}]");
-
             if (!this._executorIndicies.TryGetValue(executor.Id, out int index))
             {
                 index = this._executors.Count;
@@ -68,13 +64,8 @@ public sealed class SwitchBuilder
     {
         Throw.IfNull(executors);
 
-        int executorIndex = 0;
-
         foreach (ExecutorBinding executor in executors)
         {
-            // Explicit name: null element inside the collection argument.
-            Throw.IfNull(executor, $"{nameof(executors)}[{executorIndex++}]");
-
             if (!this._executorIndicies.TryGetValue(executor.Id, out int index))
             {
                 index = this._executors.Count;

dotnet/src/Microsoft.Agents.AI.Workflows/WorkflowBuilderExtensions.cs

@@ -25,11 +25,7 @@ public static class WorkflowBuilderExtensions
     /// <param name="target">The target executor to which messages will be forwarded.</param>
     /// <returns>The updated <see cref="WorkflowBuilder"/> instance.</returns>
     public static WorkflowBuilder ForwardMessage<TMessage>(this WorkflowBuilder builder, ExecutorBinding source, ExecutorBinding target)
-    {
-        Throw.IfNull(target, nameof(target));
-
-        return builder.ForwardMessage<TMessage>(source, [target], condition: null);
-    }
+        => builder.ForwardMessage<TMessage>(source, [target], condition: null);
 
     /// <summary>
     /// Adds edges to the workflow that forward messages of the specified type from the source executor to
@@ -56,8 +52,6 @@ public static class WorkflowBuilderExtensions
     /// <returns>The updated <see cref="WorkflowBuilder"/> instance.</returns>
     public static WorkflowBuilder ForwardMessage<TMessage>(this WorkflowBuilder builder, ExecutorBinding source, IEnumerable<ExecutorBinding> targets, Func<TMessage, bool>? condition = null)
     {
-        Throw.IfNull(builder);
-        Throw.IfNull(source);
         Throw.IfNull(targets);
 
         Func<object?, bool> predicate = WorkflowBuilder.CreateConditionFunc<TMessage>(IsAllowedTypeAndMatchingCondition)!;
@@ -68,16 +62,14 @@ public static class WorkflowBuilderExtensions
         if (targets is ICollection<ExecutorBinding> { Count: 1 })
 #endif
         {
-            return builder.AddEdge(source, Throw.IfNull(targets.First(), nameof(targets)), predicate);
+            return builder.AddEdge(source, targets.First(), predicate);
         }
 
-        return builder.AddSwitch(source, (switch_) => switch_.AddCase(predicate, targets.Select(ValidateTarget)));
+        return builder.AddSwitch(source, (switch_) => switch_.AddCase(predicate, targets));
 
         // The reason we can check for "not null" here is that CreateConditionFunc<T> will do the correct unwrapping
         // logic for PortableValues.
         bool IsAllowedTypeAndMatchingCondition(TMessage? message) => message != null && (condition == null || condition(message));
-
-        ExecutorBinding ValidateTarget(ExecutorBinding target) => Throw.IfNull(target, nameof(targets));
     }
 
     /// <summary>
@@ -89,11 +81,7 @@ public static class WorkflowBuilderExtensions
     /// <param name="target">The target executor to which messages, except those of type <typeparamref name="TMessage"/>, will be forwarded.</param>
     /// <returns>The updated <see cref="WorkflowBuilder"/> instance with the added edges.</returns>
     public static WorkflowBuilder ForwardExcept<TMessage>(this WorkflowBuilder builder, ExecutorBinding source, ExecutorBinding target)
-    {
-        Throw.IfNull(target, nameof(target));
-
-        return builder.ForwardExcept<TMessage>(source, [target]);
-    }
+        => builder.ForwardExcept<TMessage>(source, [target]);
 
     /// <summary>
     /// Adds edges from the specified source to the provided executors, excluding messages of a specified type.
@@ -105,8 +93,6 @@ public static class WorkflowBuilderExtensions
     /// <returns>The updated <see cref="WorkflowBuilder"/> instance with the added edges.</returns>
     public static WorkflowBuilder ForwardExcept<TMessage>(this WorkflowBuilder builder, ExecutorBinding source, IEnumerable<ExecutorBinding> targets)
     {
-        Throw.IfNull(builder);
-        Throw.IfNull(source);
         Throw.IfNull(targets);
 
         Func<object?, bool> predicate = WorkflowBuilder.CreateConditionFunc<TMessage>((Func<object?, bool>)IsAllowedType)!;
@@ -117,16 +103,14 @@ public static class WorkflowBuilderExtensions
         if (targets is ICollection<ExecutorBinding> { Count: 1 })
 #endif
         {
-            return builder.AddEdge(source, Throw.IfNull(targets.First(), nameof(targets)), predicate);
+            return builder.AddEdge(source, targets.First(), predicate);
         }
 
-        return builder.AddSwitch(source, (switch_) => switch_.AddCase(predicate, targets.Select(ValidateTarget)));
+        return builder.AddSwitch(source, (switch_) => switch_.AddCase(predicate, targets));
 
         // The reason we can check for "null" here is that CreateConditionFunc<T> will do the correct unwrapping
         // logic for PortableValues.
         static bool IsAllowedType(object? message) => message is null;
-
-        ExecutorBinding ValidateTarget(ExecutorBinding target) => Throw.IfNull(target, nameof(targets));
     }
 
     /// <summary>
@@ -145,7 +129,6 @@ public static class WorkflowBuilderExtensions
     {
         Throw.IfNull(builder);
         Throw.IfNull(source);
-        Throw.IfNull(executors);
 
         HashSet<string> seenExecutors = [source.Id];
 

dotnet/tests/Foundry.Hosting.IntegrationTests.TestContainer/Program.cs

@@ -7,7 +7,6 @@ using Azure.Identity;
 using Azure.Search.Documents;
 using Azure.Search.Documents.Models;
 using Microsoft.Agents.AI;
-using Microsoft.Agents.AI.Foundry;
 using Microsoft.Agents.AI.Foundry.Hosting;
 using Microsoft.Extensions.AI;
 
@@ -35,7 +34,6 @@ AIAgent agent = scenario switch
     "tool-calling-approval" => CreateToolCallingApprovalAgent(projectClient, deployment),
     "mcp-toolbox" => CreateMcpToolboxAgent(projectClient, deployment),
     "custom-storage" => CreateCustomStorageAgent(projectClient, deployment),
-    "memory" => await CreateMemoryAgentAsync(projectClient, deployment).ConfigureAwait(false),
     "azure-search-rag" => CreateAzureSearchRagAgent(projectClient, deployment),
     "session-files" => CreateSessionFilesAgent(projectClient, deployment),
     _ => throw new InvalidOperationException($"Unknown IT_SCENARIO '{scenario}'.")
@@ -181,34 +179,6 @@ static AIAgent CreateSessionFilesAgent(AIProjectClient client, string deployment
             AIFunctionFactory.Create(ReadFile)
         ]);
 
-// Memory scenario. The agent uses FoundryMemoryProvider scoped per user via the
-// HostedSessionContext that the hosting layer applies from the platform isolation headers.
-// In production the platform sets the headers; here we rely on the default
-// PlatformHostedSessionIsolationKeyProvider that AgentFrameworkResponseHandler resolves.
-static async Task<AIAgent> CreateMemoryAgentAsync(AIProjectClient client, string deployment)
-{
-    var embedding = Environment.GetEnvironmentVariable("AZURE_AI_EMBEDDING_DEPLOYMENT_NAME") ?? "text-embedding-ada-002";
-    var memoryStoreName = Environment.GetEnvironmentVariable("IT_MEMORY_STORE_ID") ?? "it-memory-store";
-
-    var memoryProvider = new FoundryMemoryProvider(
-        client,
-        memoryStoreName,
-        stateInitializer: HostedFoundryMemoryProviderScopes.PerUser());
-
-    await memoryProvider.EnsureMemoryStoreCreatedAsync(deployment, embedding, "Memory store for hosted-memory IT scenario.").ConfigureAwait(false);
-
-    return client.AsAIAgent(new ChatClientAgentOptions
-    {
-        Name = "memory-agent",
-        ChatOptions = new ChatOptions
-        {
-            ModelId = deployment,
-            Instructions = "You are a friendly travel assistant. Use known memories about the user when responding, and do not invent details."
-        },
-        AIContextProviders = [memoryProvider]
-    });
-}
-
 [Description("Returns the current UTC date and time as an ISO 8601 string.")]
 static string GetUtcNow() => DateTime.UtcNow.ToString("o");
 

dotnet/tests/Foundry.Hosting.IntegrationTests/Fixtures/MemoryHostedAgentFixture.cs

@@ -1,28 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System;
-using System.Collections.Generic;
-
-namespace Foundry.Hosting.IntegrationTests.Fixtures;
-
-/// <summary>
-/// Provisions a hosted agent that runs the test container in <c>IT_SCENARIO=memory</c> mode.
-/// Used by tests that exercise <see cref="Microsoft.Agents.AI.Foundry.FoundryMemoryProvider"/>
-/// running inside the Foundry hosted agent. The memory store name is randomised per fixture
-/// instance so concurrent test runs do not share state.
-/// </summary>
-public sealed class MemoryHostedAgentFixture : HostedAgentFixture
-{
-    protected override string ScenarioName => "memory";
-
-    /// <summary>
-    /// Memory store name passed to the test container via <c>IT_MEMORY_STORE_ID</c> so that each
-    /// fixture instance gets a fresh, isolated bucket of memories.
-    /// </summary>
-    public string MemoryStoreId { get; } = $"it-memory-{Guid.NewGuid():N}";
-
-    protected override void ConfigureEnvironment(IDictionary<string, string> environment)
-    {
-        environment["IT_MEMORY_STORE_ID"] = this.MemoryStoreId;
-    }
-}

dotnet/tests/Foundry.Hosting.IntegrationTests/MemoryHostedAgentTests.cs

@@ -1,79 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System;
-using System.Threading.Tasks;
-using Foundry.Hosting.IntegrationTests.Fixtures;
-using Microsoft.Agents.AI;
-
-#pragma warning disable OPENAI001 // Experimental Responses API surfaces
-
-namespace Foundry.Hosting.IntegrationTests;
-
-/// <summary>
-/// Validates the Hosted-MemoryAgent end-to-end against a deployed test container running the
-/// <c>IT_SCENARIO=memory</c> scenario. Asserts that <see cref="Microsoft.Agents.AI.Foundry.FoundryMemoryProvider"/>
-/// scoped via <see cref="Microsoft.Agents.AI.Foundry.Hosting.HostedSessionContext"/> recalls user
-/// preferences across multiple turns of a conversation.
-/// </summary>
-[Trait("Category", "FoundryHostedAgents")]
-public sealed class MemoryHostedAgentTests(MemoryHostedAgentFixture fixture) : IClassFixture<MemoryHostedAgentFixture>
-{
-    private readonly MemoryHostedAgentFixture _fixture = fixture;
-
-    [Fact]
-    public async Task Memory_RecallsAcrossTurnsAsync()
-    {
-        // Arrange
-        var agent = this._fixture.Agent;
-        var session = await agent.CreateSessionAsync();
-
-        // Act: teach the agent two pieces of information about the user.
-        var first = await agent.RunAsync("My name is Taylor and I am planning a hiking trip to Patagonia in November.", session);
-        Assert.False(string.IsNullOrWhiteSpace(first.Text));
-
-        var second = await agent.RunAsync("I am travelling with my sister and we love finding scenic viewpoints.", session);
-        Assert.False(string.IsNullOrWhiteSpace(second.Text));
-
-        // FoundryMemoryProvider defaults to UpdateDelay=0 (immediate trigger). Server-side ingestion
-        // typically completes within ~3 seconds; allow a small margin.
-        await Task.Delay(TimeSpan.FromSeconds(5));
-
-        var recall = await agent.RunAsync("What do you already know about my upcoming trip?", session);
-
-        // Assert
-        Assert.Contains("Patagonia", recall.Text, StringComparison.OrdinalIgnoreCase);
-    }
-
-    [Fact(Skip = "Foundry Memory write propagation is eventually consistent and the in-container WhenUpdatesCompletedAsync flush hook is not callable from the test process; this scenario is exercised manually via the sample's smoke.ps1.")]
-    public async Task Memory_PersistsAcrossSessionsForSameUserAsync()
-    {
-        // Arrange: drive a session that establishes some user-private memory. Foundry Memory
-        // extracts memories more reliably from multi-turn conversations than from a single
-        // imperative utterance, so mirror the sample's two-turn teaching pattern.
-        var agent = this._fixture.Agent;
-        var teachingSession = await agent.CreateSessionAsync();
-        await agent.RunAsync("My preferred airline is Iberia and I always fly business class.", teachingSession);
-        await agent.RunAsync("I also prefer aisle seats whenever they are available.", teachingSession);
-
-        // FoundryMemoryProvider defaults to UpdateDelay=0 (immediate trigger). Server-side
-        // ingestion typically completes within ~3 seconds; poll a fresh-session recall a few
-        // times before failing so the test does not flake on cold caches.
-        AgentResponse recall = null!;
-        const int MaxAttempts = 6;
-        for (var attempt = 1; attempt <= MaxAttempts; attempt++)
-        {
-            await Task.Delay(TimeSpan.FromSeconds(5));
-
-            var freshSession = await agent.CreateSessionAsync();
-            recall = await agent.RunAsync("Which airline do I prefer? Reply with just the airline name.", freshSession);
-
-            if (recall.Text.Contains("Iberia", StringComparison.OrdinalIgnoreCase))
-            {
-                break;
-            }
-        }
-
-        // Assert
-        Assert.Contains("Iberia", recall.Text, StringComparison.OrdinalIgnoreCase);
-    }
-}

dotnet/tests/Foundry.Hosting.IntegrationTests/scripts/it-bootstrap-agents.ps1

@@ -45,7 +45,6 @@ $Scenarios = @(
     'tool-calling-approval',
     'mcp-toolbox',
     'custom-storage',
-    'memory',
     'azure-search-rag',
     'session-files'
 )