fix(appkit): forward sub-agent events into the parent SSE stream

After dispatchToolCall consolidated the sub-agent path, runSubAgent
called consumeAdapterStream without forwarding the child's adapter
events. The parent stream therefore only emitted the outer agent-<name>
function call; nested tool_call / tool_result events from the sub-agent
never reached the client.

The smart-dashboard query agent delegates to dashboard_pilot whose UI-
action tools (apply_filter, highlight_period, focus_chart, etc.) rely on
the SSE stream to apply React state mutations. Without the forwarding,
the user asks for a highlight and nothing visible happens.

Forward every sub-agent event except metadata. Sub-agents have their
own threadId; emitting it would overwrite the parent's thread state on
the client and break multi-turn continuity.

Test exercises the metadata-skipping rule and asserts tool_call,
tool_result, and message_delta all reach outboundEvents.

Signed-off-by: MarioCadenas <MarioCadenas@users.noreply.github.com>

Author: MarioCadenas

packages/appkit/src/plugins/agents/agents.ts

@@ -1129,7 +1129,25 @@ export class AgentsPlugin extends Plugin implements ToolProvider {
         },
         runContext,
       ),
-      { signal: runState.signal },
+      {
+        signal: runState.signal,
+        // Forward every sub-agent event into the parent's outbound SSE
+        // stream so the client sees nested tool_call / tool_result events
+        // (UI-action tools like apply_filter / highlight_period rely on
+        // this) and the sub-agent's streaming text as it's generated.
+        //
+        // `metadata` is the one exception: sub-agents have their own
+        // threadId, and forwarding it would overwrite the parent's
+        // thread state on the client and break multi-turn continuity.
+        // Approval-pending events emitted by `dispatchToolCall` already
+        // reach `outboundEvents` directly, so they are not routed here.
+        onEvent: (event) => {
+          if (event.type === "metadata") return;
+          for (const translated of runState.translator.translate(event)) {
+            runState.outboundEvents.push(translated);
+          }
+        },
+      },
     );
   }
 

packages/appkit/src/plugins/agents/tests/dispatch-tool-call.test.ts

@@ -278,3 +278,48 @@ describe("dispatchToolCall — shared tool-call budget", () => {
     expect(runState.signal.aborted).toBe(true);
   });
 });
+
+describe("runSubAgent — sub-agent event forwarding", () => {
+  /**
+   * The smart-dashboard `query` agent delegates to `dashboard_pilot`, which
+   * emits UI-action `tool_call` events (apply_filter, highlight_period) that
+   * the client reads off the parent's SSE stream. Without forwarding those
+   * inner events, the user asks for a highlight and nothing visible
+   * happens. `metadata` events are NOT forwarded because the sub-agent has
+   * its own threadId and overwriting the parent's would break multi-turn.
+   */
+  test("forwards every sub-agent event into the parent stream except metadata", async () => {
+    const plugin = new AgentsPlugin({ dir: false, agents: {} });
+    const { runState, pushed } = makeRunState(plugin);
+
+    const child = {
+      name: "child",
+      instructions: "test",
+      adapter: {
+        // biome-ignore lint/suspicious/noExplicitAny: stub adapter shape
+        async *run(): any {
+          yield { type: "metadata", data: { threadId: "child-thread" } };
+          yield {
+            type: "tool_call",
+            id: "call-1",
+            name: "highlight_period",
+            arguments: '{"start":"2016-03-01","end":"2016-03-31"}',
+          };
+          yield { type: "tool_result", id: "call-1", output: "highlighted" };
+          yield { type: "message_delta", content: "Done." };
+        },
+      },
+      toolIndex: new Map(),
+      // biome-ignore lint/suspicious/noExplicitAny: minimal stub
+    } as any;
+
+    // biome-ignore lint/suspicious/noExplicitAny: call private
+    await (plugin as any).runSubAgent(runState, child, { input: "go" }, 1);
+
+    const types = pushed.map((e) => (e as { type: string }).type);
+    expect(types).not.toContain("metadata");
+    expect(types).toContain("tool_call");
+    expect(types).toContain("tool_result");
+    expect(types).toContain("message_delta");
+  });
+});