Centralize model-change TUI notification in the main loop

Add a change-detection mechanism (lastEmittedModelID + emitModelInfo
closure) in RunStream that automatically emits AgentInfo only when the
effective model actually changes. This is checked before and after each
LLM call, covering per-tool overrides, fallback, model picker, cooldowns,
and any future model-switching feature — without each one having to
remember to notify the TUI.

- loop.go: replace 3 scattered manual AgentInfo emissions with
  emitModelInfo calls driven by the closure
- model_picker.go: remove AgentInfo emission from the tool handler;
  rename setModelAndEmitInfo to setCurrentAgentModel (no longer emits)
- agent_delegation.go: use getEffectiveModelID instead of getAgentModelID
  so agent-switch events reflect active fallback cooldowns

Assisted-By: docker-agent

Author: dgageot

pkg/runtime/agent_delegation.go

@@ -168,13 +168,13 @@ func (r *LocalRuntime) handleTaskTransfer(ctx context.Context, sess *session.Ses
 
 		// Restore original agent info in sidebar
 		if originalAgent, err := r.team.Agent(ca); err == nil {
-			evts <- AgentInfo(originalAgent.Name(), getAgentModelID(originalAgent), originalAgent.Description(), originalAgent.WelcomeMessage())
+			evts <- AgentInfo(originalAgent.Name(), r.getEffectiveModelID(originalAgent), originalAgent.Description(), originalAgent.WelcomeMessage())
 		}
 	}()
 
 	// Emit agent info for the new agent
 	if newAgent, err := r.team.Agent(params.Agent); err == nil {
-		evts <- AgentInfo(newAgent.Name(), getAgentModelID(newAgent), newAgent.Description(), newAgent.WelcomeMessage())
+		evts <- AgentInfo(newAgent.Name(), r.getEffectiveModelID(newAgent), newAgent.Description(), newAgent.WelcomeMessage())
 	}
 
 	slog.Debug("Creating new session with parent session", "parent_session_id", sess.ID, "tools_approved", sess.ToolsApproved, "thinking", sess.Thinking)

pkg/runtime/loop.go

@@ -97,9 +97,21 @@ func (r *LocalRuntime) RunStream(ctx context.Context, sess *session.Session) <-c
 
 		a := r.resolveSessionAgent(sess)
 
+		// lastEmittedModelID tracks what the TUI currently displays.
+		// emitModelInfo sends an AgentInfo only when the model actually changed,
+		// so new features (routing, alloy, fallback, model picker, …) never need
+		// to notify the TUI themselves — the loop handles it.
+		lastEmittedModelID := r.getEffectiveModelID(a)
+		emitModelInfo := func(a *agent.Agent, modelID string) {
+			if modelID == lastEmittedModelID {
+				return
+			}
+			lastEmittedModelID = modelID
+			events <- AgentInfo(a.Name(), modelID, a.Description(), a.WelcomeMessage())
+		}
+
 		// Emit agent information for sidebar display
-		// Use getEffectiveModelID to account for active fallback cooldowns
-		events <- AgentInfo(a.Name(), r.getEffectiveModelID(a), a.Description(), a.WelcomeMessage())
+		events <- AgentInfo(a.Name(), lastEmittedModelID, a.Description(), a.WelcomeMessage())
 
 		// Emit team information
 		events <- TeamInfo(r.agentDetailsFromTeam(), a.Name())
@@ -247,10 +259,9 @@ func (r *LocalRuntime) RunStream(ctx context.Context, sess *session.Session) <-c
 
 			modelID := model.ID()
 
-			// Notify sidebar when this turn uses a different model (per-tool override).
-			if modelID != defaultModelID {
-				events <- AgentInfo(a.Name(), modelID, a.Description(), a.WelcomeMessage())
-			}
+			// Notify sidebar when this turn uses a different model
+			// (per-tool override, model picker, fallback cooldown, …).
+			emitModelInfo(a, modelID)
 
 			slog.Debug("Using agent", "agent", a.Name(), "model", modelID)
 			slog.Debug("Getting model definition", "model_id", modelID)
@@ -325,17 +336,15 @@ func (r *LocalRuntime) RunStream(ctx context.Context, sess *session.Session) <-c
 				return
 			}
 
-			// Update sidebar model info to reflect what was actually used this turn.
-			// Fallback models are sticky (cooldown system persists them), so we only
-			// emit once. Per-tool model overrides are temporary (one turn), so we
-			// emit the override and then revert to the agent's default.
+			// Update sidebar to reflect the model actually used this turn.
+			// When no fallback kicked in, revert to the agent's default
+			// (undoes any temporary per-tool override).
+			actualModelID := defaultModelID
 			if usedModel != nil && usedModel.ID() != model.ID() {
 				slog.Info("Used fallback model", "agent", a.Name(), "primary", model.ID(), "used", usedModel.ID())
-				events <- AgentInfo(a.Name(), usedModel.ID(), a.Description(), a.WelcomeMessage())
-			} else if model.ID() != defaultModelID {
-				// Per-tool override was active: revert sidebar to the agent's default model.
-				events <- AgentInfo(a.Name(), defaultModelID, a.Description(), a.WelcomeMessage())
+				actualModelID = usedModel.ID()
 			}
+			emitModelInfo(a, actualModelID)
 			streamSpan.SetAttributes(
 				attribute.Int("tool.calls", len(res.Calls)),
 				attribute.Int("content.length", len(res.Content)),

pkg/runtime/model_picker.go

@@ -30,7 +30,7 @@ func (r *LocalRuntime) findModelPickerTool() *builtin.ModelPickerTool {
 }
 
 // handleChangeModel handles the change_model tool call by switching the current agent's model.
-func (r *LocalRuntime) handleChangeModel(ctx context.Context, _ *session.Session, toolCall tools.ToolCall, events chan Event) (*tools.ToolCallResult, error) {
+func (r *LocalRuntime) handleChangeModel(ctx context.Context, _ *session.Session, toolCall tools.ToolCall, _ chan Event) (*tools.ToolCallResult, error) {
 	var params builtin.ChangeModelArgs
 	if err := json.Unmarshal([]byte(toolCall.Function.Arguments), &params); err != nil {
 		return nil, fmt.Errorf("invalid arguments: %w", err)
@@ -53,29 +53,24 @@ func (r *LocalRuntime) handleChangeModel(ctx context.Context, _ *session.Session
 		)), nil
 	}
 
-	return r.setModelAndEmitInfo(ctx, params.Model, events)
+	return r.setCurrentAgentModel(ctx, params.Model)
 }
 
 // handleRevertModel handles the revert_model tool call by reverting the current agent to its default model.
-func (r *LocalRuntime) handleRevertModel(ctx context.Context, _ *session.Session, _ tools.ToolCall, events chan Event) (*tools.ToolCallResult, error) {
-	return r.setModelAndEmitInfo(ctx, "", events)
+func (r *LocalRuntime) handleRevertModel(ctx context.Context, _ *session.Session, _ tools.ToolCall, _ chan Event) (*tools.ToolCallResult, error) {
+	return r.setCurrentAgentModel(ctx, "")
 }
 
-// setModelAndEmitInfo sets the model for the current agent and emits an updated
-// AgentInfo event so the UI reflects the change. An empty modelRef reverts to
-// the agent's default model.
-func (r *LocalRuntime) setModelAndEmitInfo(ctx context.Context, modelRef string, events chan Event) (*tools.ToolCallResult, error) {
+// setCurrentAgentModel sets the model for the current agent. An empty modelRef
+// reverts to the agent's default model. The main loop detects the resulting
+// model change and automatically notifies the TUI, so no AgentInfo event is
+// emitted here.
+func (r *LocalRuntime) setCurrentAgentModel(ctx context.Context, modelRef string) (*tools.ToolCallResult, error) {
 	currentName := r.CurrentAgentName()
 	if err := r.SetAgentModel(ctx, currentName, modelRef); err != nil {
 		return tools.ResultError(fmt.Sprintf("failed to set model: %v", err)), nil
 	}
 
-	if a, err := r.team.Agent(currentName); err == nil {
-		events <- AgentInfo(a.Name(), r.getEffectiveModelID(a), a.Description(), a.WelcomeMessage())
-	} else {
-		slog.Warn("Failed to retrieve agent after model change; UI may not reflect the update", "agent", currentName, "error", err)
-	}
-
 	if modelRef == "" {
 		slog.Info("Model reverted via model_picker tool", "agent", currentName)
 		return tools.ResultSuccess("Model reverted to the agent's default model"), nil