Method runForwarding

pkg/runtime/agent_delegation.go:265–329

runForwarding runs a child session synchronously, forwarding all of its events to evts and propagating tool-approval state back to the parent on completion. This is the "interactive" path used by transfer_task and run_skill: the parent loop is blocked while the child executes, and the user sees the

(ctx context.Context, parent *session.Session, evts EventSink, req delegationRequest)

// building the sub-session, driving RunStream, and recording the
// sub-session on the parent.
func (r *LocalRuntime) runForwarding(ctx context.Context, parent *session.Session, evts EventSink, req delegationRequest) (*tools.ToolCallResult, error) {
	span := trace.SpanFromContext(ctx)

	callerAgent, err := r.team.Agent(r.currentAgentName())
	if err != nil {
		return nil, fmt.Errorf("current agent not found: %w", err)
	}
	child, err := r.team.Agent(req.AgentName)
	if err != nil {
		return nil, err
	}

	if req.SwitchCurrentAgent {
		defer r.swapCurrentAgent(ctx, parent.ID, callerAgent, child, evts)()
	}

	s := newSubSession(parent, req.SubSessionConfig, child)

	// subagent_stop fires after the child's stream has fully drained,
	// using the *parent* agent's executor so handlers configured on the
	// orchestrator see every child completion in one place — success or
	// failure. The deferred call ensures we don't lose the event when an
	// ErrorEvent triggers an early return below; handlers can detect a
	// failed run by an empty stop_response (or by correlating with the
	// session-level error event the parent already received).
	defer func() {
		r.executeSubagentStopHooks(ctx, parent, s, callerAgent, req.AgentName, s.GetLastAssistantMessageContent())
	}()

	childEvents := r.RunStream(ctx, s)
	var subSessionErr error
	for event := range childEvents {
		evts.Emit(event)
		if errEvent, ok := event.(*ErrorEvent); ok && subSessionErr == nil {
			// Capture the first ErrorEvent but keep draining the channel so
			// the sub-session's full transcript still streams through. The
			// child's run loop may emit additional events (e.g. notifications,
			// hook output) after the error before its channel closes; dropping
			// them here would leave the TUI's streamDepth counter unbalanced
			// and the user without context for what actually went wrong.
			subSessionErr = fmt.Errorf("%s", errEvent.Error)
		}
	}

	// Persist the sub-session unconditionally — even on error, the partial
	// transcript is the most valuable artifact for debugging. The persistence
	// pipeline relies on SubSessionCompleted to write the sub-session's
	// messages to the store; without this emission they are silently dropped.
	parent.AddSubSession(s)
	evts.Emit(SubSessionCompleted(parent.ID, s, callerAgent.Name()))

	if subSessionErr != nil {
		span.RecordError(subSessionErr)
		span.SetStatus(codes.Error, "sub-session error")
		return nil, subSessionErr
	}

	// Only propagate ToolsApproved on success. A failed sub-session must not