fix(shell,config): terminal font size, AI tools, provider keys

- Fix terminal default fontSize from 6px to 14px across all references
- Add terminal tool to shell AI via ChatEngine with tool_call streaming
- Fix provider key detection (apiKey → api_key, baseURL → base_url)
- Add mimo provider migration and validation endpoint
- Bump version to 0.4.0

💘 Generated with Crush

Assisted-by: GLM-5.1 via Crush <crush@charm.land>

internal/api/handlers_config.go

@@ -187,6 +187,8 @@ func (s *Server) handleValidateProvider(w http.ResponseWriter, r *http.Request)
 		switch body.Name {
 		case "minimax":
 			baseURL = "https://api.minimax.io/v1"
+		case "mimo":
+			baseURL = "https://token-plan-ams.xiaomimimo.com/v1"
 		case "openai":
 			baseURL = "https://api.openai.com/v1"
 		case "anthropic":

internal/api/handlers_shell_chat.go

@@ -1,6 +1,7 @@
 package api
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
@@ -51,26 +52,31 @@ func (s *Server) handleShellChat(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	orb.SetSystemPrompt(s.buildShellSystemPromptV2(req))
+	orb.SetSystemPrompt(s.buildShellSystemPrompt(req))
+	orb.SetTools(s.shellAgentToolsJSON)
 
 	if req.Stream {
-		s.handleShellChatStreamV2(w, orb)
+		s.handleShellChatStream(w, orb)
 	} else {
-		s.handleShellChatNonStreamV2(w, orb)
+		s.handleShellChatNonStream(w, orb)
 	}
 }
 
-func (s *Server) buildShellSystemPromptV2(_ ShellChatRequest) string {
+func (s *Server) buildShellSystemPrompt(_ ShellChatRequest) string {
 	var sb strings.Builder
 
 	sb.WriteString(`Tu es l'Analyste Système de Muyue. Tu es un expert en administration système et développement.
 Tu aides l'utilisateur à comprendre son système, diagnostiquer des problèmes, et optimiser son environnement.
 
-RÈGLES STRICTES:
-- Tu ne peux JAMAIS exécuter de commande ou de code
-- Tu ne peux que analyser, expliquer, et proposer des solutions
-- Quand tu proposes du code ou des commandes, mets-les dans des blocs de code markdown avec le langage spécifié
-- L'utilisateur pourra les copier ou les envoyer directement au terminal depuis les boutons
+OUTILS DISPONIBLES:
+- terminal: Exécute des commandes shell sur le système local et retourne le résultat
+
+RÈGLES:
+- Utilise l'outil terminal pour exécuter des commandes quand c'est nécessaire
+- Analyse les résultats et explique-les clairement
+- Formate tes réponses en markdown avec des blocs de code quand approprié
+- Sois concis et technique
+- Quand tu proposes des commandes alternatives, utilise des blocs de code markdown
 
 `)
 
@@ -89,43 +95,42 @@ RÈGLES STRICTES:
 	return sb.String()
 }
 
-func (s *Server) handleShellChatStreamV2(w http.ResponseWriter, orb *orchestrator.Orchestrator) {
+func (s *Server) handleShellChatStream(w http.ResponseWriter, orb *orchestrator.Orchestrator) {
 	SetupSSEHeaders(w)
 	flusher, canFlush := w.(http.Flusher)
 	sseWriter := NewSSEWriter(w)
 
-	// Rebuild history into orchestrator
-	history := s.shellConvStore.Get()
-	for _, m := range history[:len(history)-1] { // all except last user msg
-		if m.Role == "system" {
-			continue
+	ctx := context.Background()
+	messages := s.buildShellContextMessages()
+
+	engine := NewChatEngine(orb, s.shellAgentRegistry, s.shellAgentToolsJSON)
+	engine.OnChunk(func(data map[string]interface{}) {
+		if data == nil {
+			return
 		}
-		// Pre-load orchestrator history
-		orb.AppendHistory(orchestrator.Message{Role: m.Role, Content: m.Content})
-	}
-
-	lastUserMsg := history[len(history)-1].Content
-
-	var finalContent string
-	result, err := orb.SendStream(lastUserMsg, func(chunk string) {
-		finalContent = chunk
-		sseWriter.Write(map[string]interface{}{"content": chunk})
+		sseWriter.Write(data)
 		if canFlush {
 			flusher.Flush()
 		}
 	})
 
+	finalContent, allToolCalls, allToolResults, err := engine.RunWithTools(ctx, messages)
 	if err != nil {
 		sseWriter.Write(map[string]interface{}{"error": err.Error()})
 		return
 	}
 
-	content := result
-	if content == "" {
-		content = finalContent
+	storeContent := finalContent
+	if len(allToolCalls) > 0 {
+		storeObj := map[string]interface{}{
+			"content":      storeContent,
+			"tool_calls":   allToolCalls,
+			"tool_results": allToolResults,
+		}
+		storeJSON, _ := json.Marshal(storeObj)
+		storeContent = string(storeJSON)
 	}
-
-	s.shellConvStore.Add("assistant", cleanThinkingTags(content))
+	s.shellConvStore.Add("assistant", storeContent)
 
 	sseWriter.Write(map[string]interface{}{
 		"done":   "true",
@@ -133,30 +138,62 @@ func (s *Server) handleShellChatStreamV2(w http.ResponseWriter, orb *orchestrato
 	})
 }
 
-func (s *Server) handleShellChatNonStreamV2(w http.ResponseWriter, orb *orchestrator.Orchestrator) {
-	history := s.shellConvStore.Get()
-	for _, m := range history[:len(history)-1] {
-		if m.Role == "system" {
-			continue
-		}
-		orb.AppendHistory(orchestrator.Message{Role: m.Role, Content: m.Content})
-	}
+func (s *Server) handleShellChatNonStream(w http.ResponseWriter, orb *orchestrator.Orchestrator) {
+	ctx := context.Background()
+	messages := s.buildShellContextMessages()
 
-	lastUserMsg := history[len(history)-1].Content
-
-	result, err := orb.Send(lastUserMsg)
+	engine := NewChatEngine(orb, s.shellAgentRegistry, s.shellAgentToolsJSON)
+	finalContent, err := engine.RunNonStream(ctx, messages)
 	if err != nil {
 		writeError(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 
-	s.shellConvStore.Add("assistant", cleanThinkingTags(result))
+	s.shellConvStore.Add("assistant", finalContent)
 	writeJSON(w, map[string]interface{}{
-		"content": result,
+		"content": finalContent,
 		"tokens":  s.shellConvStore.ApproxTokens(),
 	})
 }
 
+func (s *Server) buildShellContextMessages() []orchestrator.Message {
+	history := s.shellConvStore.Get()
+	start := 0
+	const shellContextWindow = 20
+	if len(history) > shellContextWindow {
+		start = len(history) - shellContextWindow
+	}
+
+	messages := make([]orchestrator.Message, 0, len(history[start:]))
+
+	for _, m := range history[start:] {
+		content := m.Content
+		if m.Role == "assistant" {
+			var parsed struct {
+				Content   string `json:"content"`
+				ToolCalls []struct {
+					ToolCallID string `json:"tool_call_id"`
+					Name       string `json:"name"`
+					Args       string `json:"args"`
+				} `json:"tool_calls"`
+			}
+			if err := json.Unmarshal([]byte(content), &parsed); err == nil && parsed.Content != "" {
+				content = parsed.Content
+			}
+		}
+		role := m.Role
+		if role == "system" {
+			continue
+		}
+		messages = append(messages, orchestrator.Message{
+			Role:    role,
+			Content: content,
+		})
+	}
+
+	return messages
+}
+
 func (s *Server) handleShellChatHistory(w http.ResponseWriter, r *http.Request) {
 	if r.Method != "GET" {
 		writeError(w, "GET only", http.StatusMethodNotAllowed)

internal/api/server.go

@@ -13,14 +13,16 @@ import (
 )
 
 type Server struct {
-	config         *config.MuyueConfig
-	scanResult     *scanner.ScanResult
-	mux            *http.ServeMux
-	convStore      *ConversationStore
-	shellConvStore *ShellConvStore
-	agentRegistry  *agent.Registry
-	agentToolsJSON json.RawMessage
-	workflowEngine *workflow.Engine
+	config              *config.MuyueConfig
+	scanResult          *scanner.ScanResult
+	mux                 *http.ServeMux
+	convStore           *ConversationStore
+	shellConvStore      *ShellConvStore
+	agentRegistry       *agent.Registry
+	agentToolsJSON      json.RawMessage
+	shellAgentRegistry  *agent.Registry
+	shellAgentToolsJSON json.RawMessage
+	workflowEngine      *workflow.Engine
 }
 
 func NewServer(cfg *config.MuyueConfig) *Server {
@@ -52,6 +54,14 @@ func NewServer(cfg *config.MuyueConfig) *Server {
 	tools := s.agentRegistry.OpenAITools()
 	toolsJSON, _ := json.Marshal(tools)
 	s.agentToolsJSON = json.RawMessage(toolsJSON)
+
+	s.shellAgentRegistry = agent.NewRegistry()
+	terminalTool, _ := agent.NewTerminalTool()
+	s.shellAgentRegistry.Register(terminalTool)
+	shellTools := s.shellAgentRegistry.OpenAITools()
+	shellToolsJSON, _ := json.Marshal(shellTools)
+	s.shellAgentToolsJSON = json.RawMessage(shellToolsJSON)
+
 	s.workflowEngine, _ = workflow.NewEngine(s.agentRegistry)
 	s.routes()
 	return s

internal/config/config.go

@@ -128,6 +128,22 @@ var DEFAULT_TERMINAL_THEMES = map[string]TerminalTheme{
 	},
 }
 
+func migrateProviders(cfg *MuyueConfig) {
+	defaults := Default().AI.Providers
+	for _, dp := range defaults {
+		found := false
+		for _, p := range cfg.AI.Providers {
+			if p.Name == dp.Name {
+				found = true
+				break
+			}
+		}
+		if !found {
+			cfg.AI.Providers = append(cfg.AI.Providers, dp)
+		}
+	}
+}
+
 func GetTerminalTheme(name string) TerminalTheme {
 	if theme, ok := DEFAULT_TERMINAL_THEMES[name]; ok {
 		return theme
@@ -206,6 +222,8 @@ func Load() (*MuyueConfig, error) {
 		}
 	}
 
+	migrateProviders(&cfg)
+
 	return &cfg, nil
 }
 
@@ -303,6 +321,7 @@ func Default() *MuyueConfig {
 
 	cfg.Terminal.CustomPrompt = true
 	cfg.Terminal.PromptTheme = "zerotwo"
+	cfg.Terminal.FontSize = 14
 
 	return cfg
 }

internal/version/version.go

@@ -7,7 +7,7 @@ import (
 
 const (
 	Name    = "muyue"
-	Version = "0.3.5"
+	Version = "0.4.0"
 	Author  = "La Légion de Muyue"
 )