feat(agent-tool): stream sub-agent events live (parity with adk-python #3991)

[cstavaru]

Summary

Brings the JS SDK to parity with adk-python PR
#3991 ("Stream
sub-agent events from AgentTool").

Today, when an LlmAgent invokes a sub-agent via AgentTool, every
intermediate event the sub-agent produces (model output, function
calls, nested AgentTool invocations, function responses) is consumed
inside AgentTool.runAsync() and never reaches the parent runner —
the parent only sees a single final function_response event with
the merged final text. This makes it impossible to render real-time
sub-agent activity in a CLI/UI, and is the JS counterpart to the
exact problem adk-python fixed in #3991.

Changes

core/src/agents/functions.ts

• Add handleFunctionCallsStreamingAsync(), an
  AsyncGenerator<Event> variant of handleFunctionCallsAsync().
  It splits the incoming function-call event into AgentTool calls
  and regular tool calls. For each AgentTool call it iterates
  AgentTool.runAsyncWithEvents() and yields every event live, while
  tracking the last content event in order to build the final tool
  response. Regular tool calls continue to delegate to
  handleFunctionCallList.
• The contract is: the terminal yield is always either the single
  function-response event or the merged
  parallel-function-response event. Callers can therefore keep a
  one-step buffer to capture it as functionResponseEvent.

core/src/tools/agent_tool.ts

• Refactor AgentTool.runAsync():
  • Extract runner/session setup into a private
    setupRunnerAndSession().
  • Extract result merging (filter thoughts, apply output schema)
    into a public buildToolResultFromContent() helper that
    handleFunctionCallsStreamingAsync reuses.
• Add AgentTool.runAsyncWithEvents(): an AsyncGenerator<Event>
  that yields the sub-agent's events as they are produced and does
  not build the tool result itself.
• Pass invocationContext.runConfig down into the inner
  runner.runAsync() so the sub-agent inherits the parent's run
  configuration (matches the Python implementation).

core/src/agents/llm_agent.ts

• Switch the function-call handling site from
  handleFunctionCallsAsync to handleFunctionCallsStreamingAsync.
• Consume the generator with a one-step buffer, yielding every
  intermediate sub-agent event to the parent runner and retaining
  only the terminal event as the functionResponseEvent for the
  rest of the flow.

let functionResponseEvent: Event | null = null;
let pendingEvent: Event | null = null;
for await (const event of handleFunctionCallsStreamingAsync({...})) {
  if (invocationContext.abortSignal?.aborted) return;
  if (pendingEvent) yield pendingEvent;
  pendingEvent = event;
}
functionResponseEvent = pendingEvent;

Behavior

• Before: runner only sees [function_call_event, function_response_event] for an AgentTool invocation.
• After: runner sees
  [function_call_event, ...all sub-agent events..., function_response_event].
  The final function_response_event is byte-for-byte the same as
  before (still built by buildToolResultFromContent), so any code
  that only cared about the response event keeps working.

Verification

• npm run lint — clean
• npm run build — clean
• Manually verified in a CLI that uses an LlmAgent with an
  AgentTool-wrapped sub-agent: intermediate events from the
  sub-agent now stream into the parent runner exactly as a top-level
  agent's events would, and the final tool response is unchanged.

Refs

• adk-python PR #3991:
  feat(agent-tool): Add event streaming propagation from AgentTool sub-agents to Runner adk-python#3991

[google-cla]

Thanks for your pull request! It looks like this may be your first contribution to a Google open source project. Before we can look at your pull request, you'll need to sign a Contributor License Agreement (CLA).

View this failed invocation of the CLA check for more information.

For the most up to date status, view the checks section at the bottom of the pull request.