Merge pull request #838 from benodiwal/fix/preload-sidebar-status

Fix/preload sidebar status

Author: dgageot

pkg/app/app.go

@@ -52,6 +52,11 @@ func (a *App) ResolveCommand(ctx context.Context, userInput string) string {
 	return runtime.ResolveCommand(ctx, a.runtime, userInput)
 }
 
+// EmitStartupInfo emits initial agent, team, and toolset information to the provided channel
+func (a *App) EmitStartupInfo(ctx context.Context, events chan runtime.Event) {
+	a.runtime.EmitStartupInfo(ctx, events)
+}
+
 // Run one agent loop
 func (a *App) Run(ctx context.Context, cancel context.CancelFunc, message string) {
 	a.cancel = cancel

pkg/runtime/remote_runtime.go

@@ -78,6 +78,23 @@ func (r *RemoteRuntime) CurrentWelcomeMessage(ctx context.Context) string {
 	return r.readCurrentAgentConfig(ctx).WelcomeMessage
 }
 
+// EmitStartupInfo emits initial agent, team, and toolset information for immediate sidebar display
+func (r *RemoteRuntime) EmitStartupInfo(ctx context.Context, events chan Event) {
+	agentConfig := r.readCurrentAgentConfig(ctx)
+
+	// Emit agent information for sidebar display
+	modelID := agentConfig.Model // In v2 config, Model is already a string
+	events <- AgentInfo(r.currentAgent, modelID, agentConfig.Description)
+
+	// Emit team information
+	availableAgents := r.team.AgentNames()
+	events <- TeamInfo(availableAgents, r.currentAgent)
+
+	// For remote runtime, we estimate toolset count from config
+	toolsetCount := len(agentConfig.Toolsets)
+	events <- ToolsetInfo(toolsetCount, r.currentAgent)
+}
+
 func (r *RemoteRuntime) readCurrentAgentConfig(ctx context.Context) latest.AgentConfig {
 	cfg, err := r.client.GetAgent(ctx, r.agentFilename)
 	if err != nil {

pkg/runtime/runtime.go

@@ -70,6 +70,8 @@ type Runtime interface {
 	CurrentAgentCommands(ctx context.Context) map[string]string
 	// CurrentWelcomeMessage returns the welcome message for the active agent
 	CurrentWelcomeMessage(ctx context.Context) string
+	// EmitStartupInfo emits initial agent, team, and toolset information for immediate display
+	EmitStartupInfo(ctx context.Context, events chan Event)
 	// RunStream starts the agent's interaction loop and returns a channel of events
 	RunStream(ctx context.Context, sess *session.Session) <-chan Event
 	// Run starts the agent's interaction loop and returns the final messages
@@ -93,6 +95,7 @@ type LocalRuntime struct {
 	modelsStore                 modelStore
 	sessionCompaction           bool
 	managedOAuth                bool
+	startupInfoEmitted          bool                   // Track if startup info has been emitted to avoid unnecessary duplication
 	elicitationRequestCh        chan ElicitationResult // Channel for receiving elicitation responses
 	elicitationEventsChannel    chan Event             // Current events channel for sending elicitation requests
 	elicitationEventsChannelMux sync.RWMutex           // Protects elicitationEventsChannel
@@ -196,6 +199,43 @@ func (r *LocalRuntime) CurrentAgent() *agent.Agent {
 	return current
 }
 
+// EmitStartupInfo emits initial agent, team, and toolset information for immediate sidebar display
+func (r *LocalRuntime) EmitStartupInfo(ctx context.Context, events chan Event) {
+	// Prevent duplicate emissions
+	if r.startupInfoEmitted {
+		return
+	}
+
+	a := r.CurrentAgent()
+
+	// Emit agent information for sidebar display
+	var modelID string
+	if model := a.Model(); model != nil {
+		modelID = model.ID()
+	}
+	events <- AgentInfo(a.Name(), modelID, a.Description())
+
+	// Emit team information
+	availableAgents := r.team.AgentNames()
+	events <- TeamInfo(availableAgents, r.currentAgent)
+
+	// Emit agent warnings (if any)
+	r.emitAgentWarnings(a, events)
+
+	agentTools, err := a.Tools(ctx)
+	if err != nil {
+		slog.Warn("Failed to get agent tools during startup", "agent", a.Name(), "error", err)
+		// Emit toolset info with 0 tools if we can't get them
+		events <- ToolsetInfo(0, r.currentAgent)
+		r.startupInfoEmitted = true
+		return
+	}
+
+	// Emit toolset information
+	events <- ToolsetInfo(len(agentTools), r.currentAgent)
+	r.startupInfoEmitted = true
+}
+
 // registerDefaultTools registers the default tool handlers
 func (r *LocalRuntime) registerDefaultTools() {
 	slog.Debug("Registering default tools")

pkg/runtime/runtime_test.go

@@ -726,3 +726,53 @@ func TestProcessToolCalls_UnknownTool_NoToolResultMessage(t *testing.T) {
 	}
 	require.False(t, sawToolMsg, "no tool result should be added for unknown tool; this reproduces invalid sequencing state")
 }
+
+func TestEmitStartupInfo(t *testing.T) {
+	// Create a simple agent with mock provider
+	prov := &mockProvider{id: "test/startup-model", stream: &mockStream{}}
+	root := agent.New("startup-test-agent", "You are a startup test agent",
+		agent.WithModel(prov),
+		agent.WithDescription("This is a startup test agent"))
+	other := agent.New("other-agent", "You are another agent",
+		agent.WithModel(prov),
+		agent.WithDescription("This is another agent"))
+	tm := team.New(team.WithAgents(root, other))
+
+	rt, err := New(tm, WithCurrentAgent("startup-test-agent"), WithModelStore(mockModelStore{}))
+	require.NoError(t, err)
+
+	// Create a channel to collect events
+	events := make(chan Event, 10)
+
+	// Call EmitStartupInfo
+	rt.EmitStartupInfo(t.Context(), events)
+	close(events)
+
+	// Collect events
+	var collectedEvents []Event
+	for event := range events {
+		collectedEvents = append(collectedEvents, event)
+	}
+
+	// Verify expected events are emitted
+	expectedEvents := []Event{
+		AgentInfo("startup-test-agent", "test/startup-model", "This is a startup test agent"),
+		TeamInfo([]string{"startup-test-agent", "other-agent"}, "startup-test-agent"),
+		ToolsetInfo(0, "startup-test-agent"), // No tools configured
+	}
+
+	require.Equal(t, expectedEvents, collectedEvents)
+
+	// Test that calling EmitStartupInfo again doesn't emit duplicate events
+	events2 := make(chan Event, 10)
+	rt.EmitStartupInfo(t.Context(), events2)
+	close(events2)
+
+	var collectedEvents2 []Event
+	for event := range events2 {
+		collectedEvents2 = append(collectedEvents2, event)
+	}
+
+	// Should be empty due to deduplication
+	require.Empty(t, collectedEvents2, "EmitStartupInfo should not emit duplicate events")
+}

pkg/tui/tui.go

@@ -104,6 +104,7 @@ func (a *appModel) Init() tea.Cmd {
 	cmds := []tea.Cmd{
 		a.dialog.Init(),
 		a.chatPage.Init(),
+		a.emitStartupInfo(),
 	}
 
 	if firstMessage := a.application.FirstMessage(); firstMessage != nil {
@@ -117,6 +118,31 @@ func (a *appModel) Init() tea.Cmd {
 	return tea.Batch(cmds...)
 }
 
+// emitStartupInfo creates a command that emits startup events for immediate sidebar display
+func (a *appModel) emitStartupInfo() tea.Cmd {
+	return func() tea.Msg {
+		// a buffered channel to collect startup events
+		events := make(chan runtime.Event, 10)
+
+		go func() {
+			defer close(events)
+			a.application.EmitStartupInfo(context.Background(), events)
+		}()
+
+		var collectedEvents []runtime.Event
+		for event := range events {
+			collectedEvents = append(collectedEvents, event)
+		}
+
+		return StartupEventsMsg{Events: collectedEvents}
+	}
+}
+
+// StartupEventsMsg carries startup events to be processed by the UI
+type StartupEventsMsg struct {
+	Events []runtime.Event
+}
+
 // Help returns help information
 func (a *appModel) Help() help.KeyMap {
 	return core.NewSimpleHelp(a.Bindings())
@@ -138,6 +164,17 @@ func (a *appModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		a.dialog = u.(dialog.Manager)
 		return a, dialogCmd
 
+	case StartupEventsMsg:
+		var cmds []tea.Cmd
+		for _, event := range msg.Events {
+			updated, cmd := a.chatPage.Update(event)
+			a.chatPage = updated.(chat.Page)
+			if cmd != nil {
+				cmds = append(cmds, cmd)
+			}
+		}
+		return a, tea.Batch(cmds...)
+
 	case tea.WindowSizeMsg:
 		a.wWidth, a.wHeight = msg.Width, msg.Height
 		cmd := a.handleWindowResize(msg.Width, msg.Height)