feat(moa): stream the aggregator response to the user

[lEWFkRAD]

What does this PR do?

Makes Mixture-of-Agents (MoA) sessions stream the aggregator's response to the
user. Today MoA can't stream: the gateway streaming toggle is a no-op for
provider: moa, so the user sees nothing until the entire response finishes —
minutes of silence on long turns — because the aggregator's reply is always
fetched whole.

Two causes: (1) conversation_loop hard-disables streaming for
provider in {"copilot-acp", "moa"}, and (2) MoAChatCompletions.create()
fetches the aggregator response whole via call_llm(), which had no streaming
mode.

For provider: moa, _create_request_openai_client() returns the MoAClient
facade itself, so the existing streaming consumer already invokes
MoAChatCompletions.create(stream=True). This PR reuses that battle-tested
consumer (text-delta delivery, tool-call reassembly, stale-stream detection,
non-streaming fallback) rather than adding a parallel streaming path — so the
change is small and low-risk.

Related Issue

No existing issue — happy to open one if preferred.

Fixes #

Type of Change

• 🐛 Bug fix (non-breaking change that fixes an issue)
• ✨ New feature (non-breaking change that adds functionality)
• 🔒 Security fix
• 📝 Documentation update
• ✅ Tests (adding or improving test coverage)
• ♻️ Refactor (no behavior change)
• 🎯 New skill (bundled or hub)

Changes Made

• agent/auxiliary_client.py — call_llm() gains stream/stream_options.
  When streaming it returns the raw SDK stream iterator directly, bypassing
  _validate_llm_response and the temperature/max_tokens/payment fallback chain
  (which assume a complete response). The caller owns reassembly and fallback.
• agent/moa_loop.py — MoAChatCompletions.create() runs the references first
  (unchanged), then when stream=True returns the aggregator's raw stream,
  forwarding stream_options and the consumer's per-request read timeout.
  stream=False is byte-identical to before (no stream/stream_options/timeout
  forwarded).
• agent/conversation_loop.py — MoA streams only when a display/TTS consumer is
  present; quiet/subagent/health-check paths keep the complete-response path,
  preserving prior behavior (and the existing _create_request_openai_client
  guard test).
• tests/run_agent/test_moa_streaming.py — new tests (below).

How to Test

1. Configure a MoA preset and run an interactive turn (provider: moa) with a
   display consumer attached — the aggregator's output now appears
   incrementally instead of all at once when the turn completes.
2. Confirm the references still run before the aggregator (MoA not bypassed), and
   that tool-calling still works under streaming (the reused consumer reassembles
   tool_calls).
3. Quiet mode / subagents are unchanged (no consumer → complete-response path).
4. Run the tests: pytest tests/run_agent/test_moa_streaming.py tests/run_agent/test_moa_loop_mode.py -q

Checklist

Code

• I've read the Contributing Guide
• My commit messages follow Conventional Commits (feat(moa): ...)
• I searched for existing PRs to make sure this isn't a duplicate
• My PR contains only changes related to this fix/feature (no unrelated commits)
• I've run pytest tests/ -q and all tests pass (the MoA suites; 20 passed)
• I've added tests for my changes
• I've tested on my platform: Windows 11

Documentation & Housekeeping

• I've updated relevant documentation (docstrings on call_llm and the
  changed methods) — no user-facing docs reference MoA streaming
• I've updated cli-config.yaml.example if I added/changed config keys — N/A
  (no new config keys; reuses existing streaming behavior)
• I've updated CONTRIBUTING.md or AGENTS.md if I changed architecture or
  workflows — N/A
• I've considered cross-platform impact — N/A (pure Python, no platform-specific code)
• I've updated tool descriptions/schemas if I changed tool behavior — N/A

Screenshots / Logs

Verified live on a local llama.cpp MoA stack: a plain turn streamed 74 incremental
content chunks (previously one buffered block); references still fired; a
tool-calling turn streamed and executed the tool with no errors.

[tonydwb]

Code Review Summary

Verdict: Approved

MoA aggregator streaming response (4 files). Clean feature extension:

• New stream and stream_options parameters on call_llm
• Streaming path returns raw SDK iterator directly (bypasses response validation)
• Conversation loop integration for streaming MoA aggregator output
• Clear docstring explaining the streaming contract and fallback ownership

Well-scoped streaming extension. The deliberate skip of validation on the streaming path is correct — the caller owns chunk reassembly.

[teknium1]

Merged via #55625 — your commit was cherry-picked onto current main with your authorship preserved in git log (commit on main under your name). One small conflict resolved during salvage: the call_llm signature also gained an api_mode kwarg from an earlier MoA fix (#55579), so both kwargs now coexist. Thanks for the clean, low-risk approach — reusing the existing streaming consumer was exactly right.