concurrent session support with tab view to switch between sessions

Signed-off-by: Christopher Petito <chrisjpetito@gmail.com>

Author: krissetto

cmd/root/new.go

@@ -2,6 +2,7 @@ package root
 
 import (
 	"context"
+	"os"
 	"strings"
 
 	tea "charm.land/bubbletea/v2"
@@ -14,6 +15,7 @@ import (
 	"github.com/docker/cagent/pkg/session"
 	"github.com/docker/cagent/pkg/telemetry"
 	"github.com/docker/cagent/pkg/tui"
+	"github.com/docker/cagent/pkg/tui/background"
 	tuiinput "github.com/docker/cagent/pkg/tui/input"
 )
 
@@ -86,14 +88,14 @@ func (f *newFlags) runNewCommand(cmd *cobra.Command, args []string) error {
 	return runTUI(ctx, rt, sess, appOpts...)
 }
 
-func runTUI(ctx context.Context, rt runtime.Runtime, sess *session.Session, opts ...app.Opt) error {
-	// If the runtime can provide a title generator, use it.
+// newTUIApp creates the shared app and wheel coalescer/filter used by both
+// single-session and multi-session TUI entry points.
+func newTUIApp(ctx context.Context, rt runtime.Runtime, sess *session.Session, opts []app.Opt) (*app.App, *tuiinput.WheelCoalescer, func(tea.Model, tea.Msg) tea.Msg) {
 	if gen := rt.TitleGenerator(); gen != nil {
 		opts = append(opts, app.WithTitleGenerator(gen))
 	}
 
 	a := app.New(ctx, rt, sess, opts...)
-	m := tui.New(ctx, a)
 
 	coalescer := tuiinput.NewWheelCoalescer()
 	filter := func(model tea.Model, msg tea.Msg) tea.Msg {
@@ -107,10 +109,39 @@ func runTUI(ctx context.Context, rt runtime.Runtime, sess *session.Session, opts
 		return msg
 	}
 
+	return a, coalescer, filter
+}
+
+func runTUI(ctx context.Context, rt runtime.Runtime, sess *session.Session, opts ...app.Opt) error {
+	a, coalescer, filter := newTUIApp(ctx, rt, sess, opts)
+
+	m := tui.New(ctx, a)
+
 	p := tea.NewProgram(m, tea.WithContext(ctx), tea.WithFilter(filter))
 	coalescer.SetSender(p.Send)
 	go a.Subscribe(ctx, p)
 
 	_, err := p.Run()
 	return err
 }
+
+func runMultiSessionTUI(ctx context.Context, rt runtime.Runtime, sess *session.Session, spawner background.SessionSpawner, cleanup func(), opts ...app.Opt) error {
+	a, coalescer, filter := newTUIApp(ctx, rt, sess, opts)
+
+	if cleanup == nil {
+		cleanup = func() {}
+	}
+	wd, _ := os.Getwd()
+	bgModel := background.New(ctx, spawner, a, wd, cleanup)
+
+	p := tea.NewProgram(bgModel, tea.WithContext(ctx), tea.WithFilter(filter))
+	coalescer.SetSender(p.Send)
+
+	// Set program on background model for routed message sending
+	if m, ok := bgModel.(interface{ SetProgram(p *tea.Program) }); ok {
+		m.SetProgram(p)
+	}
+
+	_, err := p.Run()
+	return err
+}

cmd/root/run.go

@@ -21,8 +21,10 @@ import (
 	"github.com/docker/cagent/pkg/paths"
 	"github.com/docker/cagent/pkg/runtime"
 	"github.com/docker/cagent/pkg/session"
+	"github.com/docker/cagent/pkg/sessiontitle"
 	"github.com/docker/cagent/pkg/teamloader"
 	"github.com/docker/cagent/pkg/telemetry"
+	"github.com/docker/cagent/pkg/tui/background"
 	"github.com/docker/cagent/pkg/tui/styles"
 )
 
@@ -204,45 +206,38 @@ func (f *runExecFlags) runOrExec(ctx context.Context, out *cli.Printer, args []s
 		out.Println("Recording mode enabled, cassette: " + cassettePath)
 	}
 
-	var (
-		rt      runtime.Runtime
-		sess    *session.Session
-		cleanup func()
-	)
+	// Remote runtime
 	if f.remoteAddress != "" {
-		rt, sess, err = f.createRemoteRuntimeAndSession(ctx, agentFileName)
-		if err != nil {
-			return err
-		}
-		cleanup = func() {} // Remote runtime doesn't need local cleanup
-	} else {
-		agentSource, err := config.Resolve(agentFileName, f.runConfig.EnvProvider())
+		rt, sess, err := f.createRemoteRuntimeAndSession(ctx, agentFileName)
 		if err != nil {
 			return err
 		}
+		return f.launchTUI(ctx, out, rt, sess, args, tui)
+	}
 
-		loadResult, err := f.loadAgentFrom(ctx, agentSource)
-		if err != nil {
-			return err
-		}
+	// Local runtime
+	agentSource, err := config.Resolve(agentFileName, f.runConfig.EnvProvider())
+	if err != nil {
+		return err
+	}
 
-		rt, sess, err = f.createLocalRuntimeAndSession(ctx, loadResult)
-		if err != nil {
-			return err
-		}
+	loadResult, err := f.loadAgentFrom(ctx, agentSource)
+	if err != nil {
+		return err
+	}
 
-		// Setup cleanup for local runtime
-		cleanup = func() {
-			// Use a fresh context for cleanup since the original may be canceled
-			cleanupCtx := context.WithoutCancel(ctx)
-			if err := loadResult.Team.StopToolSets(cleanupCtx); err != nil {
-				slog.Error("Failed to stop tool sets", "error", err)
-			}
+	rt, sess, err := f.createLocalRuntimeAndSession(ctx, loadResult)
+	if err != nil {
+		return err
+	}
+	cleanup := func() {
+		cleanupCtx := context.WithoutCancel(ctx)
+		if err := loadResult.Team.StopToolSets(cleanupCtx); err != nil {
+			slog.Error("Failed to stop tool sets", "error", err)
 		}
 	}
 	defer cleanup()
 
-	// Apply theme before TUI starts
 	if tui {
 		applyTheme()
 	}
@@ -256,7 +251,25 @@ func (f *runExecFlags) runOrExec(ctx context.Context, out *cli.Printer, args []s
 		return f.handleExecMode(ctx, out, rt, sess, args)
 	}
 
-	return f.handleRunMode(ctx, rt, sess, args)
+	opts, err := f.buildAppOpts(args)
+	if err != nil {
+		return err
+	}
+
+	// Concurrent agents: use multi-session TUI
+	if background.IsEnabled() {
+		var sessStore session.Store
+		switch typedRt := rt.(type) {
+		case *runtime.LocalRuntime:
+			sessStore = typedRt.SessionStore()
+		case *runtime.PersistentRuntime:
+			sessStore = typedRt.SessionStore()
+		}
+
+		return runMultiSessionTUI(ctx, rt, sess, f.createSessionSpawner(agentSource, sessStore), cleanup, opts...)
+	}
+
+	return runTUI(ctx, rt, sess, opts...)
 }
 
 func (f *runExecFlags) loadAgentFrom(ctx context.Context, agentSource config.Source) (*teamloader.LoadResult, error) {
@@ -456,12 +469,34 @@ func readInitialMessage(args []string) (*string, error) {
 	return &args[1], nil
 }
 
-func (f *runExecFlags) handleRunMode(ctx context.Context, rt runtime.Runtime, sess *session.Session, args []string) error {
-	firstMessage, err := readInitialMessage(args)
+func (f *runExecFlags) launchTUI(ctx context.Context, out *cli.Printer, rt runtime.Runtime, sess *session.Session, args []string, tui bool) error {
+	if tui {
+		applyTheme()
+	}
+
+	if f.dryRun {
+		out.Println("Dry run mode enabled. Agent initialized but will not execute.")
+		return nil
+	}
+
+	if !tui {
+		return f.handleExecMode(ctx, out, rt, sess, args)
+	}
+
+	opts, err := f.buildAppOpts(args)
 	if err != nil {
 		return err
 	}
 
+	return runTUI(ctx, rt, sess, opts...)
+}
+
+func (f *runExecFlags) buildAppOpts(args []string) ([]app.Opt, error) {
+	firstMessage, err := readInitialMessage(args)
+	if err != nil {
+		return nil, err
+	}
+
 	var opts []app.Opt
 	if firstMessage != nil {
 		opts = append(opts, app.WithFirstMessage(*firstMessage))
@@ -472,8 +507,74 @@ func (f *runExecFlags) handleRunMode(ctx context.Context, rt runtime.Runtime, se
 	if f.exitAfterResponse {
 		opts = append(opts, app.WithExitAfterFirstResponse())
 	}
+	return opts, nil
+}
 
-	return runTUI(ctx, rt, sess, opts...)
+// createSessionSpawner creates a function that can spawn new sessions with different working directories.
+func (f *runExecFlags) createSessionSpawner(agentSource config.Source, sessStore session.Store) background.SessionSpawner {
+	return func(spawnCtx context.Context, workingDir string) (*app.App, *session.Session, func(), error) {
+		// Create a copy of the runtime config with the new working directory
+		runConfigCopy := f.runConfig.Clone()
+		runConfigCopy.WorkingDir = workingDir
+
+		// Load team with the new working directory
+		loadResult, err := teamloader.LoadWithConfig(spawnCtx, agentSource, runConfigCopy, teamloader.WithModelOverrides(f.modelOverrides))
+		if err != nil {
+			return nil, nil, nil, err
+		}
+
+		team := loadResult.Team
+		agent, err := team.Agent(f.agentName)
+		if err != nil {
+			return nil, nil, nil, err
+		}
+
+		// Create model switcher config
+		modelSwitcherCfg := &runtime.ModelSwitcherConfig{
+			Models:             loadResult.Models,
+			Providers:          loadResult.Providers,
+			ModelsGateway:      runConfigCopy.ModelsGateway,
+			EnvProvider:        runConfigCopy.EnvProvider(),
+			AgentDefaultModels: loadResult.AgentDefaultModels,
+		}
+
+		// Create the local runtime
+		localRt, err := runtime.New(team,
+			runtime.WithSessionStore(sessStore),
+			runtime.WithCurrentAgent(f.agentName),
+			runtime.WithTracer(otel.Tracer(AppName)),
+			runtime.WithModelSwitcherConfig(modelSwitcherCfg),
+		)
+		if err != nil {
+			return nil, nil, nil, err
+		}
+
+		// Create a new session
+		newSess := session.New(
+			session.WithMaxIterations(agent.MaxIterations()),
+			session.WithToolsApproved(f.autoApprove),
+			session.WithThinking(agent.ThinkingConfigured()),
+			session.WithWorkingDir(workingDir),
+		)
+
+		// Create cleanup function
+		cleanup := func() {
+			cleanupCtx := context.WithoutCancel(spawnCtx)
+			_ = team.StopToolSets(cleanupCtx)
+		}
+
+		// Create the app
+		var appOpts []app.Opt
+		if pr, ok := localRt.(*runtime.PersistentRuntime); ok {
+			if model := pr.CurrentAgent().Model(); model != nil {
+				appOpts = append(appOpts, app.WithTitleGenerator(sessiontitle.New(model)))
+			}
+		}
+
+		a := app.New(spawnCtx, localRt, newSess, appOpts...)
+
+		return a, newSess, cleanup, nil
+	}
 }
 
 // applyTheme applies the theme from user config, or the built-in default.

pkg/app/app.go

@@ -339,10 +339,13 @@ func (a *App) Run(ctx context.Context, cancel context.CancelFunc, message string
 			a.session.AddMessage(session.UserMessage(message))
 		}
 		for event := range a.runtime.RunStream(ctx, a.session) {
-			// If context is cancelled, continue draining but don't forward events.
-			// This prevents the runtime from blocking on event sends.
+			// If context is cancelled, continue draining but don't forward events
+			// — except StreamStoppedEvent, which must always propagate so the
+			// supervisor can mark the session as no longer running.
 			if ctx.Err() != nil {
-				continue
+				if _, ok := event.(*runtime.StreamStoppedEvent); !ok {
+					continue
+				}
 			}
 
 			// Clear titleGenerating flag when title is generated (from server for remote runtime)
@@ -379,10 +382,13 @@ func (a *App) RunWithMessage(ctx context.Context, cancel context.CancelFunc, msg
 	go func() {
 		a.session.AddMessage(msg)
 		for event := range a.runtime.RunStream(ctx, a.session) {
-			// If context is cancelled, continue draining but don't forward events.
-			// This prevents the runtime from blocking on event sends.
+			// If context is cancelled, continue draining but don't forward events
+			// — except StreamStoppedEvent, which must always propagate so the
+			// supervisor can mark the session as no longer running.
 			if ctx.Err() != nil {
-				continue
+				if _, ok := event.(*runtime.StreamStoppedEvent); !ok {
+					continue
+				}
 			}
 
 			// Clear titleGenerating flag when title is generated (from server for remote runtime)
@@ -401,6 +407,14 @@ func (a *App) RunBangCommand(ctx context.Context, command string) {
 }
 
 func (a *App) Subscribe(ctx context.Context, program *tea.Program) {
+	a.SubscribeWith(ctx, program.Send)
+}
+
+// SubscribeWith subscribes to app events using a custom send function.
+// This allows callers to wrap or transform messages before sending them
+// to the Bubble Tea program. It's used by the concurrent agents feature
+// to tag events with their session ID for proper routing.
+func (a *App) SubscribeWith(ctx context.Context, send func(tea.Msg)) {
 	throttledChan := a.throttleEvents(ctx, a.events)
 	for {
 		select {
@@ -411,7 +425,7 @@ func (a *App) Subscribe(ctx context.Context, program *tea.Program) {
 				return
 			}
 
-			program.Send(msg)
+			send(msg)
 		}
 	}
 }

pkg/config/resolve_test.go

@@ -86,7 +86,8 @@ agents:
 }
 
 func TestResolveAgentFile_EmptyIsDefault(t *testing.T) {
-	t.Parallel()
+	home := t.TempDir()
+	t.Setenv("HOME", home)
 
 	resolved, err := resolve("")
 
@@ -95,7 +96,8 @@ func TestResolveAgentFile_EmptyIsDefault(t *testing.T) {
 }
 
 func TestResolveAgentFile_DefaultIsDefault(t *testing.T) {
-	t.Parallel()
+	home := t.TempDir()
+	t.Setenv("HOME", home)
 
 	resolved, err := resolve("default")
 

pkg/tui/background/feature.go

@@ -0,0 +1,16 @@
+// Package background provides concurrent agents feature support.
+package background
+
+import (
+	"os"
+)
+
+const (
+	// EnvConcurrentAgents is the environment variable to enable concurrent agents.
+	EnvConcurrentAgents = "CAGENT_EXPERIMENTAL_CONCURRENT_AGENTS"
+)
+
+// IsEnabled returns true if the concurrent agents feature is enabled.
+func IsEnabled() bool {
+	return os.Getenv(EnvConcurrentAgents) == "1"
+}