handle agent tool

Author: kujtimiihoxha

internal/tui/components/anim/anim.go

@@ -75,6 +75,11 @@ func cycleColors(id string) tea.Cmd {
 	})
 }
 
+type Animation interface {
+	util.Model
+	ID() string
+}
+
 // anim is the model that manages the animation that displays while the
 // output is being generated.
 type anim struct {
@@ -88,7 +93,15 @@ type anim struct {
 	id              string
 }
 
-func New(cyclingCharsSize uint, label string) util.Model {
+type animOption func(*anim)
+
+func WithId(id string) animOption {
+	return func(a *anim) {
+		a.id = id
+	}
+}
+
+func New(cyclingCharsSize uint, label string, opts ...animOption) Animation {
 	// #nosec G115
 	n := min(int(cyclingCharsSize), maxCyclingChars)
 
@@ -105,6 +118,10 @@ func New(cyclingCharsSize uint, label string) util.Model {
 		id:       id.String(),
 	}
 
+	for _, opt := range opts {
+		opt(&c)
+	}
+
 	// If we're in truecolor mode (and there are enough cycling characters)
 	// color the cycling characters with a gradient ramp.
 	const minRampSize = 3
@@ -204,6 +221,10 @@ func (a anim) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	}
 }
 
+func (a anim) ID() string {
+	return a.id
+}
+
 func (a *anim) updateChars(chars *[]cyclingChar) {
 	for i, c := range *chars {
 		switch c.state(a.start) {

internal/tui/components/chat/list.go

@@ -8,7 +8,7 @@ import (
 	tea "github.com/charmbracelet/bubbletea/v2"
 	"github.com/charmbracelet/lipgloss/v2"
 	"github.com/opencode-ai/opencode/internal/app"
-	"github.com/opencode-ai/opencode/internal/logging"
+	"github.com/opencode-ai/opencode/internal/llm/agent"
 	"github.com/opencode-ai/opencode/internal/message"
 	"github.com/opencode-ai/opencode/internal/pubsub"
 	"github.com/opencode-ai/opencode/internal/session"
@@ -106,26 +106,71 @@ func (m *messageListCmp) View() string {
 }
 
 // handleChildSession handles messages from child sessions (agent tools).
-// TODO: update the agent tool message with the changes
-func (m *messageListCmp) handleChildSession(event pubsub.Event[message.Message]) {
-	// Implementation pending
+func (m *messageListCmp) handleChildSession(event pubsub.Event[message.Message]) tea.Cmd {
+	var cmds []tea.Cmd
+	if len(event.Payload.ToolCalls()) == 0 {
+		return nil
+	}
+	items := m.listCmp.Items()
+	toolCallInx := NotFound
+	var toolCall messages.ToolCallCmp
+	for i := len(items) - 1; i >= 0; i-- {
+		if msg, ok := items[i].(messages.ToolCallCmp); ok {
+			if msg.GetToolCall().ID == event.Payload.SessionID {
+				toolCallInx = i
+				toolCall = msg
+			}
+		}
+	}
+	if toolCallInx == NotFound {
+		return nil
+	}
+	nestedToolCalls := toolCall.GetNestedToolCalls()
+	for _, tc := range event.Payload.ToolCalls() {
+		found := false
+		for existingInx, existingTC := range nestedToolCalls {
+			if existingTC.GetToolCall().ID == tc.ID {
+				nestedToolCalls[existingInx].SetToolCall(tc)
+				found = true
+				break
+			}
+		}
+		if !found {
+			nestedCall := messages.NewToolCallCmp(
+				event.Payload.ID,
+				tc,
+				messages.WithToolCallNested(true),
+			)
+			cmds = append(cmds, nestedCall.Init())
+			nestedToolCalls = append(
+				nestedToolCalls,
+				nestedCall,
+			)
+		}
+	}
+	toolCall.SetNestedToolCalls(nestedToolCalls)
+	m.listCmp.UpdateItem(
+		toolCallInx,
+		toolCall,
+	)
+	return tea.Batch(cmds...)
 }
 
 // handleMessageEvent processes different types of message events (created/updated).
 func (m *messageListCmp) handleMessageEvent(event pubsub.Event[message.Message]) tea.Cmd {
 	switch event.Type {
 	case pubsub.CreatedEvent:
 		if event.Payload.SessionID != m.session.ID {
-			m.handleChildSession(event)
-			return nil
+			return m.handleChildSession(event)
 		}
-
 		if m.messageExists(event.Payload.ID) {
 			return nil
 		}
-
 		return m.handleNewMessage(event.Payload)
 	case pubsub.UpdatedEvent:
+		if event.Payload.SessionID != m.session.ID {
+			return m.handleChildSession(event)
+		}
 		return m.handleUpdateAssistantMessage(event.Payload)
 	}
 	return nil
@@ -196,8 +241,6 @@ func (m *messageListCmp) handleUpdateAssistantMessage(msg message.Message) tea.C
 	// Find existing assistant message and tool calls for this message
 	assistantIndex, existingToolCalls := m.findAssistantMessageAndToolCalls(items, msg.ID)
 
-	logging.Info("Update Assistant Message", "msg", msg, "assistantMessageInx", assistantIndex, "toolCalls", existingToolCalls)
-
 	// Handle assistant message content
 	if cmd := m.updateAssistantMessageContent(msg, assistantIndex); cmd != nil {
 		cmds = append(cmds, cmd)
@@ -389,6 +432,19 @@ func (m *messageListCmp) convertAssistantMessage(msg message.Message, toolResult
 	for _, tc := range msg.ToolCalls() {
 		options := m.buildToolCallOptions(tc, msg, toolResultMap)
 		uiMessages = append(uiMessages, messages.NewToolCallCmp(msg.ID, tc, options...))
+		// If this tool call is the agent tool, fetch nested tool calls
+		if tc.Name == agent.AgentToolName {
+			nestedMessages, _ := m.app.Messages.List(context.Background(), tc.ID)
+			nestedUIMessages := m.convertMessagesToUI(nestedMessages, make(map[string]message.ToolResult))
+			nestedToolCalls := make([]messages.ToolCallCmp, 0, len(nestedUIMessages))
+			for _, nestedMsg := range nestedUIMessages {
+				if toolCall, ok := nestedMsg.(messages.ToolCallCmp); ok {
+					toolCall.SetIsNested(true)
+					nestedToolCalls = append(nestedToolCalls, toolCall)
+				}
+			}
+			uiMessages[len(uiMessages)-1].(messages.ToolCallCmp).SetNestedToolCalls(nestedToolCalls)
+		}
 	}
 
 	return uiMessages

internal/tui/components/chat/messages/messages.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/charmbracelet/bubbles/v2/spinner"
 	tea "github.com/charmbracelet/bubbletea/v2"
 	"github.com/charmbracelet/lipgloss/v2"
 	"github.com/opencode-ai/opencode/internal/llm/models"
@@ -80,7 +81,7 @@ func (m *messageCmp) Init() tea.Cmd {
 // Manages animation updates for spinning messages and stops animation when appropriate.
 func (m *messageCmp) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
-	case anim.ColorCycleMsg, anim.StepCharsMsg:
+	case anim.ColorCycleMsg, anim.StepCharsMsg, spinner.TickMsg:
 		m.spinning = m.shouldSpin()
 		if m.spinning {
 			u, cmd := m.anim.Update(msg)

internal/tui/components/chat/messages/renderer.go

@@ -91,7 +91,14 @@ func (pb *paramBuilder) build() []string {
 
 // renderWithParams provides a common rendering pattern for tools with parameters
 func (br baseRenderer) renderWithParams(v *toolCallCmp, toolName string, args []string, contentRenderer func() string) string {
-	header := makeHeader(toolName, v.textWidth(), args...)
+	width := v.textWidth()
+	if v.isNested {
+		width -= 3 // Adjust for nested tool call indentation
+	}
+	header := makeHeader(toolName, width, args...)
+	if v.isNested {
+		return v.style().Render(header)
+	}
 	if res, done := earlyState(header, v); done {
 		return res
 	}
@@ -117,6 +124,7 @@ func init() {
 	registry.register(tools.SourcegraphToolName, func() renderer { return sourcegraphRenderer{} })
 	registry.register(tools.PatchToolName, func() renderer { return patchRenderer{} })
 	registry.register(tools.DiagnosticsToolName, func() renderer { return diagnosticsRenderer{} })
+	registry.register(agent.AgentToolName, func() renderer { return agentRenderer{} })
 }
 
 // -----------------------------------------------------------------------------
@@ -467,6 +475,51 @@ func (dr diagnosticsRenderer) Render(v *toolCallCmp) string {
 	})
 }
 
+// -----------------------------------------------------------------------------
+//  Task renderer
+// -----------------------------------------------------------------------------
+
+// agentRenderer handles project-wide diagnostic information
+type agentRenderer struct {
+	baseRenderer
+}
+
+// Render displays agent task parameters and result content
+func (tr agentRenderer) Render(v *toolCallCmp) string {
+	var params agent.AgentParams
+	if err := tr.unmarshalParams(v.call.Input, &params); err != nil {
+		return tr.renderError(v, "Invalid task parameters")
+	}
+	prompt := params.Prompt
+	prompt = strings.ReplaceAll(prompt, "\n", " ")
+	args := newParamBuilder().addMain(prompt).build()
+
+	header := makeHeader("Task", v.textWidth(), args...)
+	parts := []string{header}
+	for _, call := range v.nestedToolCalls {
+		parts = append(parts, call.View())
+	}
+
+	if v.result.ToolCallID == "" {
+		v.spinning = true
+		parts = append(parts, v.anim.View())
+	} else {
+		v.spinning = false
+	}
+
+	header = lipgloss.JoinVertical(
+		lipgloss.Left,
+		parts...,
+	)
+
+	if v.result.ToolCallID == "" {
+		return header
+	}
+
+	body := renderPlainContent(v, v.result.Content)
+	return joinHeaderBody(header, body)
+}
+
 // makeHeader builds "<Tool>: param (key=value)" and truncates as needed.
 func makeHeader(tool string, width int, params ...string) string {
 	prefix := tool + ": "