fix(showcase): agno reasoning, ms-agent-python slots/multimodal, mastra subagents

- agno: custom _run_reasoning_agent handler emitting proper
  REASONING_MESSAGE AG-UI events (Agno's stock handler only emits
  STEP_STARTED/FINISHED which CopilotKit ignores); disable reasoning=True
  to avoid multi-call CoT loop that breaks aimock fixtures
- ms-agent-python: wire chat-slots assistantMessage + disclaimer overrides;
  add missing public/demo-files/ (sample.png, sample.pdf)
- mastra: register byocHashbrownAgent in main route; rewrite subagents
  e2e test to match actual page structure

Author: jpr5

showcase/integrations/agno/src/agent_server.py

@@ -24,11 +24,17 @@
 from ag_ui.core import (
     BaseEvent,
     EventType,
+    ReasoningMessageContentEvent,
+    ReasoningMessageEndEvent,
+    ReasoningMessageStartEvent,
     RunAgentInput,
     RunErrorEvent,
     RunFinishedEvent,
     RunStartedEvent,
     StateSnapshotEvent,
+    TextMessageContentEvent,
+    TextMessageEndEvent,
+    TextMessageStartEvent,
 )
 from ag_ui.core.types import Message as AGUIMessage
 from ag_ui.encoder import EventEncoder
@@ -451,6 +457,190 @@ async def _gen():
     app.post(route, name=f"agui_agent_config_{prefix.strip('/')}")(_handler)
 
 
+# ---------------------------------------------------------------------------
+# Reasoning-aware AGUI handler
+# ---------------------------------------------------------------------------
+#
+# Agno's stock AGUI handler emits STEP_STARTED/STEP_FINISHED events for
+# reasoning, not the REASONING_MESSAGE_* events that CopilotKit expects.
+# And reasoning=True triggers a multi-call CoT loop that breaks with
+# aimock/fixture environments.
+#
+# This custom handler:
+#   1. Runs the agent with reasoning=False (single LLM call)
+#   2. Collects the streamed text content
+#   3. Parses <reasoning>...</reasoning> tags from the text
+#   4. Emits REASONING_MESSAGE_* events for the reasoning block
+#   5. Emits TEXT_MESSAGE_* events for the answer
+#
+# If no <reasoning> tags are found, the entire response is emitted as a
+# text message (graceful fallback for aimock fixtures that return plain
+# text containing reasoning keywords).
+
+import re
+
+_REASONING_PATTERN = re.compile(
+    r"<reasoning>(.*?)</reasoning>",
+    re.DOTALL | re.IGNORECASE,
+)
+
+
+async def _run_reasoning_agent(
+    agent: Union[Agent, RemoteAgent], run_input: RunAgentInput
+) -> AsyncIterator[BaseEvent]:
+    """Stream one reasoning agent run, synthesizing REASONING_MESSAGE events."""
+    run_id = run_input.run_id or str(uuid.uuid4())
+    thread_id = run_input.thread_id
+
+    try:
+        user_input = extract_agui_user_input(run_input.messages or [])
+
+        yield RunStartedEvent(
+            type=EventType.RUN_STARTED, thread_id=thread_id, run_id=run_id
+        )
+
+        user_id: Optional[str] = None
+        if run_input.forwarded_props and isinstance(run_input.forwarded_props, dict):
+            user_id = run_input.forwarded_props.get("user_id")
+
+        session_state = validate_agui_state(run_input.state, thread_id) or {}
+
+        response_stream = agent.arun(  # type: ignore[attr-defined]
+            input=user_input,
+            session_id=thread_id,
+            stream=True,
+            stream_events=True,
+            user_id=user_id,
+            session_state=session_state,
+            run_id=run_id,
+        )
+
+        # Collect the full text from the agent stream — we need to see the
+        # complete response to split reasoning from answer. We still forward
+        # tool-call events in real-time (important for the reasoning-chain
+        # demo that interleaves reasoning with tool rendering).
+        full_text = ""
+        tool_events: list[BaseEvent] = []
+
+        async for event in async_stream_agno_response_as_agui_events(
+            response_stream=response_stream,  # type: ignore[arg-type]
+            thread_id=thread_id,
+            run_id=run_id,
+        ):
+            if event.type in (EventType.RUN_STARTED, EventType.RUN_FINISHED):
+                continue
+            # Accumulate text content
+            if event.type == EventType.TEXT_MESSAGE_CONTENT:
+                full_text += event.delta  # type: ignore[attr-defined]
+            # Forward tool-call events immediately
+            elif event.type in (
+                EventType.TOOL_CALL_START,
+                EventType.TOOL_CALL_ARGS,
+                EventType.TOOL_CALL_END,
+            ):
+                tool_events.append(event)
+            # Skip text start/end — we'll re-emit with reasoning split
+
+        # Parse <reasoning>...</reasoning> tags
+        match = _REASONING_PATTERN.search(full_text)
+
+        if match:
+            reasoning_text = match.group(1).strip()
+            answer_text = (
+                full_text[: match.start()] + full_text[match.end() :]
+            ).strip()
+        else:
+            # Fallback: check for "Reasoning:" prefix pattern (aimock fixtures)
+            lower = full_text.lower()
+            if lower.startswith("reasoning:") or lower.startswith("reasoning step"):
+                # Treat the whole text as containing reasoning — emit as
+                # reasoning message so the ReasoningBlock renders, then emit
+                # a short text answer.
+                reasoning_text = full_text.strip()
+                answer_text = ""
+            else:
+                reasoning_text = ""
+                answer_text = full_text.strip()
+
+        # Emit reasoning message if we have reasoning content
+        if reasoning_text:
+            reasoning_msg_id = str(uuid.uuid4())
+            yield ReasoningMessageStartEvent(
+                type=EventType.REASONING_MESSAGE_START,
+                message_id=reasoning_msg_id,
+                role="reasoning",
+            )
+            yield ReasoningMessageContentEvent(
+                type=EventType.REASONING_MESSAGE_CONTENT,
+                message_id=reasoning_msg_id,
+                delta=reasoning_text,
+            )
+            yield ReasoningMessageEndEvent(
+                type=EventType.REASONING_MESSAGE_END,
+                message_id=reasoning_msg_id,
+            )
+
+        # Emit text message for the answer (or entire text if no reasoning)
+        text_msg_id = str(uuid.uuid4())
+        # Only emit a text message if there's actual content or tool events
+        if answer_text or tool_events:
+            yield TextMessageStartEvent(
+                type=EventType.TEXT_MESSAGE_START,
+                message_id=text_msg_id,
+                role="assistant",
+            )
+            if answer_text:
+                yield TextMessageContentEvent(
+                    type=EventType.TEXT_MESSAGE_CONTENT,
+                    message_id=text_msg_id,
+                    delta=answer_text,
+                )
+            yield TextMessageEndEvent(
+                type=EventType.TEXT_MESSAGE_END,
+                message_id=text_msg_id,
+            )
+
+        # Emit any tool-call events that were collected
+        for te in tool_events:
+            yield te
+
+        yield RunFinishedEvent(
+            type=EventType.RUN_FINISHED, thread_id=thread_id, run_id=run_id
+        )
+
+    except asyncio.CancelledError:  # noqa: TRY302
+        raise
+    except Exception as exc:  # noqa: BLE001
+        yield RunErrorEvent(type=EventType.RUN_ERROR, message=str(exc))
+
+
+def _attach_reasoning_route(
+    app: FastAPI, agent: Agent, prefix: str
+) -> None:
+    """Mount a reasoning-aware AGUI POST endpoint at `<prefix>/agui`."""
+    encoder = EventEncoder()
+    route = f"{prefix.rstrip('/')}/agui"
+
+    async def _handler(run_input: RunAgentInput) -> StreamingResponse:
+        async def _gen():
+            async for event in _run_reasoning_agent(agent, run_input):
+                yield encoder.encode(event)
+
+        return StreamingResponse(
+            _gen(),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Methods": "POST, GET, OPTIONS",
+                "Access-Control-Allow-Headers": "*",
+            },
+        )
+
+    app.post(route, name=f"agui_reasoning_{prefix.strip('/')}")(_handler)
+
+
 # ---------------------------------------------------------------------------
 # AgentOS bootstrap
 # ---------------------------------------------------------------------------
@@ -474,7 +664,8 @@ async def _gen():
     interfaces=[
         # main_agent is mounted separately below via _attach_hitl_aware_route
         # so it can forward tool results for HITL round-trips.
-        AGUI(agent=reasoning_agent, prefix="/reasoning"),  # -> /reasoning/agui
+        # reasoning_agent is mounted separately below via _attach_reasoning_route
+        # so it can emit proper REASONING_MESSAGE_* AG-UI events.
         # No-tools agent for the MCP Apps cell. The CopilotKit runtime's
         # `mcpApps.servers` middleware injects MCP server tools at request
         # time, so the LLM only sees the MCP-provided toolset.
@@ -521,6 +712,11 @@ async def _gen():
 _attach_state_aware_route(app, shared_state_rw_agent, "/shared-state-rw")
 _attach_state_aware_route(app, subagents_supervisor, "/subagents")
 
+# Reasoning-aware route — emits proper REASONING_MESSAGE_* AG-UI events
+# that CopilotKit renders via the reasoningMessage slot. Replaces the stock
+# AGUI(agent=reasoning_agent, prefix="/reasoning") interface.
+_attach_reasoning_route(app, reasoning_agent, "/reasoning")
+
 # Agent Config Object cell — builds a per-request Agno Agent whose system
 # prompt is composed from the CopilotKit provider's forwarded properties
 # (tone / expertise / responseLength).

showcase/integrations/agno/src/agents/reasoning_agent.py

@@ -8,16 +8,16 @@
 Mirrors `showcase/integrations/langgraph-python/src/agents/reasoning_agent.py`
 (shared across the three reasoning demos there).
 
-Agno's AGUI interface emits REASONING_MESSAGE_* events (see
-`agno/os/interfaces/agui/utils.py`) whenever the agent produces reasoning
-steps. Setting `reasoning=True` on the Agent enables Agno's built-in
-agentic reasoning loop, which generates step-wise thinking visible to the
-frontend via those events.
+Uses reasoning=False with a custom AGUI handler in agent_server.py that
+synthesizes REASONING_MESSAGE_* AG-UI events from <reasoning>...</reasoning>
+XML tags in the model output. This avoids Agno's multi-call CoT loop
+(which breaks aimock fixtures) while still producing the proper AG-UI
+events that CopilotKit's frontend renders via the reasoningMessage slot.
 
 For the reasoning-chain demo we also expose the same shared backend tools
 (`get_weather`, `search_flights`, `get_stock_price`, `roll_dice`) as the
 primary agent so the catch-all tool renderer can observe a full
-reasoning → tool call → reasoning → tool call chain.
+reasoning -> tool call -> reasoning -> tool call chain.
 """
 
 from __future__ import annotations
@@ -107,13 +107,30 @@ def roll_dice(sides: int = 6):
     return json.dumps({"sides": sides, "result": randint(1, max(2, sides))})
 
 
-# A reasoning-enabled agent emits REASONING_MESSAGE_* events through the
-# AGUI interface. gpt-4o-mini is cheap + fast and good enough for the
-# step-by-step demonstration the showcase cell is after.
+# NOTE: reasoning=False (the default) is used here intentionally.
+#
+# Agno's reasoning=True triggers a multi-call Chain-of-Thought loop that
+# makes up to `reasoning_max_steps` sequential LLM calls. This breaks in
+# proxy/fixture environments (aimock, D5 probes) where only the first
+# call matches a fixture — subsequent calls don't match and either fall
+# through to the real API (slow, non-deterministic) or fail entirely.
+#
+# Instead, the custom AGUI handler in agent_server.py synthesizes
+# REASONING_MESSAGE_* AG-UI events from the agent's response text. The
+# system prompt instructs the model to prefix its answer with a reasoning
+# block delimited by <reasoning>...</reasoning> tags. The custom handler
+# parses those tags and emits proper AG-UI reasoning events that
+# CopilotKit's frontend renders via the reasoningMessage slot.
+#
+# This approach:
+#   - Works with aimock (single LLM call)
+#   - Emits proper AG-UI REASONING_MESSAGE_* events (unlike Agno's stock
+#     AGUI handler which only emits STEP_STARTED/STEP_FINISHED)
+#   - Keeps the demo visually identical to native reasoning models
 agent = Agent(
     model=OpenAIChat(id="gpt-4o-mini", timeout=120),
     tools=[get_weather, search_flights, get_stock_price, roll_dice],
-    reasoning=True,
+    reasoning=False,
     tool_call_limit=10,
     description=(
         "You are a helpful assistant. For each user question, first think "
@@ -122,9 +139,18 @@ def roll_dice(sides: int = 6):
     ),
     instructions="""
         REASONING STYLE:
-        Always reason step-by-step before answering. Keep thinking concise —
-        two to four short steps is plenty for most questions. Do not repeat
-        the final answer inside the reasoning block.
+        Always begin your response with a reasoning block wrapped in
+        <reasoning>...</reasoning> XML tags. Inside the tags, think
+        step-by-step (two to four short steps is plenty). After the closing
+        tag, give your concise final answer. Example:
+
+        <reasoning>
+        Step 1: Identify what the user is asking.
+        Step 2: Consider which tool to use.
+        Step 3: Formulate the answer.
+        </reasoning>
+
+        Here is my answer...
 
         TOOLS (reasoning-chain cell):
         - get_weather: use when the user asks about weather.

showcase/integrations/mastra/src/app/api/copilotkit/route.ts

@@ -106,7 +106,8 @@ export type LocalMastraAgentName =
   | "subagentsSupervisorAgent"
   | "interruptAgent"
   | "multimodalAgent"
-  | "mcpAppsAgent";
+  | "mcpAppsAgent"
+  | "byocHashbrownAgent";
 
 export type BuiltAgents = Record<
   DemoAgentName | LocalMastraAgentName,
@@ -174,6 +175,11 @@ export function buildAgents(
       "mcpAppsAgent missing from Mastra config — required for /demos/mcp-apps",
     );
   }
+  if (!baseLocalAgents.byocHashbrownAgent) {
+    throw new Error(
+      "byocHashbrownAgent missing from Mastra config — required for /demos/byoc-hashbrown",
+    );
+  }
   const headlessCompleteAgentInstance = getLocalAgent({
     mastra: mastraInstance,
     agentId: "headlessCompleteAgent",
@@ -224,6 +230,14 @@ export function buildAgents(
   if (!mcpAppsAgentInstance) {
     throw new Error("getLocalAgent returned null for mcpAppsAgent");
   }
+  const byocHashbrownAgentInstance = getLocalAgent({
+    mastra: mastraInstance,
+    agentId: "byocHashbrownAgent",
+    resourceId: "mastra-byocHashbrownAgent",
+  });
+  if (!byocHashbrownAgentInstance) {
+    throw new Error("getLocalAgent returned null for byocHashbrownAgent");
+  }
   const localAgents = {
     weatherAgent: baseLocalAgents.weatherAgent,
     headlessCompleteAgent: headlessCompleteAgentInstance,
@@ -232,6 +246,7 @@ export function buildAgents(
     interruptAgent: interruptAgentInstance,
     multimodalAgent: multimodalAgentInstance,
     mcpAppsAgent: mcpAppsAgentInstance,
+    byocHashbrownAgent: byocHashbrownAgentInstance,
   };
 
   // Guard against silent shadowing: if Mastra ever registers a local agent
@@ -278,6 +293,7 @@ export function buildAgents(
   resourceIdByAgent.set("interruptAgent", "mastra-interruptAgent");
   resourceIdByAgent.set("multimodalAgent", "mastra-multimodalAgent");
   resourceIdByAgent.set("mcpAppsAgent", "mastra-mcpAppsAgent");
+  resourceIdByAgent.set("byocHashbrownAgent", "mastra-byocHashbrownAgent");
 
   const demoAliases: Record<
     string,