fix console TUI rendering, add startup spinner and handoff support

Author: theomonnom

cmd/lk/console.go

@@ -139,13 +139,17 @@ func runConsole(ctx context.Context, cmd *cli.Command) error {
 	}
 
 	fmt.Fprintf(os.Stderr, "Detected %s agent (%s in %s)\n", projectType.Lang(), entrypoint, projectDir)
+
+	// Show spinner while starting agent
+	stopSpinner := startSpinner("Starting agent")
 	agentProc, err := startAgent(AgentStartConfig{
 		Dir:         projectDir,
 		Entrypoint:  entrypoint,
 		ProjectType: projectType,
 		CLIArgs:     buildConsoleArgs(actualAddr, cmd.Bool("record")),
 	})
 	if err != nil {
+		stopSpinner()
 		return fmt.Errorf("failed to start agent: %w", err)
 	}
 	defer agentProc.Kill()
@@ -167,11 +171,13 @@ func runConsole(ctx context.Context, cmd *cli.Command) error {
 	var conn net.Conn
 	select {
 	case res := <-acceptCh:
+		stopSpinner()
 		if res.err != nil {
 			return fmt.Errorf("agent connection: %w", res.err)
 		}
 		conn = res.conn
 	case err := <-agentProc.Done():
+		stopSpinner()
 		logs := agentProc.RecentLogs(20)
 		for _, l := range logs {
 			fmt.Fprintln(os.Stderr, l)
@@ -181,12 +187,14 @@ func runConsole(ctx context.Context, cmd *cli.Command) error {
 		}
 		return fmt.Errorf("agent exited before connecting")
 	case <-time.After(60 * time.Second):
+		stopSpinner()
 		logs := agentProc.RecentLogs(20)
 		for _, l := range logs {
 			fmt.Fprintln(os.Stderr, l)
 		}
 		return fmt.Errorf("timed out waiting for agent to connect")
 	case <-ctx.Done():
+		stopSpinner()
 		return ctx.Err()
 	}
 	pipeline, err := console.NewPipeline(console.PipelineConfig{

cmd/lk/console_stub.go

@@ -5,9 +5,6 @@ package main
 import (
 	"context"
 	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
 
 	"github.com/urfave/cli/v3"
 )
@@ -17,30 +14,11 @@ func init() {
 		Name:  "console",
 		Usage: "Voice chat with an agent via mic/speakers",
 		Action: func(ctx context.Context, cmd *cli.Command) error {
-			msg := "console is not included in this build.\n\n"
-			if isHomebrewInstall() {
-				msg += "\"brew install livekit-cli\" does not include console support.\n" +
-					"Install with console support:\n" +
-					"  brew tap livekit/livekit && brew install lk\n"
-			} else {
-				msg += "Install with console support:\n" +
-					"  https://docs.livekit.io/intro/basics/cli/start/\n"
-			}
-			msg += "\nOr build from source:\n" +
-				"  go build -tags console ./cmd/lk"
-			return fmt.Errorf("%s", msg)
+			return fmt.Errorf("console is not included in this build (requires -tags console).\n\n" +
+				"Install with console support:\n" +
+				"  https://docs.livekit.io/intro/basics/cli/start/\n\n" +
+				"Or build from source:\n" +
+				"  go build -tags console ./cmd/lk")
 		},
 	})
 }
-
-func isHomebrewInstall() bool {
-	exe, err := os.Executable()
-	if err != nil {
-		return false
-	}
-	resolved, err := filepath.EvalSymlinks(exe)
-	if err != nil {
-		return false
-	}
-	return strings.Contains(resolved, "/Cellar/")
-}

cmd/lk/console_tui.go

@@ -20,6 +20,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"os"
 	"strings"
 	"time"
 
@@ -52,6 +53,27 @@ var blocks = []string{"▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"}
 // Braille spinner frames (matching Rich's "dots" spinner)
 var spinnerFrames = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
 
+// startSpinner shows a braille spinner on stderr with the given message.
+// Returns a stop function that clears the spinner line.
+func startSpinner(msg string) func() {
+	done := make(chan struct{})
+	go func() {
+		i := 0
+		for {
+			select {
+			case <-done:
+				fmt.Fprintf(os.Stderr, "\r\033[K")
+				return
+			default:
+				fmt.Fprintf(os.Stderr, "\r  %s %s", spinnerFrames[i%len(spinnerFrames)], msg)
+				i++
+				time.Sleep(80 * time.Millisecond)
+			}
+		}
+	}()
+	return func() { close(done) }
+}
+
 type consoleTickMsg struct{}
 type sessionEventMsg struct{ event *agent.AgentSessionEvent }
 type sessionResponseMsg struct{ resp *agent.SessionResponse }
@@ -388,11 +410,38 @@ func (m *consoleModel) handleSessionEvent(ev *agent.AgentSessionEvent) []tea.Cmd
 					m.metricsText = text
 				}
 				}
-			lines := formatChatItem(item)
-			for _, line := range lines {
-				cmds = append(cmds, tea.Println(line))
+			cmds = append(cmds, tea.Println(formatChatItem(item)))
+		}
+
+	case *agent.AgentSessionEvent_FunctionToolsExecuted_:
+		ft := e.FunctionToolsExecuted
+		outputsByCallID := make(map[string]*agent.FunctionCallOutput)
+		for _, fco := range ft.FunctionCallOutputs {
+			outputsByCallID[fco.CallId] = fco
+		}
+		var b strings.Builder
+		for i, fc := range ft.FunctionCalls {
+			if i > 0 {
+				b.WriteString("\n")
+			}
+			b.WriteString("\n  ")
+			b.WriteString("● ")
+			b.WriteString("function_tool: ")
+			b.WriteString(fc.Name)
+			if fco, ok := outputsByCallID[fc.CallId]; ok {
+				if fco.IsError {
+					b.WriteString("\n    ")
+					b.WriteString(redBoldStyle.Render("✗ "))
+					b.WriteString(redStyle.Render(truncateOutput(fco.Output)))
+				} else {
+					b.WriteString("\n    ")
+					b.WriteString(greenStyle.Render("✓ "))
+					b.WriteString(dimStyle.Render(summarizeOutput(fco.Output)))
+				}
 			}
 		}
+		b.WriteString("\n")
+		cmds = append(cmds, tea.Println(b.String()))
 
 	case *agent.AgentSessionEvent_Error_:
 		cmds = append(cmds, tea.Println(
@@ -403,16 +452,12 @@ func (m *consoleModel) handleSessionEvent(ev *agent.AgentSessionEvent) []tea.Cmd
 	return cmds
 }
 
-// formatChatItem returns lines to print for a conversation item,
-// matching the old Python console format.
-func formatChatItem(item *agent.ChatContext_ChatItem) []string {
+func formatChatItem(item *agent.ChatContext_ChatItem) string {
 	switch i := item.Item.(type) {
 	case *agent.ChatContext_ChatItem_Message:
 		msg := i.Message
-		// User messages are printed from UserInputTranscribed (final) to avoid
-		// ordering issues with partial transcripts.
 		if msg.Role == agent.ChatRole_USER {
-			return nil
+			return ""
 		}
 		var textParts []string
 		for _, c := range msg.Content {
@@ -422,41 +467,30 @@ func formatChatItem(item *agent.ChatContext_ChatItem) []string {
 		}
 		text := strings.Join(textParts, "")
 		if text == "" {
-			return nil
-		}
-
-		var lines []string
-		lines = append(lines,
-			"\n  "+lipgloss.NewStyle().Foreground(lkGreen).Render("● ")+
-				greenBoldStyle.Render("Agent"),
-		)
-		parts := strings.Split(text, "\n")
-		for i, tl := range parts {
-			if i == len(parts)-1 {
-				lines = append(lines, "    "+tl+"\n")
-			} else {
-				lines = append(lines, "    "+tl)
-			}
+			return ""
 		}
-		return lines
 
-	case *agent.ChatContext_ChatItem_FunctionCall:
-		return []string{
-			"  " + lipgloss.NewStyle().Foreground(lkCyan).Render("➜ ") +
-				cyanBoldStyle.Render(i.FunctionCall.Name),
+		var b strings.Builder
+		b.WriteString("\n  ")
+		b.WriteString(lipgloss.NewStyle().Foreground(lkGreen).Render("● "))
+		b.WriteString(greenBoldStyle.Render("Agent"))
+		for _, tl := range strings.Split(text, "\n") {
+			b.WriteString("\n    ")
+			b.WriteString(tl)
 		}
+		b.WriteString("\n")
+		return b.String()
 
-	case *agent.ChatContext_ChatItem_FunctionCallOutput:
-		if i.FunctionCallOutput.IsError {
-			return []string{
-				"    " + redBoldStyle.Render("✗ ") + redStyle.Render(truncateOutput(i.FunctionCallOutput.Output)),
-			}
-		}
-		return []string{
-			"    " + greenStyle.Render("✓ ") + dimStyle.Render(summarizeOutput(i.FunctionCallOutput.Output)),
+	case *agent.ChatContext_ChatItem_AgentHandoff:
+		h := i.AgentHandoff
+		old := ""
+		if h.OldAgentId != nil && *h.OldAgentId != "" {
+			old = dimStyle.Render(*h.OldAgentId) + " → "
 		}
+		return "  " + lipgloss.NewStyle().Foreground(lkPurple).Render("● ") +
+			dimStyle.Render("handoff: ") + old + labelStyle.Render(h.NewAgentId)
 	}
-	return nil
+	return ""
 }
 
 // ──────────────────────────────────────────────────────────────────