Merge pull request #1403 from krissetto/disable-think-cmd-on-dumb-models

Disable /think in the TUI when using non-reasoning models

Author: dgageot

pkg/app/app.go

@@ -29,6 +29,7 @@ type App struct {
 	events             chan tea.Msg
 	throttleDuration   time.Duration
 	cancel             context.CancelFunc
+	currentAgentModel  string // Tracks the current agent's model ID from AgentInfoEvent
 }
 
 // Opt is an option for creating a new App.
@@ -105,6 +106,29 @@ func (a *App) CurrentAgentCommands(ctx context.Context) types.Commands {
 	return a.runtime.CurrentAgentInfo(ctx).Commands
 }
 
+// CurrentAgentModel returns the model ID for the current agent.
+// Returns the tracked model from AgentInfoEvent, or falls back to session overrides.
+// Returns empty string if no model information is available (fail-open scenario).
+func (a *App) CurrentAgentModel() string {
+	if a.currentAgentModel != "" {
+		return a.currentAgentModel
+	}
+	// Fallback to session overrides
+	if a.session != nil && a.session.AgentModelOverrides != nil {
+		agentName := a.runtime.CurrentAgentName()
+		if modelRef, ok := a.session.AgentModelOverrides[agentName]; ok {
+			return modelRef
+		}
+	}
+	return ""
+}
+
+// TrackCurrentAgentModel updates the tracked model ID for the current agent.
+// This is called when AgentInfoEvent is received from the runtime.
+func (a *App) TrackCurrentAgentModel(model string) {
+	a.currentAgentModel = model
+}
+
 // CurrentMCPPrompts returns the available MCP prompts for the active agent
 func (a *App) CurrentMCPPrompts(ctx context.Context) map[string]mcptools.PromptInfo {
 	if localRuntime, ok := a.runtime.(*runtime.LocalRuntime); ok {

pkg/modelsdev/store.go

@@ -349,3 +349,36 @@ var bedrockRegionPrefixes = map[string]bool{
 func isBedrockRegionPrefix(prefix string) bool {
 	return bedrockRegionPrefixes[prefix]
 }
+
+// ModelSupportsReasoning checks if the given model ID supports reasoning/thinking.
+//
+// This function implements fail-open semantics:
+//   - If modelID is empty or not in "provider/model" format, returns true (fail-open)
+//   - If models.dev lookup fails for any reason, returns true (fail-open)
+//   - If lookup succeeds, returns the model's Reasoning field value
+func ModelSupportsReasoning(ctx context.Context, modelID string) bool {
+	// Fail-open for empty model ID
+	if modelID == "" {
+		return true
+	}
+
+	// Fail-open if not in provider/model format
+	if !strings.Contains(modelID, "/") {
+		slog.Debug("Model ID not in provider/model format, assuming reasoning supported to allow user choice", "model_id", modelID)
+		return true
+	}
+
+	store, err := NewStore()
+	if err != nil {
+		slog.Debug("Failed to create modelsdev store, assuming reasoning supported to allow user choice", "error", err)
+		return true
+	}
+
+	model, err := store.GetModel(ctx, modelID)
+	if err != nil {
+		slog.Debug("Failed to lookup model in models.dev, assuming reasoning supported to allow user choice", "model_id", modelID, "error", err)
+		return true
+	}
+
+	return model.Reasoning
+}

pkg/runtime/event.go

@@ -373,7 +373,7 @@ func MCPInitFinished(agentName string) Event {
 type AgentInfoEvent struct {
 	Type           string `json:"type"`
 	AgentName      string `json:"agent_name"`
-	Model          string `json:"model"`
+	Model          string `json:"model"` // this is in provider/model format (e.g., "openai/gpt-4o")
 	Description    string `json:"description"`
 	WelcomeMessage string `json:"welcome_message,omitempty"`
 	AgentContext

pkg/runtime/runtime.go

@@ -1086,8 +1086,14 @@ func (r *LocalRuntime) handleStream(ctx context.Context, stream chat.MessageStre
 		if actualModel == "" && response.Model != "" {
 			actualModel = response.Model
 			if !actualModelEventEmitted && actualModel != modelID {
-				slog.Debug("Detected actual model differs from configured model (streaming)", "configured", modelID, "actual", actualModel)
-				events <- AgentInfo(a.Name(), actualModel, a.Description(), a.WelcomeMessage())
+				// NOTE(krissetto):Prepend the provider from the configured modelID to maintain consistent format
+				// every other invocation in the code uses the provider/model format
+				formattedModel := actualModel
+				if idx := strings.Index(modelID, "/"); idx != -1 {
+					formattedModel = modelID[:idx+1] + actualModel
+				}
+				slog.Debug("Detected actual model differs from configured model (streaming)", "configured", modelID, "actual", formattedModel)
+				events <- AgentInfo(a.Name(), formattedModel, a.Description(), a.WelcomeMessage())
 				actualModelEventEmitted = true
 			}
 		}

pkg/tui/commands/commands.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/docker/cagent/pkg/app"
 	"github.com/docker/cagent/pkg/feedback"
+	"github.com/docker/cagent/pkg/modelsdev"
 	"github.com/docker/cagent/pkg/tui/components/toolcommon"
 	"github.com/docker/cagent/pkg/tui/core"
 	"github.com/docker/cagent/pkg/tui/messages"
@@ -220,10 +221,25 @@ func builtInFeedbackCommands() []Item {
 
 // BuildCommandCategories builds the list of command categories for the command palette
 func BuildCommandCategories(ctx context.Context, application *app.App) []Category {
+	// Get session commands and filter based on model capabilities
+	sessionCommands := builtInSessionCommands()
+
+	// Check if the current model supports reasoning; hide /think if not
+	currentModel := application.CurrentAgentModel()
+	if !modelsdev.ModelSupportsReasoning(ctx, currentModel) {
+		filtered := make([]Item, 0, len(sessionCommands))
+		for _, cmd := range sessionCommands {
+			if cmd.ID != "session.think" {
+				filtered = append(filtered, cmd)
+			}
+		}
+		sessionCommands = filtered
+	}
+
 	categories := []Category{
 		{
 			Name:     "Session",
-			Commands: builtInSessionCommands(),
+			Commands: sessionCommands,
 		},
 		{
 			Name:     "Feedback",

pkg/tui/components/sidebar/sidebar.go

@@ -1,6 +1,7 @@
 package sidebar
 
 import (
+	"context"
 	"fmt"
 	"log/slog"
 	"maps"
@@ -11,6 +12,7 @@ import (
 	tea "charm.land/bubbletea/v2"
 	"charm.land/lipgloss/v2"
 
+	"github.com/docker/cagent/pkg/modelsdev"
 	"github.com/docker/cagent/pkg/paths"
 	"github.com/docker/cagent/pkg/runtime"
 	"github.com/docker/cagent/pkg/session"
@@ -63,34 +65,35 @@ type ragIndexingState struct {
 
 // model implements Model
 type model struct {
-	width             int
-	height            int
-	xPos              int                       // absolute x position on screen
-	yPos              int                       // absolute y position on screen
-	layoutCfg         LayoutConfig              // layout configuration for spacing
-	sessionUsage      map[string]*runtime.Usage // sessionID -> latest usage snapshot
-	sessionAgent      map[string]string         // sessionID -> agent name
-	todoComp          *todotool.SidebarComponent
-	mcpInit           bool
-	ragIndexing       map[string]*ragIndexingState // strategy name -> indexing state
-	spinner           spinner.Spinner
-	mode              Mode
-	sessionTitle      string
-	sessionStarred    bool
-	sessionHasContent bool // true when session has been used (has messages)
-	currentAgent      string
-	agentModel        string
-	agentDescription  string
-	availableAgents   []runtime.AgentDetails
-	agentSwitching    bool
-	availableTools    int
-	toolsLoading      bool // true when more tools may still be loading
-	sessionState      *service.SessionState
-	workingAgent      string // Name of the agent currently working (empty if none)
-	scrollbar         *scrollbar.Model
-	workingDirectory  string
-	queuedMessages    []string // Truncated preview of queued messages
-	streamCancelled   bool     // true after ESC cancel until next StreamStartedEvent
+	width              int
+	height             int
+	xPos               int                       // absolute x position on screen
+	yPos               int                       // absolute y position on screen
+	layoutCfg          LayoutConfig              // layout configuration for spacing
+	sessionUsage       map[string]*runtime.Usage // sessionID -> latest usage snapshot
+	sessionAgent       map[string]string         // sessionID -> agent name
+	todoComp           *todotool.SidebarComponent
+	mcpInit            bool
+	ragIndexing        map[string]*ragIndexingState // strategy name -> indexing state
+	spinner            spinner.Spinner
+	mode               Mode
+	sessionTitle       string
+	sessionStarred     bool
+	sessionHasContent  bool // true when session has been used (has messages)
+	currentAgent       string
+	agentModel         string
+	agentDescription   string
+	availableAgents    []runtime.AgentDetails
+	agentSwitching     bool
+	availableTools     int
+	toolsLoading       bool // true when more tools may still be loading
+	sessionState       *service.SessionState
+	workingAgent       string // Name of the agent currently working (empty if none)
+	scrollbar          *scrollbar.Model
+	workingDirectory   string
+	queuedMessages     []string // Truncated preview of queued messages
+	streamCancelled    bool     // true after ESC cancel until next StreamStartedEvent
+	reasoningSupported bool     // true if current model supports reasoning (default: true / fail-open)
 }
 
 // Option is a functional option for configuring the sidebar.
@@ -103,18 +106,19 @@ func WithLayoutConfig(cfg LayoutConfig) Option {
 
 func New(sessionState *service.SessionState, opts ...Option) Model {
 	m := &model{
-		width:            20,
-		layoutCfg:        DefaultLayoutConfig(),
-		height:           24,
-		sessionUsage:     make(map[string]*runtime.Usage),
-		sessionAgent:     make(map[string]string),
-		todoComp:         todotool.NewSidebarComponent(),
-		spinner:          spinner.New(spinner.ModeSpinnerOnly, styles.SpinnerDotsHighlightStyle),
-		sessionTitle:     "New session",
-		ragIndexing:      make(map[string]*ragIndexingState),
-		sessionState:     sessionState,
-		scrollbar:        scrollbar.New(),
-		workingDirectory: getCurrentWorkingDirectory(),
+		width:              20,
+		layoutCfg:          DefaultLayoutConfig(),
+		height:             24,
+		sessionUsage:       make(map[string]*runtime.Usage),
+		sessionAgent:       make(map[string]string),
+		todoComp:           todotool.NewSidebarComponent(),
+		spinner:            spinner.New(spinner.ModeSpinnerOnly, styles.SpinnerDotsHighlightStyle),
+		sessionTitle:       "New session",
+		ragIndexing:        make(map[string]*ragIndexingState),
+		sessionState:       sessionState,
+		scrollbar:          scrollbar.New(),
+		workingDirectory:   getCurrentWorkingDirectory(),
+		reasoningSupported: true, // Default to true (fail-open)
 	}
 	for _, opt := range opts {
 		opt(m)
@@ -145,16 +149,22 @@ func (m *model) SetTodos(result *tools.ToolCallResult) error {
 }
 
 // SetAgentInfo sets the current agent information and updates the model in availableAgents
-func (m *model) SetAgentInfo(agentName, model, description string) {
+func (m *model) SetAgentInfo(agentName, modelID, description string) {
 	m.currentAgent = agentName
-	m.agentModel = model
+	m.agentModel = modelID
 	m.agentDescription = description
+	m.reasoningSupported = modelsdev.ModelSupportsReasoning(context.Background(), modelID)
 
 	// Update the model in availableAgents for the current agent
 	// This is important when model routing selects a different model than configured
+	// Extract just the model name from "provider/model" format to match TeamInfoEvent format
 	for i := range m.availableAgents {
-		if m.availableAgents[i].Name == agentName && model != "" {
-			m.availableAgents[i].Model = model
+		if m.availableAgents[i].Name == agentName && modelID != "" {
+			modelName := modelID
+			if idx := strings.LastIndex(modelName, "/"); idx != -1 {
+				modelName = modelName[idx+1:]
+			}
+			m.availableAgents[i].Model = modelName
 			break
 		}
 	}
@@ -776,13 +786,14 @@ func (m *model) toolsetInfo(contentWidth int) string {
 	lines = append(lines, m.renderToolsStatus())
 
 	// Toggle indicators with shortcuts
+	// Only show "Thinking enabled" if the model supports reasoning
 	toggles := []struct {
 		enabled  bool
 		label    string
 		shortcut string
 	}{
 		{m.sessionState.YoloMode, "YOLO mode enabled", "^y"},
-		{m.sessionState.Thinking, "Thinking enabled", "/think"},
+		{m.sessionState.Thinking && m.reasoningSupported, "Thinking enabled", "/think"},
 		{m.sessionState.HideToolResults, "Tool output hidden", "^o"},
 		{m.sessionState.SplitDiffView, "Split Diff View enabled", "^t"},
 	}

pkg/tui/handlers.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/docker/cagent/pkg/browser"
 	"github.com/docker/cagent/pkg/evaluation"
+	"github.com/docker/cagent/pkg/modelsdev"
 	mcptools "github.com/docker/cagent/pkg/tools/mcp"
 	"github.com/docker/cagent/pkg/tui/components/editor"
 	"github.com/docker/cagent/pkg/tui/components/notification"
@@ -191,6 +192,12 @@ func (a *appModel) handleToggleYolo() (tea.Model, tea.Cmd) {
 }
 
 func (a *appModel) handleToggleThinking() (tea.Model, tea.Cmd) {
+	// Check if the current model supports reasoning
+	currentModel := a.application.CurrentAgentModel()
+	if !modelsdev.ModelSupportsReasoning(context.Background(), currentModel) {
+		return a, notification.InfoCmd("Thinking/reasoning is not supported for the current model")
+	}
+
 	sess := a.application.Session()
 	sess.Thinking = !sess.Thinking
 	a.sessionState.SetThinking(sess.Thinking)

pkg/tui/tui.go

@@ -203,9 +203,10 @@ func (a *appModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		return a, cmd
 
 	case *runtime.AgentInfoEvent:
-		// Track current agent
+		// Track current agent and model
 		a.currentAgent = msg.AgentName
 		a.sessionState.SetCurrentAgent(msg.AgentName)
+		a.application.TrackCurrentAgentModel(msg.Model)
 		// Forward to chat page
 		updated, cmd := a.chatPage.Update(msg)
 		a.chatPage = updated.(chat.Page)