feat(agent): refactor AI chat with streaming, agent registry, and tool execution

- Replace old tool-call regex with proper agent registry
- Add streaming chat via SSE (handleStreamChat / handleNonStreamChat)
- Add internal/agent package with tool definitions and execution
- Add orchestrator with system prompt and tool scaffolding
- Add internal/agent/ directory
- Studio.jsx: streaming chat with thinking indicator and tool result rendering
- global.css: chat bubble styles, streaming animation, thinking dots
- handlers_chat.go: full rewrite using new agent/orchestrator architecture

💘 Generated with Crush

Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>

internal/api/handlers_chat.go

@@ -1,17 +1,16 @@
 package api
 
 import (
+	"context"
 	"encoding/json"
-	"fmt"
 	"net/http"
-	"os/exec"
-	"regexp"
 	"strings"
 
+	"github.com/muyue/muyue/internal/agent"
 	"github.com/muyue/muyue/internal/orchestrator"
 )
 
-var toolCallRegex = regexp.MustCompile(`\[TOOL_CALL:\{[^\}]+\}\]`)
+const maxToolIterations = 15
 
 func (s *Server) handleChat(w http.ResponseWriter, r *http.Request) {
 	if r.Method != "POST" {
@@ -27,7 +26,7 @@ func (s *Server) handleChat(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	if body.Message == "" {
-		writeError(w, "no message", http.StatusBadRequest)
+		writeError(w, "no message", http.StatusMethodNotAllowed)
 		return
 	}
 
@@ -42,143 +41,189 @@ func (s *Server) handleChat(w http.ResponseWriter, r *http.Request) {
 		writeError(w, err.Error(), http.StatusServiceUnavailable)
 		return
 	}
-	orb.SetSystemPrompt(`Tu es l'assistant IA de Muyue Studio. Tu as accès à un outil "crush" pour exécuter des tâches complexes sur l'ordinateur de l'utilisateur.
-
-RÈGLES ABSOLUES:
-1. Tu as DEUX possibilités ONLY:
-   - Répondre directement à l'utilisateur avec tes connaissances
-   - Demander l'exécution d'une tâche via crush en utilisant ce format EXACT:
-     [TOOL_CALL:{"tool":"crush","task":"description de la tâche"}]
-
-2. Quand tu utilises [TOOL_CALL:...], le système exécutera la tâche et te donnera le résultat.
-   Tu peux ensuite répondre à l'utilisateur avec ce résultat.
-
-3. SOIS CONCIS - pas de blabla, vais droit au but.
-
-4. L'utilisateur ne voit PAS tes pensées entre <think> tags.
-
-5. EXEMPLES d'utilisation de tool:
-   - "cherche tous les fichiers .md dans le projet" → [TOOL_CALL:{"tool":"crush","task":"Recherche les fichiers .md dans le projet courant"}]
-   - "aide-moi à déboguer cette erreur" → tu peux répondre directement si tu as assez d'info, sinon utiliser tool
-   - "quelle est la météo?" → [TOOL_CALL:{"tool":"crush","task":"Cherche la météo actuelle"}]
-
-6. Ne fais PAS de multi-step tool calls dans une seule réponse. Attends le résultat avant de continuer.`)
+	orb.SetSystemPrompt(agent.StudioSystemPrompt())
+	orb.SetTools(s.agentToolsJSON)
 
 	if body.Stream {
-		w.Header().Set("Content-Type", "text/event-stream")
-		w.Header().Set("Cache-Control", "no-cache")
-		w.Header().Set("Connection", "keep-alive")
-		w.Header().Set("Access-Control-Allow-Origin", "*")
-		w.WriteHeader(http.StatusOK)
-		flusher, canFlush := w.(http.Flusher)
+		s.handleStreamChat(w, orb, body.Message)
+	} else {
+		s.handleNonStreamChat(w, orb, body.Message)
+	}
+}
 
-		result, err := orb.SendStream(body.Message, func(chunk string) {
-			if strings.HasPrefix(chunk, "<think") {
-				data, _ := json.Marshal(map[string]string{"thinking": strings.TrimPrefix(chunk, "<think")})
-				w.Write([]byte("data: " + string(data) + "\n\n"))
-				if canFlush {
-					flusher.Flush()
-				}
-				return
-			}
-			if chunk == "</think>" {
-				data, _ := json.Marshal(map[string]string{"thinking_end": "true"})
-				w.Write([]byte("data: " + string(data) + "\n\n"))
-				if canFlush {
-					flusher.Flush()
-				}
-				return
-			}
-			data, _ := json.Marshal(map[string]string{"content": chunk})
-			w.Write([]byte("data: " + string(data) + "\n\n"))
-			if canFlush {
-				flusher.Flush()
-			}
-		})
-		if err != nil {
-			data, _ := json.Marshal(map[string]string{"error": err.Error()})
-			w.Write([]byte("data: " + string(data) + "\n\n"))
-			if canFlush {
-				flusher.Flush()
-			}
-			return
-		}
+func (s *Server) handleStreamChat(w http.ResponseWriter, orb *orchestrator.Orchestrator, userMessage string) {
+	w.Header().Set("Content-Type", "text/event-stream")
+	w.Header().Set("Cache-Control", "no-cache")
+	w.Header().Set("Connection", "keep-alive")
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.WriteHeader(http.StatusOK)
+	flusher, canFlush := w.(http.Flusher)
 
-		// Process tool calls if any
-		cleanResult := processToolCalls(result)
-		s.convStore.Add("assistant", cleanResult)
-
-		data, _ := json.Marshal(map[string]string{"done": "true"})
-		w.Write([]byte("data: " + string(data) + "\n\n"))
+	writeSSE := func(data map[string]interface{}) {
+		b, _ := json.Marshal(data)
+		w.Write([]byte("data: " + string(b) + "\n\n"))
 		if canFlush {
 			flusher.Flush()
 		}
-		return
 	}
 
-	result, err := orb.Send(body.Message)
-	if err != nil {
-		writeError(w, err.Error(), http.StatusInternalServerError)
-		return
+	ctx := context.Background()
+	messages := []orchestrator.Message{
+		{Role: "user", Content: userMessage},
 	}
-	cleanResult := processToolCalls(result)
-	s.convStore.Add("assistant", cleanResult)
-	writeJSON(w, map[string]string{"content": cleanResult})
+
+	var finalContent string
+	var allToolCalls []map[string]interface{}
+
+	for i := 0; i < maxToolIterations; i++ {
+		resp, err := orb.SendWithTools(messages)
+		if err != nil {
+			writeSSE(map[string]interface{}{"error": err.Error()})
+			return
+		}
+
+		choice := resp.Choices[0]
+		content := cleanThinkingTags(choice.Message.Content)
+
+		if content != "" {
+			for _, ch := range strings.Split(content, "") {
+				writeSSE(map[string]interface{}{"content": ch})
+			}
+			finalContent = content
+		}
+
+		if len(choice.Message.ToolCalls) == 0 {
+			break
+		}
+
+		assistantMsg := orchestrator.Message{
+			Role:      "assistant",
+			Content:   content,
+			ToolCalls: choice.Message.ToolCalls,
+		}
+		messages = append(messages, assistantMsg)
+
+		for _, tc := range choice.Message.ToolCalls {
+			toolCallData := map[string]interface{}{
+				"tool_call_id": tc.ID,
+				"name":         tc.Function.Name,
+				"args":         tc.Function.Arguments,
+			}
+			allToolCalls = append(allToolCalls, toolCallData)
+			writeSSE(map[string]interface{}{"tool_call": toolCallData})
+
+			call := agent.ToolCall{
+				ID:        tc.ID,
+				Name:      tc.Function.Name,
+				Arguments: json.RawMessage(tc.Function.Arguments),
+			}
+
+			result, execErr := s.agentRegistry.Execute(ctx, call)
+			if execErr != nil {
+				result = agent.ToolResponse{
+					Content: execErr.Error(),
+					IsError: true,
+				}
+			}
+
+			resultData := map[string]interface{}{
+				"tool_call_id": tc.ID,
+				"content":      result.Content,
+				"is_error":     result.IsError,
+			}
+			writeSSE(map[string]interface{}{"tool_result": resultData})
+
+			messages = append(messages, orchestrator.Message{
+				Role:       "tool",
+				Content:    result.Content,
+				ToolCallID: tc.ID,
+				Name:       tc.Function.Name,
+			})
+		}
+
+		finalContent = ""
+	}
+
+	storeContent := finalContent
+	if len(allToolCalls) > 0 {
+		storeObj := map[string]interface{}{"content": storeContent, "tool_calls": allToolCalls}
+		storeJSON, _ := json.Marshal(storeObj)
+		storeContent = string(storeJSON)
+	}
+	s.convStore.Add("assistant", storeContent)
+
+	writeSSE(map[string]interface{}{"done": "true"})
 }
 
-func processToolCalls(content string) string {
-	matches := toolCallRegex.FindAllString(content, -1)
-	if len(matches) == 0 {
-		return cleanThinkingTags(content)
+func (s *Server) handleNonStreamChat(w http.ResponseWriter, orb *orchestrator.Orchestrator, userMessage string) {
+	ctx := context.Background()
+	messages := []orchestrator.Message{
+		{Role: "user", Content: userMessage},
 	}
 
-	var result strings.Builder
-	clean := content
+	var finalContent string
 
-	for _, match := range matches {
-		// Extract tool and task from [TOOL_CALL:{...}]
-		inner := strings.TrimPrefix(match, "[TOOL_CALL:")
-		inner = strings.TrimSuffix(inner, "]}") + "}"
-
-		var call struct {
-			Tool string `json:"tool"`
-			Task string `json:"task"`
-		}
-		if err := json.Unmarshal([]byte(inner), &call); err != nil {
-			continue
+	for i := 0; i < maxToolIterations; i++ {
+		resp, err := orb.SendWithTools(messages)
+		if err != nil {
+			writeError(w, err.Error(), http.StatusInternalServerError)
+			return
 		}
 
-		if call.Tool == "crush" && call.Task != "" {
-			result.WriteString(fmt.Sprintf("> %s\n\n", call.Task))
-			output := executeCrush(call.Task)
-			result.WriteString(output)
-			result.WriteString("\n\n---\n\n")
+		choice := resp.Choices[0]
+		content := cleanThinkingTags(choice.Message.Content)
+
+		if content != "" {
+			finalContent = content
 		}
 
-		clean = strings.Replace(clean, match, "", 1)
+		if len(choice.Message.ToolCalls) == 0 {
+			break
+		}
+
+		assistantMsg := orchestrator.Message{
+			Role:      "assistant",
+			Content:   content,
+			ToolCalls: choice.Message.ToolCalls,
+		}
+		messages = append(messages, assistantMsg)
+
+		for _, tc := range choice.Message.ToolCalls {
+			call := agent.ToolCall{
+				ID:        tc.ID,
+				Name:      tc.Function.Name,
+				Arguments: json.RawMessage(tc.Function.Arguments),
+			}
+
+			result, execErr := s.agentRegistry.Execute(ctx, call)
+			if execErr != nil {
+				result = agent.ToolResponse{
+					Content: execErr.Error(),
+					IsError: true,
+				}
+			}
+
+			messages = append(messages, orchestrator.Message{
+				Role:       "tool",
+				Content:    result.Content,
+				ToolCallID: tc.ID,
+				Name:       tc.Function.Name,
+			})
+		}
+
+		finalContent = ""
 	}
 
-	clean = cleanThinkingTags(clean)
-
-	if result.Len() > 0 {
-		clean = strings.TrimSpace(clean) + "\n\n" + strings.TrimSpace(result.String())
+	if finalContent == "" {
+		finalContent = "(tool calls completed, no text response)"
 	}
 
-	return clean
+	s.convStore.Add("assistant", finalContent)
+	writeJSON(w, map[string]string{"content": finalContent})
 }
 
 func cleanThinkingTags(content string) string {
-	re := regexp.MustCompile(`(?s)<think[^>]*>.*?</think>`)
-	return re.ReplaceAllString(content, "")
-}
-
-func executeCrush(task string) string {
-	cmd := exec.Command("crush", "run", task)
-	output, err := cmd.CombinedOutput()
-	if err != nil {
-		return fmt.Sprintf("Erreur: %v\n%s", err, string(output))
-	}
-	return string(output)
+	return strings.ReplaceAll(content, "<think", "")
 }
 
 func (s *Server) autoSummarize() {
@@ -233,4 +278,4 @@ func (s *Server) handleChatClear(w http.ResponseWriter, r *http.Request) {
 	}
 	s.convStore.Clear()
 	writeJSON(w, map[string]string{"status": "ok"})
-}
+}