Merge pull request #821 from benodiwal/feat/sidebar-agent-info

Feat/sidebar agent info

Author: rumpl

pkg/runtime/event.go

@@ -349,3 +349,94 @@ func MCPInitFinished(agentName string) Event {
 		AgentContext: AgentContext{AgentName: agentName},
 	}
 }
+
+// AgentInfoEvent is sent when agent information is available or changes
+type AgentInfoEvent struct {
+	Type        string `json:"type"`
+	AgentName   string `json:"agent_name"`
+	Model       string `json:"model"`
+	Description string `json:"description"`
+	AgentContext
+}
+
+func AgentInfo(agentName, model, description string) Event {
+	return &AgentInfoEvent{
+		Type:         "agent_info",
+		AgentName:    agentName,
+		Model:        model,
+		Description:  description,
+		AgentContext: AgentContext{AgentName: agentName},
+	}
+}
+
+// TeamInfoEvent is sent when team information is available
+type TeamInfoEvent struct {
+	Type            string   `json:"type"`
+	AvailableAgents []string `json:"available_agents"`
+	CurrentAgent    string   `json:"current_agent"`
+	AgentContext
+}
+
+func TeamInfo(availableAgents []string, currentAgent string) Event {
+	return &TeamInfoEvent{
+		Type:            "team_info",
+		AvailableAgents: availableAgents,
+		CurrentAgent:    currentAgent,
+		AgentContext:    AgentContext{AgentName: currentAgent},
+	}
+}
+
+// AgentSwitchingEvent is sent when agent switching starts or stops
+type AgentSwitchingEvent struct {
+	Type      string `json:"type"`
+	Switching bool   `json:"switching"`
+	FromAgent string `json:"from_agent,omitempty"`
+	ToAgent   string `json:"to_agent,omitempty"`
+	AgentContext
+}
+
+func AgentSwitching(switching bool, fromAgent, toAgent string) Event {
+	currentAgent := fromAgent
+	if toAgent != "" {
+		currentAgent = toAgent
+	}
+	return &AgentSwitchingEvent{
+		Type:         "agent_switching",
+		Switching:    switching,
+		FromAgent:    fromAgent,
+		ToAgent:      toAgent,
+		AgentContext: AgentContext{AgentName: currentAgent},
+	}
+}
+
+// ToolsetInfoEvent is sent when toolset information is available
+type ToolsetInfoEvent struct {
+	Type           string `json:"type"`
+	AvailableTools int    `json:"available_tools"`
+	AgentContext
+}
+
+func ToolsetInfo(availableTools int, agentName string) Event {
+	return &ToolsetInfoEvent{
+		Type:           "toolset_info",
+		AvailableTools: availableTools,
+		AgentContext:   AgentContext{AgentName: agentName},
+	}
+}
+
+// ToolStatusEvent is sent when a tool's execution status changes
+type ToolStatusEvent struct {
+	Type     string `json:"type"`
+	ToolName string `json:"tool_name"`
+	Status   string `json:"status"` // running, completed, failed
+	AgentContext
+}
+
+func ToolStatus(toolName, status, agentName string) Event {
+	return &ToolStatusEvent{
+		Type:         "tool_status",
+		ToolName:     toolName,
+		Status:       status,
+		AgentContext: AgentContext{AgentName: agentName},
+	}
+}

pkg/runtime/runtime.go

@@ -236,6 +236,17 @@ func (r *LocalRuntime) RunStream(ctx context.Context, sess *session.Session) <-c
 		// Set elicitation handler on all MCP toolsets before getting tools
 		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)
+
 		r.emitAgentWarnings(a, events)
 
 		for _, toolset := range a.ToolSets() {
@@ -251,6 +262,9 @@ func (r *LocalRuntime) RunStream(ctx context.Context, sess *session.Session) <-c
 			return
 		}
 
+		// Emit toolset information
+		events <- ToolsetInfo(len(agentTools), r.currentAgent)
+
 		messages := sess.GetMessages(a)
 		if sess.SendUserMessage {
 			events <- UserMessage(messages[len(messages)-1].Content)
@@ -789,6 +803,9 @@ func (r *LocalRuntime) runTool(ctx context.Context, tool tools.Tool, toolCall to
 
 	events <- ToolCall(toolCall, tool, a.Name())
 
+	// Emit tool status: running
+	events <- ToolStatus(toolCall.Function.Name, "running", a.Name())
+
 	var res *tools.ToolCallResult
 	var err error
 	var duration time.Duration
@@ -803,17 +820,23 @@ func (r *LocalRuntime) runTool(ctx context.Context, tool tools.Tool, toolCall to
 			// Synthesize a cancellation response so the transcript remains consistent
 			res = &tools.ToolCallResult{Output: "The tool call was canceled by the user."}
 			span.SetStatus(codes.Ok, "tool handler canceled by user")
+			// Emit tool status: failed (cancelled)
+			events <- ToolStatus(toolCall.Function.Name, "failed", a.Name())
 		} else {
 			span.RecordError(err)
 			span.SetStatus(codes.Error, "tool handler error")
 			slog.Error("Error calling tool", "tool", toolCall.Function.Name, "error", err)
 			res = &tools.ToolCallResult{
 				Output: fmt.Sprintf("Error calling tool: %v", err),
 			}
+			// Emit tool status: failed
+			events <- ToolStatus(toolCall.Function.Name, "failed", a.Name())
 		}
 	} else {
 		span.SetStatus(codes.Ok, "tool handler completed")
 		slog.Debug("Agent tool call completed", "tool", toolCall.Function.Name, "output_length", len(res.Output))
+		// Emit tool status: completed
+		events <- ToolStatus(toolCall.Function.Name, "completed", a.Name())
 	}
 
 	events <- ToolCallResponse(toolCall, tool, res.Output, a.Name())
@@ -950,8 +973,35 @@ func (r *LocalRuntime) handleTaskTransfer(ctx context.Context, sess *session.Ses
 	slog.Debug("Transferring task to agent", "from_agent", a.Name(), "to_agent", params.Agent, "task", params.Task)
 
 	ca := r.currentAgent
+
+	// Emit agent switching start event
+	evts <- AgentSwitching(true, ca, params.Agent)
+
 	r.currentAgent = params.Agent
-	defer func() { r.currentAgent = ca }()
+	defer func() {
+		r.currentAgent = ca
+
+		// Emit agent switching end event
+		evts <- AgentSwitching(false, params.Agent, ca)
+
+		// Restore original agent info in sidebar
+		if originalAgent, err := r.team.Agent(ca); err == nil {
+			var modelID string
+			if model := originalAgent.Model(); model != nil {
+				modelID = model.ID()
+			}
+			evts <- AgentInfo(originalAgent.Name(), modelID, originalAgent.Description())
+		}
+	}()
+
+	// Emit agent info for the new agent
+	if newAgent, err := r.team.Agent(params.Agent); err == nil {
+		var modelID string
+		if model := newAgent.Model(); model != nil {
+			modelID = model.ID()
+		}
+		evts <- AgentInfo(newAgent.Name(), modelID, newAgent.Description())
+	}
 
 	memberAgentTask := "You are a member of a team of agents. Your goal is to complete the following task:"
 	memberAgentTask += fmt.Sprintf("\n\n<task>\n%s\n</task>", params.Task)

pkg/runtime/runtime_test.go

@@ -211,6 +211,9 @@ func TestSimple(t *testing.T) {
 	events := runSession(t, sess, stream)
 
 	expectedEvents := []Event{
+		AgentInfo("root", "test/mock-model", ""),
+		TeamInfo([]string{"root"}, "root"),
+		ToolsetInfo(0, "root"),
 		UserMessage("Hi"),
 		StreamStarted(sess.ID, "root"),
 		AgentChoice("root", "Hello"),
@@ -236,6 +239,9 @@ func TestMultipleContentChunks(t *testing.T) {
 	events := runSession(t, sess, stream)
 
 	expectedEvents := []Event{
+		AgentInfo("root", "test/mock-model", ""),
+		TeamInfo([]string{"root"}, "root"),
+		ToolsetInfo(0, "root"),
 		UserMessage("Please greet me"),
 		StreamStarted(sess.ID, "root"),
 		AgentChoice("root", "Hello "),
@@ -263,6 +269,9 @@ func TestWithReasoning(t *testing.T) {
 	events := runSession(t, sess, stream)
 
 	expectedEvents := []Event{
+		AgentInfo("root", "test/mock-model", ""),
+		TeamInfo([]string{"root"}, "root"),
+		ToolsetInfo(0, "root"),
 		UserMessage("Hi"),
 		StreamStarted(sess.ID, "root"),
 		AgentChoiceReasoning("root", "Let me think about this..."),
@@ -289,6 +298,9 @@ func TestMixedContentAndReasoning(t *testing.T) {
 	events := runSession(t, sess, stream)
 
 	expectedEvents := []Event{
+		AgentInfo("root", "test/mock-model", ""),
+		TeamInfo([]string{"root"}, "root"),
+		ToolsetInfo(0, "root"),
 		UserMessage("Hi there"),
 		StreamStarted(sess.ID, "root"),
 		AgentChoiceReasoning("root", "The user wants a greeting"),
@@ -338,13 +350,16 @@ func TestErrorEvent(t *testing.T) {
 		events = append(events, ev)
 	}
 
-	require.Len(t, events, 4)
-	require.IsType(t, &UserMessageEvent{}, events[0])
-	require.IsType(t, &StreamStartedEvent{}, events[1])
-	require.IsType(t, &ErrorEvent{}, events[2])
-	require.IsType(t, &StreamStoppedEvent{}, events[3])
+	require.Len(t, events, 7)
+	require.IsType(t, &AgentInfoEvent{}, events[0])
+	require.IsType(t, &TeamInfoEvent{}, events[1])
+	require.IsType(t, &ToolsetInfoEvent{}, events[2])
+	require.IsType(t, &UserMessageEvent{}, events[3])
+	require.IsType(t, &StreamStartedEvent{}, events[4])
+	require.IsType(t, &ErrorEvent{}, events[5])
+	require.IsType(t, &StreamStoppedEvent{}, events[6])
 
-	errorEvent := events[2].(*ErrorEvent)
+	errorEvent := events[5].(*ErrorEvent)
 	require.Contains(t, errorEvent.Error, "simulated error")
 }
 
@@ -374,9 +389,12 @@ func TestContextCancellation(t *testing.T) {
 		events = append(events, ev)
 	}
 
-	require.GreaterOrEqual(t, len(events), 2)
-	require.IsType(t, &UserMessageEvent{}, events[0])
-	require.IsType(t, &StreamStartedEvent{}, events[1])
+	require.GreaterOrEqual(t, len(events), 5)
+	require.IsType(t, &AgentInfoEvent{}, events[0])
+	require.IsType(t, &TeamInfoEvent{}, events[1])
+	require.IsType(t, &ToolsetInfoEvent{}, events[2])
+	require.IsType(t, &UserMessageEvent{}, events[3])
+	require.IsType(t, &StreamStartedEvent{}, events[4])
 	require.IsType(t, &StreamStoppedEvent{}, events[len(events)-1])
 }