Enha: atomic global vars instead of mutexes

Makefile

@@ -143,10 +143,11 @@ build-whisper: ## Build whisper.cpp from source in batteries directory
 
 download-whisper-model: ## Download Whisper model for STT in batteries directory
 	@echo "Downloading Whisper model for STT..."
-	@if [ ! -d "batteries/whisper.cpp/models" ]; then \
+	@if [ ! -d "batteries/whisper.cpp" ]; then \
-		mkdir -p "batteries/whisper.cpp/models" \
+		echo "Please run 'make setup-whisper' first to clone the repository."; \
+		exit 1; \
 	fi
-	curl -o batteries/whisper.cpp/models/ggml-large-v3-turbo-q5_0.bin -L "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3-turbo-q5_0.bin?download=true"
+	@cd batteries/whisper.cpp && bash ./models/download-ggml-model.sh large-v3-turbo-q5_0
 	@echo "Whisper model downloaded successfully!"
 
 # Docker targets for STT/TTS services (in batteries directory)

batteries/docker-compose.yml

@@ -6,27 +6,19 @@ services:
     ports:
       - "8081:8081"
     volumes:
-      - ./whisper.cpp/models/ggml-large-v3-turbo-q5_0.bin:/app/models/ggml-large-v3-turbo-q5_0.bin
+      - whisper_models:/app/models
     working_dir: /app
     entrypoint: ""
     command: >
       sh -c "
-      if [ ! -f /app/models/ggml-large-v3-turbo-q5_0.bin ]; then
+      if [ ! -f /app/models/ggml-large-v3-turbo.bin ]; then
-        echo 'Downloading ggml-large-v3-turboq5_0 model...'
+        echo 'Downloading ggml-large-v3-turbo model...'
-      	curl -o /app/models/ggml-large-v3-turbo-q5_0.bin -L "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3-turbo-q5_0.bin?download=true"
+        ./download-ggml-model.sh large-v3-turbo /app/models
       fi &&
-      ./build/bin/whisper-server -m /app/models/ggml-large-v3-turbo-q5_0.bin -t 4 -p 1 --port 8081 --host 0.0.0.0
+      ./build/bin/whisper-server -m /app/models/ggml-large-v3-turbo.bin -t 4 -p 1 --port 8081 --host 0.0.0.0
       "
     environment:
       - WHISPER_LOG_LEVEL=3
-    # For GPU support, uncomment the following lines:
-    deploy:
-      resources:
-        reservations:
-          devices:
-            - driver: nvidia
-              count: 1
-              capabilities: [gpu]
     # Restart policy in case the service fails
     restart: unless-stopped
 
@@ -53,5 +45,7 @@ services:
 volumes:
   models:
     driver: local
+  audio:
+    driver: local
   whisper_models:
     driver: local

bot.go

@@ -16,12 +16,13 @@ import (
 	"log/slog"
 	"net"
 	"net/http"
+	"net/url"
 	"os"
 	"regexp"
 	"slices"
 	"strconv"
 	"strings"
-	"sync"
+	"sync/atomic"
 	"time"
 )
 
@@ -36,7 +37,7 @@ var (
 	chunkChan       = make(chan string, 10)
 	openAIToolChan  = make(chan string, 10)
 	streamDone      = make(chan bool, 1)
-	chatBody        *models.ChatBody
+	chatBody        *models.SafeChatBody
 	store           storage.FullRepo
 	defaultFirstMsg = "Hello! What can I do for you?"
 	defaultStarter  = []models.RoleMsg{}
@@ -48,7 +49,6 @@ var (
 	//nolint:unused // TTS_ENABLED conditionally uses this
 	orator          Orator
 	asr             STT
-	localModelsMu   sync.RWMutex
 	defaultLCPProps = map[string]float32{
 		"temperature":    0.8,
 		"dry_multiplier": 0.0,
@@ -63,11 +63,17 @@ var (
 		"google/gemma-3-27b-it:free",
 		"meta-llama/llama-3.3-70b-instruct:free",
 	}
-	LocalModels     = []string{}
+	LocalModels     atomic.Value // stores []string
-	localModelsData *models.LCPModels
+	localModelsData atomic.Value // stores *models.LCPModels
-	orModelsData    *models.ORModels
+	orModelsData    atomic.Value // stores *models.ORModels
 )
 
+func init() {
+	LocalModels.Store([]string{})
+	localModelsData.Store((*models.LCPModels)(nil))
+	orModelsData.Store((*models.ORModels)(nil))
+}
+
 var thinkBlockRE = regexp.MustCompile(`(?s)<think>.*?</think>`)
 
 // parseKnownToTag extracts known_to list from content using configured tag.
@@ -252,17 +258,22 @@ func createClient(connectTimeout time.Duration) *http.Client {
 }
 
 func warmUpModel() {
-	if !isLocalLlamacpp() {
+	u, err := url.Parse(cfg.CurrentAPI)
+	if err != nil {
+		return
+	}
+	host := u.Hostname()
+	if host != "localhost" && host != "127.0.0.1" && host != "::1" {
 		return
 	}
 	// Check if model is already loaded
-	loaded, err := isModelLoaded(chatBody.Model)
+	loaded, err := isModelLoaded(chatBody.GetModel())
 	if err != nil {
-		logger.Debug("failed to check model status", "model", chatBody.Model, "error", err)
+		logger.Debug("failed to check model status", "model", chatBody.GetModel(), "error", err)
 		// Continue with warmup attempt anyway
 	}
 	if loaded {
-		showToast("model already loaded", "Model "+chatBody.Model+" is already loaded.")
+		showToast("model already loaded", "Model "+chatBody.GetModel()+" is already loaded.")
 		return
 	}
 	go func() {
@@ -271,7 +282,7 @@ func warmUpModel() {
 		switch {
 		case strings.HasSuffix(cfg.CurrentAPI, "/completion"):
 			// Old completion endpoint
-			req := models.NewLCPReq(".", chatBody.Model, nil, map[string]float32{
+			req := models.NewLCPReq(".", chatBody.GetModel(), nil, map[string]float32{
 				"temperature":    0.8,
 				"dry_multiplier": 0.0,
 				"min_p":          0.05,
@@ -283,7 +294,7 @@ func warmUpModel() {
 			// OpenAI-compatible chat endpoint
 			req := models.OpenAIReq{
 				ChatBody: &models.ChatBody{
-					Model: chatBody.Model,
+					Model: chatBody.GetModel(),
 					Messages: []models.RoleMsg{
 						{Role: "system", Content: "."},
 					},
@@ -307,7 +318,7 @@ func warmUpModel() {
 		}
 		resp.Body.Close()
 		// Start monitoring for model load completion
-		monitorModelLoad(chatBody.Model)
+		monitorModelLoad(chatBody.GetModel())
 	}()
 }
 
@@ -350,7 +361,7 @@ func fetchORModels(free bool) ([]string, error) {
 	if err := json.NewDecoder(resp.Body).Decode(data); err != nil {
 		return nil, err
 	}
-	orModelsData = data
+	orModelsData.Store(data)
 	freeModels := data.ListModels(free)
 	return freeModels, nil
 }
@@ -412,7 +423,7 @@ func fetchLCPModelsWithStatus() (*models.LCPModels, error) {
 	if err := json.NewDecoder(resp.Body).Decode(data); err != nil {
 		return nil, err
 	}
-	localModelsData = data
+	localModelsData.Store(data)
 	return data, nil
 }
 
@@ -815,10 +826,10 @@ func chatRound(r *models.ChatRoundReq) error {
 	}
 	go sendMsgToLLM(reader)
 	logger.Debug("looking at vars in chatRound", "msg", r.UserMsg, "regen", r.Regen, "resume", r.Resume)
-	msgIdx := len(chatBody.Messages)
+	msgIdx := chatBody.GetMessageCount()
 	if !r.Resume {
 		// Add empty message to chatBody immediately so it persists during Alt+T toggle
-		chatBody.Messages = append(chatBody.Messages, models.RoleMsg{
+		chatBody.AppendMessage(models.RoleMsg{
 			Role: botPersona, Content: "",
 		})
 		nl := "\n\n"
@@ -830,7 +841,7 @@ func chatRound(r *models.ChatRoundReq) error {
 		}
 		fmt.Fprintf(textView, "%s[-:-:b](%d) %s[-:-:-]\n", nl, msgIdx, roleToIcon(botPersona))
 	} else {
-		msgIdx = len(chatBody.Messages) - 1
+		msgIdx = chatBody.GetMessageCount() - 1
 	}
 	respText := strings.Builder{}
 	toolResp := strings.Builder{}
@@ -887,7 +898,10 @@ out:
 			fmt.Fprint(textView, chunk)
 			respText.WriteString(chunk)
 			// Update the message in chatBody.Messages so it persists during Alt+T
-			chatBody.Messages[msgIdx].Content = respText.String()
+			chatBody.UpdateMessageFunc(msgIdx, func(msg models.RoleMsg) models.RoleMsg {
+				msg.Content = respText.String()
+				return msg
+			})
 			if scrollToEndEnabled {
 				textView.ScrollToEnd()
 			}
@@ -930,29 +944,32 @@ out:
 	}
 	botRespMode = false
 	if r.Resume {
-		chatBody.Messages[len(chatBody.Messages)-1].Content += respText.String()
+		chatBody.UpdateMessageFunc(chatBody.GetMessageCount()-1, func(msg models.RoleMsg) models.RoleMsg {
-		updatedMsg := chatBody.Messages[len(chatBody.Messages)-1]
+			msg.Content += respText.String()
-		processedMsg := processMessageTag(&updatedMsg)
+			processedMsg := processMessageTag(&msg)
-		chatBody.Messages[len(chatBody.Messages)-1] = *processedMsg
+			if msgStats != nil && processedMsg.Role != cfg.ToolRole {
-		if msgStats != nil && chatBody.Messages[len(chatBody.Messages)-1].Role != cfg.ToolRole {
+				processedMsg.Stats = msgStats
-			chatBody.Messages[len(chatBody.Messages)-1].Stats = msgStats
 			}
+			return *processedMsg
+		})
 	} else {
-		chatBody.Messages[msgIdx].Content = respText.String()
+		chatBody.UpdateMessageFunc(msgIdx, func(msg models.RoleMsg) models.RoleMsg {
-		processedMsg := processMessageTag(&chatBody.Messages[msgIdx])
+			msg.Content = respText.String()
-		chatBody.Messages[msgIdx] = *processedMsg
+			processedMsg := processMessageTag(&msg)
-		if msgStats != nil && chatBody.Messages[msgIdx].Role != cfg.ToolRole {
+			if msgStats != nil && processedMsg.Role != cfg.ToolRole {
-			chatBody.Messages[msgIdx].Stats = msgStats
+				processedMsg.Stats = msgStats
 			}
-		stopTTSIfNotForUser(&chatBody.Messages[msgIdx])
+			return *processedMsg
+		})
+		stopTTSIfNotForUser(&chatBody.GetMessages()[msgIdx])
 	}
 	cleanChatBody()
 	refreshChatDisplay()
 	updateStatusLine()
 	// bot msg is done;
 	// now check it for func call
-	// logChat(activeChatName, chatBody.Messages)
+	// logChat(activeChatName, chatBody.GetMessages())
-	if err := updateStorageChat(activeChatName, chatBody.Messages); err != nil {
+	if err := updateStorageChat(activeChatName, chatBody.GetMessages()); err != nil {
 		logger.Warn("failed to update storage", "error", err, "name", activeChatName)
 	}
 	// Strip think blocks before parsing for tool calls
@@ -967,8 +984,8 @@ out:
 	// If so, trigger those characters to respond if that char is not controlled by user
 	// perhaps we should have narrator role to determine which char is next to act
 	if cfg.AutoTurn {
-		lastMsg := chatBody.Messages[len(chatBody.Messages)-1]
+		lastMsg, ok := chatBody.GetLastMessage()
-		if len(lastMsg.KnownTo) > 0 {
+		if ok && len(lastMsg.KnownTo) > 0 {
 			triggerPrivateMessageResponses(&lastMsg)
 		}
 	}
@@ -977,13 +994,15 @@ out:
 
 // cleanChatBody removes messages with null or empty content to prevent API issues
 func cleanChatBody() {
-	if chatBody == nil || chatBody.Messages == nil {
+	if chatBody == nil || chatBody.GetMessageCount() == 0 {
 		return
 	}
 	// Tool request cleaning is now configurable via AutoCleanToolCallsFromCtx (default false)
 	// /completion msg where part meant for user and other part tool call
 	// chatBody.Messages = cleanToolCalls(chatBody.Messages)
-	chatBody.Messages = consolidateAssistantMessages(chatBody.Messages)
+	chatBody.WithLock(func(cb *models.ChatBody) {
+		cb.Messages = consolidateAssistantMessages(cb.Messages)
+	})
 }
 
 // convertJSONToMapStringString unmarshals JSON into map[string]interface{} and converts all values to strings.
@@ -1083,7 +1102,7 @@ func findCall(msg, toolCall string) bool {
 				Content:    fmt.Sprintf("Error processing tool call: %v. Please check the JSON format and try again.", err),
 				ToolCallID: lastToolCall.ID, // Use the stored tool call ID
 			}
-			chatBody.Messages = append(chatBody.Messages, toolResponseMsg)
+			chatBody.AppendMessage(toolResponseMsg)
 			// Clear the stored tool call ID after using it (no longer needed)
 			// Trigger the assistant to continue processing with the error message
 			crr := &models.ChatRoundReq{
@@ -1120,7 +1139,7 @@ func findCall(msg, toolCall string) bool {
 				Role:    cfg.ToolRole,
 				Content: "Error processing tool call: no valid JSON found. Please check the JSON format.",
 			}
-			chatBody.Messages = append(chatBody.Messages, toolResponseMsg)
+			chatBody.AppendMessage(toolResponseMsg)
 			crr := &models.ChatRoundReq{
 				Role: cfg.AssistantRole,
 			}
@@ -1137,8 +1156,8 @@ func findCall(msg, toolCall string) bool {
 				Role:    cfg.ToolRole,
 				Content: fmt.Sprintf("Error processing tool call: %v. Please check the JSON format and try again.", err),
 			}
-			chatBody.Messages = append(chatBody.Messages, toolResponseMsg)
+			chatBody.AppendMessage(toolResponseMsg)
-			logger.Debug("findCall: added tool error response", "role", toolResponseMsg.Role, "content_len", len(toolResponseMsg.Content), "message_count_after_add", len(chatBody.Messages))
+			logger.Debug("findCall: added tool error response", "role", toolResponseMsg.Role, "content_len", len(toolResponseMsg.Content), "message_count_after_add", chatBody.GetMessageCount())
 			// Trigger the assistant to continue processing with the error message
 			// chatRound("", cfg.AssistantRole, tv, false, false)
 			crr := &models.ChatRoundReq{
@@ -1156,17 +1175,23 @@ func findCall(msg, toolCall string) bool {
 	// we got here => last msg recognized as a tool call (correct or not)
 	// Use the tool call ID from streaming response (lastToolCall.ID)
 	// Don't generate random ID - the ID should match between assistant message and tool response
-	lastMsgIdx := len(chatBody.Messages) - 1
+	lastMsgIdx := chatBody.GetMessageCount() - 1
 	if lastToolCall.ID != "" {
-		chatBody.Messages[lastMsgIdx].ToolCallID = lastToolCall.ID
+		chatBody.UpdateMessageFunc(lastMsgIdx, func(msg models.RoleMsg) models.RoleMsg {
+			msg.ToolCallID = lastToolCall.ID
+			return msg
+		})
 	}
 	// Store tool call info in the assistant message
 	// Convert Args map to JSON string for storage
-	chatBody.Messages[lastMsgIdx].ToolCall = &models.ToolCall{
+	chatBody.UpdateMessageFunc(lastMsgIdx, func(msg models.RoleMsg) models.RoleMsg {
+		msg.ToolCall = &models.ToolCall{
 			ID:   lastToolCall.ID,
 			Name: lastToolCall.Name,
 			Args: mapToString(lastToolCall.Args),
 		}
+		return msg
+	})
 	// call a func
 	_, ok := fnMap[fc.Name]
 	if !ok {
@@ -1177,8 +1202,8 @@ func findCall(msg, toolCall string) bool {
 			Content:    m,
 			ToolCallID: lastToolCall.ID, // Use the stored tool call ID
 		}
-		chatBody.Messages = append(chatBody.Messages, toolResponseMsg)
+		chatBody.AppendMessage(toolResponseMsg)
-		logger.Debug("findCall: added tool not implemented response", "role", toolResponseMsg.Role, "content_len", len(toolResponseMsg.Content), "tool_call_id", toolResponseMsg.ToolCallID, "message_count_after_add", len(chatBody.Messages))
+		logger.Debug("findCall: added tool not implemented response", "role", toolResponseMsg.Role, "content_len", len(toolResponseMsg.Content), "tool_call_id", toolResponseMsg.ToolCallID, "message_count_after_add", chatBody.GetMessageCount())
 		// Clear the stored tool call ID after using it
 		lastToolCall.ID = ""
 		// Trigger the assistant to continue processing with the new tool response
@@ -1249,9 +1274,9 @@ func findCall(msg, toolCall string) bool {
 		}
 	}
 	fmt.Fprintf(textView, "%s[-:-:b](%d) <%s>: [-:-:-]\n%s\n",
-		"\n\n", len(chatBody.Messages), cfg.ToolRole, toolResponseMsg.GetText())
+		"\n\n", chatBody.GetMessageCount(), cfg.ToolRole, toolResponseMsg.GetText())
-	chatBody.Messages = append(chatBody.Messages, toolResponseMsg)
+	chatBody.AppendMessage(toolResponseMsg)
-	logger.Debug("findCall: added actual tool response", "role", toolResponseMsg.Role, "content_len", len(toolResponseMsg.Content), "tool_call_id", toolResponseMsg.ToolCallID, "message_count_after_add", len(chatBody.Messages))
+	logger.Debug("findCall: added actual tool response", "role", toolResponseMsg.Role, "content_len", len(toolResponseMsg.Content), "tool_call_id", toolResponseMsg.ToolCallID, "message_count_after_add", chatBody.GetMessageCount())
 	// Clear the stored tool call ID after using it
 	lastToolCall.ID = ""
 	// Trigger the assistant to continue processing with the new tool response
@@ -1381,7 +1406,7 @@ func charToStart(agentName string, keepSysP bool) bool {
 func updateModelLists() {
 	var err error
 	if cfg.OpenRouterToken != "" {
-		ORFreeModels, err = fetchORModels(true)
+		_, err := fetchORModels(true)
 		if err != nil {
 			logger.Warn("failed to fetch or models", "error", err)
 		}
@@ -1391,24 +1416,19 @@ func updateModelLists() {
 	if err != nil {
 		logger.Warn("failed to fetch llama.cpp models", "error", err)
 	}
-	localModelsMu.Lock()
+	LocalModels.Store(ml)
-	LocalModels = ml
-	localModelsMu.Unlock()
 	for statusLineWidget == nil {
 		time.Sleep(time.Millisecond * 100)
 	}
 	// set already loaded model in llama.cpp
-	if !isLocalLlamacpp() {
+	if strings.Contains(cfg.CurrentAPI, "localhost") || strings.Contains(cfg.CurrentAPI, "127.0.0.1") {
-		return
+		modelList := LocalModels.Load().([]string)
-	}
+		for i := range modelList {
-	localModelsMu.Lock()
+			if strings.Contains(modelList[i], models.LoadedMark) {
-	defer localModelsMu.Unlock()
+				m := strings.TrimPrefix(modelList[i], models.LoadedMark)
-	for i := range LocalModels {
-		if strings.Contains(LocalModels[i], models.LoadedMark) {
-			m := strings.TrimPrefix(LocalModels[i], models.LoadedMark)
 				cfg.CurrentModel = m
 				chatBody.Model = m
-			cachedModelColor = "green"
+				cachedModelColor.Store("green")
 				updateStatusLine()
 				updateToolCapabilities()
 				app.Draw()
@@ -1416,23 +1436,20 @@ func updateModelLists() {
 			}
 		}
 	}
+}
 
 func refreshLocalModelsIfEmpty() {
-	localModelsMu.RLock()
+	models := LocalModels.Load().([]string)
-	if len(LocalModels) > 0 {
+	if len(models) > 0 {
-		localModelsMu.RUnlock()
 		return
 	}
-	localModelsMu.RUnlock()
 	// try to fetch
 	models, err := fetchLCPModels()
 	if err != nil {
 		logger.Warn("failed to fetch llama.cpp models", "error", err)
 		return
 	}
-	localModelsMu.Lock()
+	LocalModels.Store(models)
-	LocalModels = models
-	localModelsMu.Unlock()
 }
 
 func summarizeAndStartNewChat() {
@@ -1492,7 +1509,7 @@ func init() {
 	// load cards
 	basicCard.Role = cfg.AssistantRole
 	logLevel.Set(slog.LevelInfo)
-	logger = slog.New(slog.NewTextHandler(logfile, &slog.HandlerOptions{Level: logLevel}))
+	logger = slog.New(slog.NewTextHandler(logfile, &slog.HandlerOptions{Level: logLevel, AddSource: true}))
 	store = storage.NewProviderSQL(cfg.DBPATH, logger)
 	if store == nil {
 		cancel()
@@ -1516,11 +1533,11 @@ func init() {
 	}
 	lastToolCall = &models.FuncCall{}
 	lastChat := loadOldChatOrGetNew()
-	chatBody = &models.ChatBody{
+	chatBody = models.NewSafeChatBody(&models.ChatBody{
 		Model:    "modelname",
 		Stream:   true,
 		Messages: lastChat,
-	}
+	})
 	choseChunkParser()
 	httpClient = createClient(time.Second * 90)
 	if cfg.TTS_ENABLED {
@@ -1548,7 +1565,55 @@ func init() {
 	}
 	// Initialize scrollToEndEnabled based on config
 	scrollToEndEnabled = cfg.AutoScrollEnabled
+	go updateModelLists()
 	go chatWatcher(ctx)
-	initTUI()
+}
-	initTools()
+
+func getValidKnowToRecipient(msg *models.RoleMsg) (string, bool) {
+	if cfg == nil || !cfg.CharSpecificContextEnabled {
+		return "", false
+	}
+	// case where all roles are in the tag => public message
+	cr := listChatRoles()
+	slices.Sort(cr)
+	slices.Sort(msg.KnownTo)
+	if slices.Equal(cr, msg.KnownTo) {
+		logger.Info("got msg with tag mentioning every role")
+		return "", false
+	}
+	// Check each character in the KnownTo list
+	for _, recipient := range msg.KnownTo {
+		if recipient == msg.Role || recipient == cfg.ToolRole {
+			// weird cases, skip
+			continue
+		}
+		// Skip if this is the user character (user handles their own turn)
+		// If user is in KnownTo, stop processing - it's the user's turn
+		if recipient == cfg.UserRole || recipient == cfg.WriteNextMsgAs {
+			return "", false
+		}
+		return recipient, true
+	}
+	return "", false
+}
+
+// triggerPrivateMessageResponses checks if a message was sent privately to specific characters
+// and triggers those non-user characters to respond
+func triggerPrivateMessageResponses(msg *models.RoleMsg) {
+	recipient, ok := getValidKnowToRecipient(msg)
+	if !ok || recipient == "" {
+		return
+	}
+	// Trigger the recipient character to respond
+	triggerMsg := recipient + ":\n"
+	// Send empty message so LLM continues naturally from the conversation
+	crr := &models.ChatRoundReq{
+		UserMsg: triggerMsg,
+		Role:    recipient,
+		Resume:  true,
+	}
+	fmt.Fprintf(textView, "\n[-:-:b](%d) ", len(chatBody.Messages))
+	fmt.Fprint(textView, roleToIcon(recipient))
+	fmt.Fprint(textView, "[-:-:-]\n")
+	chatRoundChan <- crr
 }

extra/google_tts.go

@@ -1,218 +0,0 @@
-//go:build extra
-// +build extra
-
-package extra
-
-import (
-	"fmt"
-	"gf-lt/models"
-	"io"
-	"log/slog"
-	"os/exec"
-	"strings"
-	"sync"
-
-	google_translate_tts "github.com/GrailFinder/google-translate-tts"
-	"github.com/neurosnap/sentences/english"
-)
-
-type GoogleTranslateOrator struct {
-	logger *slog.Logger
-	mu     sync.Mutex
-	speech *google_translate_tts.Speech
-	// fields for playback control
-	cmd    *exec.Cmd
-	cmdMu  sync.Mutex
-	stopCh chan struct{}
-	// text buffer and interrupt flag
-	textBuffer strings.Builder
-	interrupt  bool
-	Speed      float32
-}
-
-func (o *GoogleTranslateOrator) stoproutine() {
-	for {
-		<-TTSDoneChan
-		o.logger.Debug("orator got done signal")
-		o.Stop()
-		for len(TTSTextChan) > 0 {
-			<-TTSTextChan
-		}
-		o.mu.Lock()
-		o.textBuffer.Reset()
-		o.interrupt = true
-		o.mu.Unlock()
-	}
-}
-
-func (o *GoogleTranslateOrator) readroutine() {
-	tokenizer, _ := english.NewSentenceTokenizer(nil)
-	for {
-		select {
-		case chunk := <-TTSTextChan:
-			o.mu.Lock()
-			o.interrupt = false
-			_, err := o.textBuffer.WriteString(chunk)
-			if err != nil {
-				o.logger.Warn("failed to write to stringbuilder", "error", err)
-				o.mu.Unlock()
-				continue
-			}
-			text := o.textBuffer.String()
-			sentences := tokenizer.Tokenize(text)
-			o.logger.Debug("adding chunk", "chunk", chunk, "text", text, "sen-len", len(sentences))
-			if len(sentences) <= 1 {
-				o.mu.Unlock()
-				continue
-			}
-			completeSentences := sentences[:len(sentences)-1]
-			remaining := sentences[len(sentences)-1].Text
-			o.textBuffer.Reset()
-			o.textBuffer.WriteString(remaining)
-			o.mu.Unlock()
-			for _, sentence := range completeSentences {
-				o.mu.Lock()
-				interrupted := o.interrupt
-				o.mu.Unlock()
-				if interrupted {
-					return
-				}
-				cleanedText := models.CleanText(sentence.Text)
-				if cleanedText == "" {
-					continue
-				}
-				o.logger.Debug("calling Speak with sentence", "sent", cleanedText)
-				if err := o.Speak(cleanedText); err != nil {
-					o.logger.Error("tts failed", "sentence", cleanedText, "error", err)
-				}
-			}
-		case <-TTSFlushChan:
-			o.logger.Debug("got flushchan signal start")
-			// lln is done get the whole message out
-			if len(TTSTextChan) > 0 { // otherwise might get stuck
-				for chunk := range TTSTextChan {
-					o.mu.Lock()
-					_, err := o.textBuffer.WriteString(chunk)
-					o.mu.Unlock()
-					if err != nil {
-						o.logger.Warn("failed to write to stringbuilder", "error", err)
-						continue
-					}
-					if len(TTSTextChan) == 0 {
-						break
-					}
-				}
-			}
-			o.mu.Lock()
-			remaining := o.textBuffer.String()
-			remaining = models.CleanText(remaining)
-			o.textBuffer.Reset()
-			o.mu.Unlock()
-			if remaining == "" {
-				continue
-			}
-			o.logger.Debug("calling Speak with remainder", "rem", remaining)
-			sentencesRem := tokenizer.Tokenize(remaining)
-			for _, rs := range sentencesRem { // to avoid dumping large volume of text
-				o.mu.Lock()
-				interrupt := o.interrupt
-				o.mu.Unlock()
-				if interrupt {
-					break
-				}
-				if err := o.Speak(rs.Text); err != nil {
-					o.logger.Error("tts failed", "sentence", rs.Text, "error", err)
-				}
-			}
-		}
-	}
-}
-
-func (o *GoogleTranslateOrator) GetLogger() *slog.Logger {
-	return o.logger
-}
-
-func (o *GoogleTranslateOrator) Speak(text string) error {
-	o.logger.Debug("fn: Speak is called", "text-len", len(text))
-	// Generate MP3 data directly as an io.Reader
-	reader, err := o.speech.GenerateSpeech(text)
-	if err != nil {
-		return fmt.Errorf("generate speech failed: %w", err)
-	}
-	// Wrap in io.NopCloser since GenerateSpeech returns io.Reader (no close needed)
-	body := io.NopCloser(reader)
-	defer body.Close()
-	// Build ffplay command with optional speed filter
-	args := []string{"-nodisp", "-autoexit"}
-	if o.Speed > 0.1 && o.Speed != 1.0 {
-		// atempo range is 0.5 to 2.0; you might clamp it here
-		args = append(args, "-af", fmt.Sprintf("atempo=%.2f", o.Speed))
-	}
-	args = append(args, "-i", "pipe:0")
-	cmd := exec.Command("ffplay", args...)
-	stdin, err := cmd.StdinPipe()
-	if err != nil {
-		return fmt.Errorf("failed to get stdin pipe: %w", err)
-	}
-	o.cmdMu.Lock()
-	o.cmd = cmd
-	o.stopCh = make(chan struct{})
-	o.cmdMu.Unlock()
-	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("failed to start ffplay: %w", err)
-	}
-	copyErr := make(chan error, 1)
-	go func() {
-		_, err := io.Copy(stdin, body)
-		stdin.Close()
-		copyErr <- err
-	}()
-	done := make(chan error, 1)
-	go func() {
-		done <- cmd.Wait()
-	}()
-	select {
-	case <-o.stopCh:
-		if o.cmd != nil && o.cmd.Process != nil {
-			o.cmd.Process.Kill()
-		}
-		<-done
-		return nil
-	case copyErrVal := <-copyErr:
-		if copyErrVal != nil {
-			if o.cmd != nil && o.cmd.Process != nil {
-				o.cmd.Process.Kill()
-			}
-			<-done
-			return copyErrVal
-		}
-		return <-done
-	case err := <-done:
-		return err
-	}
-}
-
-func (o *GoogleTranslateOrator) Stop() {
-	o.cmdMu.Lock()
-	defer o.cmdMu.Unlock()
-	// Signal any running Speak to stop
-	if o.stopCh != nil {
-		select {
-		case <-o.stopCh: // already closed
-		default:
-			close(o.stopCh)
-		}
-		o.stopCh = nil
-	}
-	// Kill the external player process if it's still running
-	if o.cmd != nil && o.cmd.Process != nil {
-		o.cmd.Process.Kill()
-		o.cmd.Wait() // clean up zombie process
-		o.cmd = nil
-	}
-	// Also reset text buffer and interrupt flag (with o.mu)
-	o.mu.Lock()
-	o.textBuffer.Reset()
-	o.interrupt = true
-	o.mu.Unlock()
-}

extra/kokoro.go

@@ -1,259 +0,0 @@
-//go:build extra
-// +build extra
-
-package extra
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"gf-lt/models"
-	"io"
-	"log/slog"
-	"net/http"
-	"os/exec"
-	"strings"
-	"sync"
-
-	"github.com/neurosnap/sentences/english"
-)
-
-type KokoroOrator struct {
-	logger   *slog.Logger
-	mu       sync.Mutex
-	URL      string
-	Format   models.AudioFormat
-	Stream   bool
-	Speed    float32
-	Language string
-	Voice    string
-	// fields for playback control
-	cmd    *exec.Cmd
-	cmdMu  sync.Mutex
-	stopCh chan struct{}
-	// textBuffer, interrupt etc. remain the same
-	textBuffer strings.Builder
-	interrupt  bool
-}
-
-func (o *KokoroOrator) GetLogger() *slog.Logger {
-	return o.logger
-}
-
-func (o *KokoroOrator) Speak(text string) error {
-	o.logger.Debug("fn: Speak is called", "text-len", len(text))
-	body, err := o.requestSound(text)
-	if err != nil {
-		return fmt.Errorf("request failed: %w", err)
-	}
-	defer body.Close()
-	cmd := exec.Command("ffplay", "-nodisp", "-autoexit", "-i", "pipe:0")
-	stdin, err := cmd.StdinPipe()
-	if err != nil {
-		return fmt.Errorf("failed to get stdin pipe: %w", err)
-	}
-	o.cmdMu.Lock()
-	o.cmd = cmd
-	o.stopCh = make(chan struct{})
-	o.cmdMu.Unlock()
-	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("failed to start ffplay: %w", err)
-	}
-	// Copy audio in background
-	copyErr := make(chan error, 1)
-	go func() {
-		_, err := io.Copy(stdin, body)
-		stdin.Close()
-		copyErr <- err
-	}()
-	// Wait for player in background
-	done := make(chan error, 1)
-	go func() {
-		done <- cmd.Wait()
-	}()
-	// Wait for BOTH copy and player, but ensure we block until done
-	select {
-	case <-o.stopCh:
-		// Stop requested: kill player and wait for it to exit
-		if o.cmd != nil && o.cmd.Process != nil {
-			o.cmd.Process.Kill()
-		}
-		<-done // Wait for process to actually exit
-		return nil
-	case copyErrVal := <-copyErr:
-		if copyErrVal != nil {
-			// Copy failed: kill player and wait
-			if o.cmd != nil && o.cmd.Process != nil {
-				o.cmd.Process.Kill()
-			}
-			<-done
-			return copyErrVal
-		}
-		// Copy succeeded, now wait for playback to complete
-		return <-done
-	case err := <-done:
-		// Playback finished normally (copy must have succeeded or player would have exited early)
-		return err
-	}
-}
-func (o *KokoroOrator) requestSound(text string) (io.ReadCloser, error) {
-	if o.URL == "" {
-		return nil, fmt.Errorf("TTS URL is empty")
-	}
-	payload := map[string]interface{}{
-		"input":           text,
-		"voice":           o.Voice,
-		"response_format": o.Format,
-		"download_format": o.Format,
-		"stream":          o.Stream,
-		"speed":           o.Speed,
-		// "return_download_link": true,
-		"lang_code": o.Language,
-	}
-	payloadBytes, err := json.Marshal(payload)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal payload: %w", err)
-	}
-	req, err := http.NewRequest("POST", o.URL, bytes.NewBuffer(payloadBytes)) //nolint:noctx
-	if err != nil {
-		return nil, fmt.Errorf("failed to create request: %w", err)
-	}
-	req.Header.Set("accept", "application/json")
-	req.Header.Set("Content-Type", "application/json")
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("request failed: %w", err)
-	}
-	if resp.StatusCode != http.StatusOK {
-		defer resp.Body.Close()
-		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
-	}
-	return resp.Body, nil
-}
-
-func (o *KokoroOrator) stoproutine() {
-	for {
-		<-TTSDoneChan
-		o.logger.Debug("orator got done signal")
-		// 1. Stop any ongoing playback (kills external player, closes stopCh)
-		o.Stop()
-		// 2. Drain any pending text chunks
-		for len(TTSTextChan) > 0 {
-			<-TTSTextChan
-		}
-		// 3. Reset internal state
-		o.mu.Lock()
-		o.textBuffer.Reset()
-		o.interrupt = true
-		o.mu.Unlock()
-	}
-}
-
-func (o *KokoroOrator) Stop() {
-	o.cmdMu.Lock()
-	defer o.cmdMu.Unlock()
-	// Signal any running Speak to stop
-	if o.stopCh != nil {
-		select {
-		case <-o.stopCh: // already closed
-		default:
-			close(o.stopCh)
-		}
-		o.stopCh = nil
-	}
-	// Kill the external player process if it's still running
-	if o.cmd != nil && o.cmd.Process != nil {
-		o.cmd.Process.Kill()
-		o.cmd.Wait() // clean up zombie process
-		o.cmd = nil
-	}
-	// Also reset text buffer and interrupt flag (with o.mu)
-	o.mu.Lock()
-	o.textBuffer.Reset()
-	o.interrupt = true
-	o.mu.Unlock()
-}
-
-func (o *KokoroOrator) readroutine() {
-	tokenizer, _ := english.NewSentenceTokenizer(nil)
-	for {
-		select {
-		case chunk := <-TTSTextChan:
-			o.mu.Lock()
-			o.interrupt = false
-			_, err := o.textBuffer.WriteString(chunk)
-			if err != nil {
-				o.logger.Warn("failed to write to stringbuilder", "error", err)
-				o.mu.Unlock()
-				continue
-			}
-			text := o.textBuffer.String()
-			sentences := tokenizer.Tokenize(text)
-			o.logger.Debug("adding chunk", "chunk", chunk, "text", text, "sen-len", len(sentences))
-			if len(sentences) <= 1 {
-				o.mu.Unlock()
-				continue
-			}
-			completeSentences := sentences[:len(sentences)-1]
-			remaining := sentences[len(sentences)-1].Text
-			o.textBuffer.Reset()
-			o.textBuffer.WriteString(remaining)
-			o.mu.Unlock()
-			for _, sentence := range completeSentences {
-				o.mu.Lock()
-				interrupted := o.interrupt
-				o.mu.Unlock()
-				if interrupted {
-					return
-				}
-				cleanedText := models.CleanText(sentence.Text)
-				if cleanedText == "" {
-					continue
-				}
-				o.logger.Debug("calling Speak with sentence", "sent", cleanedText)
-				if err := o.Speak(cleanedText); err != nil {
-					o.logger.Error("tts failed", "sentence", cleanedText, "error", err)
-				}
-			}
-		case <-TTSFlushChan:
-			o.logger.Debug("got flushchan signal start")
-			// lln is done get the whole message out
-			if len(TTSTextChan) > 0 { // otherwise might get stuck
-				for chunk := range TTSTextChan {
-					o.mu.Lock()
-					_, err := o.textBuffer.WriteString(chunk)
-					o.mu.Unlock()
-					if err != nil {
-						o.logger.Warn("failed to write to stringbuilder", "error", err)
-						continue
-					}
-					if len(TTSTextChan) == 0 {
-						break
-					}
-				}
-			}
-			// flush remaining text
-			o.mu.Lock()
-			remaining := o.textBuffer.String()
-			remaining = models.CleanText(remaining)
-			o.textBuffer.Reset()
-			o.mu.Unlock()
-			if remaining == "" {
-				continue
-			}
-			o.logger.Debug("calling Speak with remainder", "rem", remaining)
-			sentencesRem := tokenizer.Tokenize(remaining)
-			for _, rs := range sentencesRem { // to avoid dumping large volume of text
-				o.mu.Lock()
-				interrupt := o.interrupt
-				o.mu.Unlock()
-				if interrupt {
-					break
-				}
-				if err := o.Speak(rs.Text); err != nil {
-					o.logger.Error("tts failed", "sentence", rs, "error", err)
-				}
-			}
-		}
-	}
-}

extra/stt.go

@@ -6,10 +6,18 @@ package extra
 import (
 	"bytes"
 	"encoding/binary"
+	"errors"
+	"fmt"
 	"gf-lt/config"
 	"io"
 	"log/slog"
+	"mime/multipart"
+	"net/http"
 	"regexp"
+	"strings"
+	"syscall"
+
+	"github.com/gordonklaus/portaudio"
 )
 
 var specialRE = regexp.MustCompile(`\[.*?\]`)
@@ -36,6 +44,14 @@ func NewSTT(logger *slog.Logger, cfg *config.Config) STT {
 	return NewWhisperServer(logger, cfg)
 }
 
+type WhisperServer struct {
+	logger      *slog.Logger
+	ServerURL   string
+	SampleRate  int
+	AudioBuffer *bytes.Buffer
+	recording   bool
+}
+
 func NewWhisperServer(logger *slog.Logger, cfg *config.Config) *WhisperServer {
 	return &WhisperServer{
 		logger:      logger,
@@ -45,6 +61,69 @@ func NewWhisperServer(logger *slog.Logger, cfg *config.Config) *WhisperServer {
 	}
 }
 
+func (stt *WhisperServer) StartRecording() error {
+	if err := stt.microphoneStream(stt.SampleRate); err != nil {
+		return fmt.Errorf("failed to init microphone: %w", err)
+	}
+	stt.recording = true
+	return nil
+}
+
+func (stt *WhisperServer) StopRecording() (string, error) {
+	stt.recording = false
+	// wait loop to finish?
+	if stt.AudioBuffer == nil {
+		err := errors.New("unexpected nil AudioBuffer")
+		stt.logger.Error(err.Error())
+		return "", err
+	}
+	// Create WAV header first
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+	// Add audio file part
+	part, err := writer.CreateFormFile("file", "recording.wav")
+	if err != nil {
+		stt.logger.Error("fn: StopRecording", "error", err)
+		return "", err
+	}
+	// Stream directly to multipart writer: header + raw data
+	dataSize := stt.AudioBuffer.Len()
+	stt.writeWavHeader(part, dataSize)
+	if _, err := io.Copy(part, stt.AudioBuffer); err != nil {
+		stt.logger.Error("fn: StopRecording", "error", err)
+		return "", err
+	}
+	// Reset buffer for next recording
+	stt.AudioBuffer.Reset()
+	// Add response format field
+	err = writer.WriteField("response_format", "text")
+	if err != nil {
+		stt.logger.Error("fn: StopRecording", "error", err)
+		return "", err
+	}
+	if writer.Close() != nil {
+		stt.logger.Error("fn: StopRecording", "error", err)
+		return "", err
+	}
+	// Send request
+	resp, err := http.Post(stt.ServerURL, writer.FormDataContentType(), body) //nolint:noctx
+	if err != nil {
+		stt.logger.Error("fn: StopRecording", "error", err)
+		return "", err
+	}
+	defer resp.Body.Close()
+	// Read and print response
+	responseTextBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		stt.logger.Error("fn: StopRecording", "error", err)
+		return "", err
+	}
+	resptext := strings.TrimRight(string(responseTextBytes), "\n")
+	// in case there are special tokens like [_BEG_]
+	resptext = specialRE.ReplaceAllString(resptext, "")
+	return strings.TrimSpace(strings.ReplaceAll(resptext, "\n ", "\n")), nil
+}
+
 func (stt *WhisperServer) writeWavHeader(w io.Writer, dataSize int) {
 	header := make([]byte, 44)
 	copy(header[0:4], "RIFF")
@@ -68,3 +147,56 @@ func (stt *WhisperServer) writeWavHeader(w io.Writer, dataSize int) {
 func (stt *WhisperServer) IsRecording() bool {
 	return stt.recording
 }
+
+func (stt *WhisperServer) microphoneStream(sampleRate int) error {
+	// Temporarily redirect stderr to suppress ALSA warnings during PortAudio init
+	origStderr, errDup := syscall.Dup(syscall.Stderr)
+	if errDup != nil {
+		return fmt.Errorf("failed to dup stderr: %w", errDup)
+	}
+	nullFD, err := syscall.Open("/dev/null", syscall.O_WRONLY, 0)
+	if err != nil {
+		_ = syscall.Close(origStderr) // Close the dup'd fd if open fails
+		return fmt.Errorf("failed to open /dev/null: %w", err)
+	}
+	// redirect stderr
+	_ = syscall.Dup2(nullFD, syscall.Stderr)
+	// Initialize PortAudio (this is where ALSA warnings occur)
+	defer func() {
+		// Restore stderr
+		_ = syscall.Dup2(origStderr, syscall.Stderr)
+		_ = syscall.Close(origStderr)
+		_ = syscall.Close(nullFD)
+	}()
+	if err := portaudio.Initialize(); err != nil {
+		return fmt.Errorf("portaudio init failed: %w", err)
+	}
+	in := make([]int16, 64)
+	stream, err := portaudio.OpenDefaultStream(1, 0, float64(sampleRate), len(in), in)
+	if err != nil {
+		if paErr := portaudio.Terminate(); paErr != nil {
+			return fmt.Errorf("failed to open microphone: %w; terminate error: %w", err, paErr)
+		}
+		return fmt.Errorf("failed to open microphone: %w", err)
+	}
+	go func(stream *portaudio.Stream) {
+		if err := stream.Start(); err != nil {
+			stt.logger.Error("microphoneStream", "error", err)
+			return
+		}
+		for {
+			if !stt.IsRecording() {
+				return
+			}
+			if err := stream.Read(); err != nil {
+				stt.logger.Error("reading stream", "error", err)
+				return
+			}
+			if err := binary.Write(stt.AudioBuffer, binary.LittleEndian, in); err != nil {
+				stt.logger.Error("writing to buffer", "error", err)
+				return
+			}
+		}
+	}(stream)
+	return nil
+}

extra/tts.go

@@ -4,13 +4,25 @@
 package extra
 
 import (
+	"bytes"
+	"encoding/json"
+	"fmt"
 	"gf-lt/config"
 	"gf-lt/models"
+	"io"
 	"log/slog"
+	"net/http"
 	"os"
 	"strings"
+	"sync"
+	"time"
 
 	google_translate_tts "github.com/GrailFinder/google-translate-tts"
+	"github.com/GrailFinder/google-translate-tts/handlers"
+	"github.com/gopxl/beep/v2"
+	"github.com/gopxl/beep/v2/mp3"
+	"github.com/gopxl/beep/v2/speaker"
+	"github.com/neurosnap/sentences/english"
 )
 
 var (
@@ -27,6 +39,142 @@ type Orator interface {
 	GetLogger() *slog.Logger
 }
 
+// impl https://github.com/remsky/Kokoro-FastAPI
+type KokoroOrator struct {
+	logger        *slog.Logger
+	mu            sync.Mutex
+	URL           string
+	Format        models.AudioFormat
+	Stream        bool
+	Speed         float32
+	Language      string
+	Voice         string
+	currentStream *beep.Ctrl // Added for playback control
+	currentDone   chan bool
+	textBuffer    strings.Builder
+	interrupt     bool
+	// textBuffer bytes.Buffer
+}
+
+// Google Translate TTS implementation
+type GoogleTranslateOrator struct {
+	logger        *slog.Logger
+	mu            sync.Mutex
+	speech        *google_translate_tts.Speech
+	currentStream *beep.Ctrl
+	currentDone   chan bool
+	textBuffer    strings.Builder
+	interrupt     bool
+}
+
+func (o *KokoroOrator) stoproutine() {
+	for {
+		<-TTSDoneChan
+		o.logger.Debug("orator got done signal")
+		o.Stop()
+		// drain the channel
+		for len(TTSTextChan) > 0 {
+			<-TTSTextChan
+		}
+		o.mu.Lock()
+		o.textBuffer.Reset()
+		if o.currentDone != nil {
+			select {
+			case o.currentDone <- true:
+			default:
+				// Channel might be closed, ignore
+			}
+		}
+		o.interrupt = true
+		o.mu.Unlock()
+	}
+}
+
+func (o *KokoroOrator) readroutine() {
+	tokenizer, _ := english.NewSentenceTokenizer(nil)
+	for {
+		select {
+		case chunk := <-TTSTextChan:
+			o.mu.Lock()
+			o.interrupt = false
+			_, err := o.textBuffer.WriteString(chunk)
+			if err != nil {
+				o.logger.Warn("failed to write to stringbuilder", "error", err)
+				o.mu.Unlock()
+				continue
+			}
+			text := o.textBuffer.String()
+			sentences := tokenizer.Tokenize(text)
+			o.logger.Debug("adding chunk", "chunk", chunk, "text", text, "sen-len", len(sentences))
+			if len(sentences) <= 1 {
+				o.mu.Unlock()
+				continue
+			}
+			completeSentences := sentences[:len(sentences)-1]
+			remaining := sentences[len(sentences)-1].Text
+			o.textBuffer.Reset()
+			o.textBuffer.WriteString(remaining)
+			o.mu.Unlock()
+
+			for _, sentence := range completeSentences {
+				o.mu.Lock()
+				interrupted := o.interrupt
+				o.mu.Unlock()
+				if interrupted {
+					return
+				}
+				cleanedText := models.CleanText(sentence.Text)
+				if cleanedText == "" {
+					continue
+				}
+				o.logger.Debug("calling Speak with sentence", "sent", cleanedText)
+				if err := o.Speak(cleanedText); err != nil {
+					o.logger.Error("tts failed", "sentence", cleanedText, "error", err)
+				}
+			}
+		case <-TTSFlushChan:
+			o.logger.Debug("got flushchan signal start")
+			// lln is done get the whole message out
+			if len(TTSTextChan) > 0 { // otherwise might get stuck
+				for chunk := range TTSTextChan {
+					o.mu.Lock()
+					_, err := o.textBuffer.WriteString(chunk)
+					o.mu.Unlock()
+					if err != nil {
+						o.logger.Warn("failed to write to stringbuilder", "error", err)
+						continue
+					}
+					if len(TTSTextChan) == 0 {
+						break
+					}
+				}
+			}
+			// flush remaining text
+			o.mu.Lock()
+			remaining := o.textBuffer.String()
+			remaining = models.CleanText(remaining)
+			o.textBuffer.Reset()
+			o.mu.Unlock()
+			if remaining == "" {
+				continue
+			}
+			o.logger.Debug("calling Speak with remainder", "rem", remaining)
+			sentencesRem := tokenizer.Tokenize(remaining)
+			for _, rs := range sentencesRem { // to avoid dumping large volume of text
+				o.mu.Lock()
+				interrupt := o.interrupt
+				o.mu.Unlock()
+				if interrupt {
+					break
+				}
+				if err := o.Speak(rs.Text); err != nil {
+					o.logger.Error("tts failed", "sentence", rs, "error", err)
+				}
+			}
+		}
+	}
+}
+
 func NewOrator(log *slog.Logger, cfg *config.Config) Orator {
 	provider := cfg.TTS_PROVIDER
 	if provider == "" {
@@ -56,14 +204,270 @@ func NewOrator(log *slog.Logger, cfg *config.Config) Orator {
 			Language: language,
 			Proxy:    "", // Proxy not supported
 			Speed:    cfg.TTS_SPEED,
+			Handler:  &handlers.Beep{},
 		}
 		orator := &GoogleTranslateOrator{
 			logger: log,
 			speech: speech,
-			Speed:  cfg.TTS_SPEED,
 		}
 		go orator.readroutine()
 		go orator.stoproutine()
 		return orator
 	}
 }
+
+func (o *KokoroOrator) GetLogger() *slog.Logger {
+	return o.logger
+}
+
+func (o *KokoroOrator) requestSound(text string) (io.ReadCloser, error) {
+	if o.URL == "" {
+		return nil, fmt.Errorf("TTS URL is empty")
+	}
+	payload := map[string]interface{}{
+		"input":           text,
+		"voice":           o.Voice,
+		"response_format": o.Format,
+		"download_format": o.Format,
+		"stream":          o.Stream,
+		"speed":           o.Speed,
+		// "return_download_link": true,
+		"lang_code": o.Language,
+	}
+	payloadBytes, err := json.Marshal(payload)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal payload: %w", err)
+	}
+	req, err := http.NewRequest("POST", o.URL, bytes.NewBuffer(payloadBytes)) //nolint:noctx
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("accept", "application/json")
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("request failed: %w", err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		defer resp.Body.Close()
+		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	}
+	return resp.Body, nil
+}
+
+func (o *KokoroOrator) Speak(text string) error {
+	o.logger.Debug("fn: Speak is called", "text-len", len(text))
+	body, err := o.requestSound(text)
+	if err != nil {
+		o.logger.Error("request failed", "error", err)
+		return fmt.Errorf("request failed: %w", err)
+	}
+	defer body.Close()
+	// Decode the mp3 audio from response body
+	streamer, format, err := mp3.Decode(body)
+	if err != nil {
+		o.logger.Error("mp3 decode failed", "error", err)
+		return fmt.Errorf("mp3 decode failed: %w", err)
+	}
+	defer streamer.Close()
+	// here it spams with errors that speaker cannot be initialized more than once, but how would we deal with many audio records then?
+	if err := speaker.Init(format.SampleRate, format.SampleRate.N(time.Second/10)); err != nil {
+		o.logger.Debug("failed to init speaker", "error", err)
+	}
+	done := make(chan bool)
+	o.mu.Lock()
+	o.currentDone = done
+	o.currentStream = &beep.Ctrl{Streamer: beep.Seq(streamer, beep.Callback(func() {
+		o.mu.Lock()
+		close(done)
+		o.currentStream = nil
+		o.currentDone = nil
+		o.mu.Unlock()
+	})), Paused: false}
+	o.mu.Unlock()
+	speaker.Play(o.currentStream)
+	<-done
+	return nil
+}
+
+func (o *KokoroOrator) Stop() {
+	// speaker.Clear()
+	o.logger.Debug("attempted to stop orator", "orator", o)
+	speaker.Lock()
+	defer speaker.Unlock()
+	o.mu.Lock()
+	defer o.mu.Unlock()
+	if o.currentStream != nil {
+		// o.currentStream.Paused = true
+		o.currentStream.Streamer = nil
+	}
+}
+
+func (o *GoogleTranslateOrator) stoproutine() {
+	for {
+		<-TTSDoneChan
+		o.logger.Debug("orator got done signal")
+		o.Stop()
+		// drain the channel
+		for len(TTSTextChan) > 0 {
+			<-TTSTextChan
+		}
+		o.mu.Lock()
+		o.textBuffer.Reset()
+		if o.currentDone != nil {
+			select {
+			case o.currentDone <- true:
+			default:
+				// Channel might be closed, ignore
+			}
+		}
+		o.interrupt = true
+		o.mu.Unlock()
+	}
+}
+
+func (o *GoogleTranslateOrator) readroutine() {
+	tokenizer, _ := english.NewSentenceTokenizer(nil)
+	for {
+		select {
+		case chunk := <-TTSTextChan:
+			o.mu.Lock()
+			o.interrupt = false
+			_, err := o.textBuffer.WriteString(chunk)
+			if err != nil {
+				o.logger.Warn("failed to write to stringbuilder", "error", err)
+				o.mu.Unlock()
+				continue
+			}
+			text := o.textBuffer.String()
+			sentences := tokenizer.Tokenize(text)
+			o.logger.Debug("adding chunk", "chunk", chunk, "text", text, "sen-len", len(sentences))
+			if len(sentences) <= 1 {
+				o.mu.Unlock()
+				continue
+			}
+			completeSentences := sentences[:len(sentences)-1]
+			remaining := sentences[len(sentences)-1].Text
+			o.textBuffer.Reset()
+			o.textBuffer.WriteString(remaining)
+			o.mu.Unlock()
+
+			for _, sentence := range completeSentences {
+				o.mu.Lock()
+				interrupted := o.interrupt
+				o.mu.Unlock()
+				if interrupted {
+					return
+				}
+				cleanedText := models.CleanText(sentence.Text)
+				if cleanedText == "" {
+					continue
+				}
+				o.logger.Debug("calling Speak with sentence", "sent", cleanedText)
+				if err := o.Speak(cleanedText); err != nil {
+					o.logger.Error("tts failed", "sentence", cleanedText, "error", err)
+				}
+			}
+		case <-TTSFlushChan:
+			o.logger.Debug("got flushchan signal start")
+			// lln is done get the whole message out
+			if len(TTSTextChan) > 0 { // otherwise might get stuck
+				for chunk := range TTSTextChan {
+					o.mu.Lock()
+					_, err := o.textBuffer.WriteString(chunk)
+					o.mu.Unlock()
+					if err != nil {
+						o.logger.Warn("failed to write to stringbuilder", "error", err)
+						continue
+					}
+					if len(TTSTextChan) == 0 {
+						break
+					}
+				}
+			}
+			o.mu.Lock()
+			remaining := o.textBuffer.String()
+			remaining = models.CleanText(remaining)
+			o.textBuffer.Reset()
+			o.mu.Unlock()
+			if remaining == "" {
+				continue
+			}
+			o.logger.Debug("calling Speak with remainder", "rem", remaining)
+			sentencesRem := tokenizer.Tokenize(remaining)
+			for _, rs := range sentencesRem { // to avoid dumping large volume of text
+				o.mu.Lock()
+				interrupt := o.interrupt
+				o.mu.Unlock()
+				if interrupt {
+					break
+				}
+				if err := o.Speak(rs.Text); err != nil {
+					o.logger.Error("tts failed", "sentence", rs.Text, "error", err)
+				}
+			}
+		}
+	}
+}
+
+func (o *GoogleTranslateOrator) GetLogger() *slog.Logger {
+	return o.logger
+}
+
+func (o *GoogleTranslateOrator) Speak(text string) error {
+	o.logger.Debug("fn: Speak is called", "text-len", len(text))
+	// Generate MP3 data using google-translate-tts
+	reader, err := o.speech.GenerateSpeech(text)
+	if err != nil {
+		o.logger.Error("generate speech failed", "error", err)
+		return fmt.Errorf("generate speech failed: %w", err)
+	}
+	// Decode the mp3 audio from reader (wrap with NopCloser for io.ReadCloser)
+	streamer, format, err := mp3.Decode(io.NopCloser(reader))
+	if err != nil {
+		o.logger.Error("mp3 decode failed", "error", err)
+		return fmt.Errorf("mp3 decode failed: %w", err)
+	}
+	defer streamer.Close()
+	playbackStreamer := beep.Streamer(streamer)
+	speed := o.speech.Speed
+	if speed <= 0 {
+		speed = 1.0
+	}
+	if speed != 1.0 {
+		playbackStreamer = beep.ResampleRatio(3, float64(speed), streamer)
+	}
+	// Initialize speaker with the format's sample rate
+	if err := speaker.Init(format.SampleRate, format.SampleRate.N(time.Second/10)); err != nil {
+		o.logger.Debug("failed to init speaker", "error", err)
+	}
+	done := make(chan bool)
+	o.mu.Lock()
+	o.currentDone = done
+	o.currentStream = &beep.Ctrl{Streamer: beep.Seq(playbackStreamer, beep.Callback(func() {
+		o.mu.Lock()
+		close(done)
+		o.currentStream = nil
+		o.currentDone = nil
+		o.mu.Unlock()
+	})), Paused: false}
+	o.mu.Unlock()
+	speaker.Play(o.currentStream)
+	<-done // wait for playback to complete
+	return nil
+}
+
+func (o *GoogleTranslateOrator) Stop() {
+	o.logger.Debug("attempted to stop google translate orator")
+	speaker.Lock()
+	defer speaker.Unlock()
+	o.mu.Lock()
+	defer o.mu.Unlock()
+	if o.currentStream != nil {
+		o.currentStream.Streamer = nil
+	}
+	// Also stop the speech handler if possible
+	if o.speech != nil {
+		_ = o.speech.Stop()
+	}
+}

extra/whisper_binary.go

@@ -9,13 +9,15 @@ import (
 	"errors"
 	"fmt"
 	"gf-lt/config"
+	"io"
 	"log/slog"
 	"os"
 	"os/exec"
 	"strings"
 	"sync"
 	"syscall"
-	"time"
+
+	"github.com/gordonklaus/portaudio"
 )
 
 type WhisperBinary struct {
@@ -23,143 +25,11 @@ type WhisperBinary struct {
 	whisperPath string
 	modelPath   string
 	lang        string
-	// Per-recording fields (protected by mu)
-	mu        sync.Mutex
-	recording bool
-	tempFile  string
 	ctx         context.Context
 	cancel      context.CancelFunc
-	cmd       *exec.Cmd
+	mu          sync.Mutex
-	cmdMu     sync.Mutex
+	recording   bool
-}
+	audioBuffer []int16
-
-func (w *WhisperBinary) StartRecording() error {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-	if w.recording {
-		return errors.New("recording is already in progress")
-	}
-	// Fresh context for this recording
-	ctx, cancel := context.WithCancel(context.Background())
-	w.ctx = ctx
-	w.cancel = cancel
-	// Create temporary file
-	tempFile, err := os.CreateTemp("", "recording_*.wav")
-	if err != nil {
-		cancel()
-		return fmt.Errorf("failed to create temp file: %w", err)
-	}
-	tempFile.Close()
-	w.tempFile = tempFile.Name()
-	// ffmpeg command: capture from default microphone, write WAV
-	args := []string{
-		"-f", "alsa", // or "pulse" if preferred
-		"-i", "default",
-		"-acodec", "pcm_s16le",
-		"-ar", "16000",
-		"-ac", "1",
-		"-y", // overwrite output file
-		w.tempFile,
-	}
-	cmd := exec.CommandContext(w.ctx, "ffmpeg", args...)
-	// Capture stderr for debugging (optional, but useful for diagnosing)
-	stderr, err := cmd.StderrPipe()
-	if err != nil {
-		cancel()
-		os.Remove(w.tempFile)
-		return fmt.Errorf("failed to create stderr pipe: %w", err)
-	}
-	go func() {
-		buf := make([]byte, 1024)
-		for {
-			n, err := stderr.Read(buf)
-			if n > 0 {
-				w.logger.Debug("ffmpeg stderr", "output", string(buf[:n]))
-			}
-			if err != nil {
-				break
-			}
-		}
-	}()
-	w.cmdMu.Lock()
-	w.cmd = cmd
-	w.cmdMu.Unlock()
-	if err := cmd.Start(); err != nil {
-		cancel()
-		os.Remove(w.tempFile)
-		return fmt.Errorf("failed to start ffmpeg: %w", err)
-	}
-	w.recording = true
-	w.logger.Debug("Recording started", "file", w.tempFile)
-	return nil
-}
-
-func (w *WhisperBinary) StopRecording() (string, error) {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-	if !w.recording {
-		return "", errors.New("not currently recording")
-	}
-	w.recording = false
-	// Gracefully stop ffmpeg
-	w.cmdMu.Lock()
-	if w.cmd != nil && w.cmd.Process != nil {
-		w.logger.Debug("Sending SIGTERM to ffmpeg")
-		w.cmd.Process.Signal(syscall.SIGTERM)
-		// Wait for process to exit (up to 2 seconds)
-		done := make(chan error, 1)
-		go func() {
-			done <- w.cmd.Wait()
-		}()
-		select {
-		case <-done:
-			w.logger.Debug("ffmpeg exited after SIGTERM")
-		case <-time.After(2 * time.Second):
-			w.logger.Warn("ffmpeg did not exit, sending SIGKILL")
-			w.cmd.Process.Kill()
-			<-done
-		}
-	}
-	w.cmdMu.Unlock()
-	// Cancel context (already done, but for cleanliness)
-	if w.cancel != nil {
-		w.cancel()
-	}
-	// Validate temp file
-	if w.tempFile == "" {
-		return "", errors.New("no recording file")
-	}
-	defer os.Remove(w.tempFile)
-	info, err := os.Stat(w.tempFile)
-	if err != nil {
-		return "", fmt.Errorf("failed to stat temp file: %w", err)
-	}
-	if info.Size() < 44 { // WAV header is 44 bytes
-		// Log ffmpeg stderr? Already captured in debug logs.
-		return "", fmt.Errorf("recording file too small (%d bytes), possibly no audio captured", info.Size())
-	}
-	// Run whisper.cpp binary
-	cmd := exec.Command(w.whisperPath, "-m", w.modelPath, "-l", w.lang, w.tempFile)
-	var outBuf, errBuf bytes.Buffer
-	cmd.Stdout = &outBuf
-	cmd.Stderr = &errBuf
-	if err := cmd.Run(); err != nil {
-		w.logger.Error("whisper binary failed",
-			"error", err,
-			"stderr", errBuf.String(),
-			"file_size", info.Size())
-		return "", fmt.Errorf("whisper binary failed: %w (stderr: %s)", err, errBuf.String())
-	}
-	result := strings.TrimRight(outBuf.String(), "\n")
-	result = specialRE.ReplaceAllString(result, "")
-	return strings.TrimSpace(strings.ReplaceAll(result, "\n ", "\n")), nil
-}
-
-// IsRecording returns true if a recording is in progress.
-func (w *WhisperBinary) IsRecording() bool {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-	return w.recording
 }
 
 func NewWhisperBinary(logger *slog.Logger, cfg *config.Config) *WhisperBinary {
@@ -174,3 +44,283 @@ func NewWhisperBinary(logger *slog.Logger, cfg *config.Config) *WhisperBinary {
 		cancel:      cancel,
 	}
 }
+
+func (w *WhisperBinary) StartRecording() error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	if w.recording {
+		return errors.New("recording is already in progress")
+	}
+	// If context is cancelled, create a new one for the next recording session
+	if w.ctx.Err() != nil {
+		w.logger.Debug("Context cancelled, creating new context")
+		w.ctx, w.cancel = context.WithCancel(context.Background())
+	}
+	// Temporarily redirect stderr to suppress ALSA warnings during PortAudio init
+	origStderr, errDup := syscall.Dup(syscall.Stderr)
+	if errDup != nil {
+		return fmt.Errorf("failed to dup stderr: %w", errDup)
+	}
+	nullFD, err := syscall.Open("/dev/null", syscall.O_WRONLY, 0)
+	if err != nil {
+		_ = syscall.Close(origStderr) // Close the dup'd fd if open fails
+		return fmt.Errorf("failed to open /dev/null: %w", err)
+	}
+	// redirect stderr
+	_ = syscall.Dup2(nullFD, syscall.Stderr)
+	// Initialize PortAudio (this is where ALSA warnings occur)
+	portaudioErr := portaudio.Initialize()
+	defer func() {
+		// Restore stderr
+		_ = syscall.Dup2(origStderr, syscall.Stderr)
+		_ = syscall.Close(origStderr)
+		_ = syscall.Close(nullFD)
+	}()
+	if portaudioErr != nil {
+		return fmt.Errorf("portaudio init failed: %w", portaudioErr)
+	}
+	// Initialize audio buffer
+	w.audioBuffer = make([]int16, 0)
+	in := make([]int16, 1024) // buffer size
+	stream, err := portaudio.OpenDefaultStream(1, 0, 16000.0, len(in), in)
+	if err != nil {
+		if paErr := portaudio.Terminate(); paErr != nil {
+			return fmt.Errorf("failed to open microphone: %w; terminate error: %w", err, paErr)
+		}
+		return fmt.Errorf("failed to open microphone: %w", err)
+	}
+	go w.recordAudio(stream, in)
+	w.recording = true
+	w.logger.Debug("Recording started")
+	return nil
+}
+
+func (w *WhisperBinary) recordAudio(stream *portaudio.Stream, in []int16) {
+	defer func() {
+		w.logger.Debug("recordAudio defer function called")
+		_ = stream.Stop()         // Stop the stream
+		_ = portaudio.Terminate() // ignoring error as we're shutting down
+		w.logger.Debug("recordAudio terminated")
+	}()
+	w.logger.Debug("Starting audio stream")
+	if err := stream.Start(); err != nil {
+		w.logger.Error("Failed to start audio stream", "error", err)
+		return
+	}
+	w.logger.Debug("Audio stream started, entering recording loop")
+	for {
+		select {
+		case <-w.ctx.Done():
+			w.logger.Debug("Context done, exiting recording loop")
+			return
+		default:
+			// Check recording status with minimal lock time
+			w.mu.Lock()
+			recording := w.recording
+			w.mu.Unlock()
+
+			if !recording {
+				w.logger.Debug("Recording flag is false, exiting recording loop")
+				return
+			}
+			if err := stream.Read(); err != nil {
+				w.logger.Error("Error reading from stream", "error", err)
+				return
+			}
+			// Append samples to buffer - only acquire lock when necessary
+			w.mu.Lock()
+			if w.audioBuffer == nil {
+				w.audioBuffer = make([]int16, 0)
+			}
+			// Make a copy of the input buffer to avoid overwriting
+			tempBuffer := make([]int16, len(in))
+			copy(tempBuffer, in)
+			w.audioBuffer = append(w.audioBuffer, tempBuffer...)
+			w.mu.Unlock()
+		}
+	}
+}
+
+func (w *WhisperBinary) StopRecording() (string, error) {
+	w.logger.Debug("StopRecording called")
+	w.mu.Lock()
+	if !w.recording {
+		w.mu.Unlock()
+		return "", errors.New("not currently recording")
+	}
+	w.logger.Debug("Setting recording to false and cancelling context")
+	w.recording = false
+	w.cancel() // This will stop the recording goroutine
+	w.mu.Unlock()
+	// // Small delay to allow the recording goroutine to react to context cancellation
+	// time.Sleep(20 * time.Millisecond)
+	// Save the recorded audio to a temporary file
+	tempFile, err := w.saveAudioToTempFile()
+	if err != nil {
+		w.logger.Error("Error saving audio to temp file", "error", err)
+		return "", fmt.Errorf("failed to save audio to temp file: %w", err)
+	}
+	w.logger.Debug("Saved audio to temp file", "file", tempFile)
+	// Run the whisper binary with a separate context to avoid cancellation during transcription
+	cmd := exec.Command(w.whisperPath, "-m", w.modelPath, "-l", w.lang, tempFile, "2>/dev/null")
+	var outBuf bytes.Buffer
+	cmd.Stdout = &outBuf
+	// Redirect stderr to suppress ALSA warnings and other stderr output
+	cmd.Stderr = io.Discard // Suppress stderr output from whisper binary
+	w.logger.Debug("Running whisper binary command")
+	if err := cmd.Run(); err != nil {
+		// Clean up audio buffer
+		w.mu.Lock()
+		w.audioBuffer = nil
+		w.mu.Unlock()
+		// Since we're suppressing stderr, we'll just log that the command failed
+		w.logger.Error("Error running whisper binary", "error", err)
+		return "", fmt.Errorf("whisper binary failed: %w", err)
+	}
+	result := outBuf.String()
+	w.logger.Debug("Whisper binary completed", "result", result)
+	// Clean up audio buffer
+	w.mu.Lock()
+	w.audioBuffer = nil
+	w.mu.Unlock()
+	// Clean up the temporary file after transcription
+	w.logger.Debug("StopRecording completed")
+	os.Remove(tempFile)
+	result = strings.TrimRight(result, "\n")
+	// in case there are special tokens like [_BEG_]
+	result = specialRE.ReplaceAllString(result, "")
+	return strings.TrimSpace(strings.ReplaceAll(result, "\n ", "\n")), nil
+}
+
+// saveAudioToTempFile saves the recorded audio data to a temporary WAV file
+func (w *WhisperBinary) saveAudioToTempFile() (string, error) {
+	w.logger.Debug("saveAudioToTempFile called")
+	// Create temporary WAV file
+	tempFile, err := os.CreateTemp("", "recording_*.wav")
+	if err != nil {
+		w.logger.Error("Failed to create temp file", "error", err)
+		return "", fmt.Errorf("failed to create temp file: %w", err)
+	}
+	w.logger.Debug("Created temp file", "file", tempFile.Name())
+	defer tempFile.Close()
+
+	// Write WAV header and data
+	w.logger.Debug("About to write WAV file", "file", tempFile.Name())
+	err = w.writeWAVFile(tempFile.Name())
+	if err != nil {
+		w.logger.Error("Error writing WAV file", "error", err)
+		return "", fmt.Errorf("failed to write WAV file: %w", err)
+	}
+	w.logger.Debug("WAV file written successfully", "file", tempFile.Name())
+
+	return tempFile.Name(), nil
+}
+
+// writeWAVFile creates a WAV file from the recorded audio data
+func (w *WhisperBinary) writeWAVFile(filename string) error {
+	w.logger.Debug("writeWAVFile called", "filename", filename)
+	// Open file for writing
+	file, err := os.Create(filename)
+	if err != nil {
+		w.logger.Error("Error creating file", "error", err)
+		return err
+	}
+	defer file.Close()
+
+	w.logger.Debug("About to acquire mutex in writeWAVFile")
+	w.mu.Lock()
+	w.logger.Debug("Locked mutex, copying audio buffer")
+	audioData := make([]int16, len(w.audioBuffer))
+	copy(audioData, w.audioBuffer)
+	w.mu.Unlock()
+	w.logger.Debug("Unlocked mutex", "audio_data_length", len(audioData))
+
+	if len(audioData) == 0 {
+		w.logger.Warn("No audio data to write")
+		return errors.New("no audio data to write")
+	}
+
+	// Calculate data size (number of samples * size of int16)
+	dataSize := len(audioData) * 2 // 2 bytes per int16 sample
+	w.logger.Debug("Calculated data size", "size", dataSize)
+
+	// Write WAV header with the correct data size
+	header := w.createWAVHeader(16000, 1, 16, dataSize)
+	_, err = file.Write(header)
+	if err != nil {
+		w.logger.Error("Error writing WAV header", "error", err)
+		return err
+	}
+	w.logger.Debug("WAV header written successfully")
+
+	// Write audio data
+	w.logger.Debug("About to write audio data samples")
+	for i, sample := range audioData {
+		// Write little-endian 16-bit sample
+		_, err := file.Write([]byte{byte(sample), byte(sample >> 8)})
+		if err != nil {
+			w.logger.Error("Error writing sample", "index", i, "error", err)
+			return err
+		}
+		// Log progress every 10000 samples to avoid too much output
+		if i%10000 == 0 {
+			w.logger.Debug("Written samples", "count", i)
+		}
+	}
+	w.logger.Debug("All audio data written successfully")
+
+	return nil
+}
+
+// createWAVHeader creates a WAV file header
+func (w *WhisperBinary) createWAVHeader(sampleRate, channels, bitsPerSample int, dataSize int) []byte {
+	header := make([]byte, 44)
+	copy(header[0:4], "RIFF")
+	// Total file size will be updated later
+	copy(header[8:12], "WAVE")
+	copy(header[12:16], "fmt ")
+	// fmt chunk size (16 for PCM)
+	header[16] = 16
+	header[17] = 0
+	header[18] = 0
+	header[19] = 0
+	// Audio format (1 = PCM)
+	header[20] = 1
+	header[21] = 0
+	// Number of channels
+	header[22] = byte(channels)
+	header[23] = 0
+	// Sample rate
+	header[24] = byte(sampleRate)
+	header[25] = byte(sampleRate >> 8)
+	header[26] = byte(sampleRate >> 16)
+	header[27] = byte(sampleRate >> 24)
+	// Byte rate
+	byteRate := sampleRate * channels * bitsPerSample / 8
+	header[28] = byte(byteRate)
+	header[29] = byte(byteRate >> 8)
+	header[30] = byte(byteRate >> 16)
+	header[31] = byte(byteRate >> 24)
+	// Block align
+	blockAlign := channels * bitsPerSample / 8
+	header[32] = byte(blockAlign)
+	header[33] = 0
+	// Bits per sample
+	header[34] = byte(bitsPerSample)
+	header[35] = 0
+	// "data" subchunk
+	copy(header[36:40], "data")
+	// Data size
+	header[40] = byte(dataSize)
+	header[41] = byte(dataSize >> 8)
+	header[42] = byte(dataSize >> 16)
+	header[43] = byte(dataSize >> 24)
+
+	return header
+}
+
+func (w *WhisperBinary) IsRecording() bool {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	return w.recording
+}

extra/whisper_server.go

@@ -1,156 +0,0 @@
-//go:build extra
-// +build extra
-
-package extra
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-	"log/slog"
-	"mime/multipart"
-	"net/http"
-	"os/exec"
-	"strings"
-	"sync"
-)
-
-type WhisperServer struct {
-	logger      *slog.Logger
-	ServerURL   string
-	SampleRate  int
-	AudioBuffer *bytes.Buffer
-	recording   bool          // protected by mu
-	mu          sync.Mutex    // protects recording & AudioBuffer
-	cmd         *exec.Cmd     // protected by cmdMu
-	stopCh      chan struct{} // protected by cmdMu
-	cmdMu       sync.Mutex    // protects cmd and stopCh
-}
-
-func (stt *WhisperServer) StartRecording() error {
-	stt.mu.Lock()
-	defer stt.mu.Unlock()
-	if stt.recording {
-		return nil
-	}
-	// Build ffmpeg command for microphone capture
-	args := []string{
-		"-f", "alsa",
-		"-i", "default",
-		"-acodec", "pcm_s16le",
-		"-ar", fmt.Sprint(stt.SampleRate),
-		"-ac", "1",
-		"-f", "s16le",
-		"-",
-	}
-	cmd := exec.Command("ffmpeg", args...)
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		return fmt.Errorf("failed to get stdout pipe: %w", err)
-	}
-	stt.cmdMu.Lock()
-	stt.cmd = cmd
-	stt.stopCh = make(chan struct{})
-	stt.cmdMu.Unlock()
-	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("failed to start ffmpeg: %w", err)
-	}
-	stt.recording = true
-	stt.AudioBuffer.Reset()
-	// Read PCM data in goroutine
-	go func() {
-		buf := make([]byte, 4096)
-		for {
-			select {
-			case <-stt.stopCh:
-				return
-			default:
-				n, err := stdout.Read(buf)
-				if n > 0 {
-					stt.mu.Lock()
-					stt.AudioBuffer.Write(buf[:n])
-					stt.mu.Unlock()
-				}
-				if err != nil {
-					if err != io.EOF {
-						stt.logger.Error("recording read error", "error", err)
-					}
-					return
-				}
-			}
-		}
-	}()
-	return nil
-}
-
-func (stt *WhisperServer) StopRecording() (string, error) {
-	stt.mu.Lock()
-	defer stt.mu.Unlock()
-	if !stt.recording {
-		return "", errors.New("not recording")
-	}
-	stt.recording = false
-	// Stop ffmpeg
-	stt.cmdMu.Lock()
-	if stt.cmd != nil && stt.cmd.Process != nil {
-		stt.cmd.Process.Kill()
-		stt.cmd.Wait()
-	}
-	close(stt.stopCh)
-	stt.cmdMu.Unlock()
-	// Rest of StopRecording unchanged (WAV header + HTTP upload)
-	// ...
-	stt.recording = false
-	// wait loop to finish?
-	if stt.AudioBuffer == nil {
-		err := errors.New("unexpected nil AudioBuffer")
-		stt.logger.Error(err.Error())
-		return "", err
-	}
-	// Create WAV header first
-	body := &bytes.Buffer{}
-	writer := multipart.NewWriter(body)
-	// Add audio file part
-	part, err := writer.CreateFormFile("file", "recording.wav")
-	if err != nil {
-		stt.logger.Error("fn: StopRecording", "error", err)
-		return "", err
-	}
-	// Stream directly to multipart writer: header + raw data
-	dataSize := stt.AudioBuffer.Len()
-	stt.writeWavHeader(part, dataSize)
-	if _, err := io.Copy(part, stt.AudioBuffer); err != nil {
-		stt.logger.Error("fn: StopRecording", "error", err)
-		return "", err
-	}
-	// Reset buffer for next recording
-	stt.AudioBuffer.Reset()
-	// Add response format field
-	err = writer.WriteField("response_format", "text")
-	if err != nil {
-		stt.logger.Error("fn: StopRecording", "error", err)
-		return "", err
-	}
-	if writer.Close() != nil {
-		stt.logger.Error("fn: StopRecording", "error", err)
-		return "", err
-	}
-	// Send request
-	resp, err := http.Post(stt.ServerURL, writer.FormDataContentType(), body) //nolint:noctx
-	if err != nil {
-		stt.logger.Error("fn: StopRecording", "error", err)
-		return "", err
-	}
-	defer resp.Body.Close()
-	// Read and print response
-	responseTextBytes, err := io.ReadAll(resp.Body)
-	if err != nil {
-		stt.logger.Error("fn: StopRecording", "error", err)
-		return "", err
-	}
-	resptext := strings.TrimRight(string(responseTextBytes), "\n")
-	// in case there are special tokens like [_BEG_]
-	resptext = specialRE.ReplaceAllString(resptext, "")
-	return strings.TrimSpace(strings.ReplaceAll(resptext, "\n ", "\n")), nil
-}

go.mod

@@ -4,11 +4,13 @@ go 1.25.1
 
 require (
 	github.com/BurntSushi/toml v1.5.0
-	github.com/GrailFinder/google-translate-tts v0.1.4
+	github.com/GrailFinder/google-translate-tts v0.1.3
 	github.com/GrailFinder/searchagent v0.2.0
 	github.com/PuerkitoBio/goquery v1.11.0
 	github.com/gdamore/tcell/v2 v2.13.2
 	github.com/glebarez/go-sqlite v1.22.0
+	github.com/gopxl/beep/v2 v2.1.1
+	github.com/gordonklaus/portaudio v0.0.0-20250206071425-98a94950218b
 	github.com/jmoiron/sqlx v1.4.0
 	github.com/ledongthuc/pdf v0.0.0-20250511090121-5959a4027728
 	github.com/neurosnap/sentences v1.1.2
@@ -23,17 +25,21 @@ require (
 	github.com/andybalholm/cascadia v1.3.3 // indirect
 	github.com/deckarep/golang-set/v2 v2.8.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/ebitengine/oto/v3 v3.4.0 // indirect
+	github.com/ebitengine/purego v0.9.1 // indirect
 	github.com/emirpasic/gods v1.18.1 // indirect
 	github.com/gdamore/encoding v1.0.1 // indirect
 	github.com/go-jose/go-jose/v3 v3.0.4 // indirect
 	github.com/go-stack/stack v1.8.1 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/hajimehoshi/go-mp3 v0.3.4 // indirect
+	github.com/hajimehoshi/oto/v2 v2.3.1 // indirect
 	github.com/lucasb-eyer/go-colorful v1.3.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db // indirect
 	github.com/ncruces/go-strftime v1.0.0 // indirect
 	github.com/patrickmn/go-cache v2.1.0+incompatible // indirect
+	github.com/pkg/errors v0.9.1 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/schollz/progressbar/v2 v2.15.0 // indirect

go.sum

@@ -2,8 +2,8 @@ filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
 filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
 github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg=
 github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
-github.com/GrailFinder/google-translate-tts v0.1.4 h1:NJoPZUGfBrmouQMN19MUcNPNUx4tmf4a8OZRME4E4Mg=
+github.com/GrailFinder/google-translate-tts v0.1.3 h1:Mww9tNzTWjjSh+OCbTPl/+21oMPKcUecXZfU7nTB/lA=
-github.com/GrailFinder/google-translate-tts v0.1.4/go.mod h1:YIOLKR7sObazdUCrSex3u9OVBovU55eYgWa25vsQJ18=
+github.com/GrailFinder/google-translate-tts v0.1.3/go.mod h1:YIOLKR7sObazdUCrSex3u9OVBovU55eYgWa25vsQJ18=
 github.com/GrailFinder/searchagent v0.2.0 h1:U2GVjLh/9xZt0xX9OcYk9Q2fMkyzyTiADPUmUisRdtQ=
 github.com/GrailFinder/searchagent v0.2.0/go.mod h1:d66tn5+22LI8IGJREUsRBT60P0sFdgQgvQRqyvgItrs=
 github.com/PuerkitoBio/goquery v1.11.0 h1:jZ7pwMQXIITcUXNH83LLk+txlaEy6NVOfTuP43xxfqw=
@@ -17,6 +17,10 @@ github.com/deckarep/golang-set/v2 v2.8.0 h1:swm0rlPCmdWn9mESxKOjWk8hXSqoxOp+Zlfu
 github.com/deckarep/golang-set/v2 v2.8.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/ebitengine/oto/v3 v3.4.0 h1:br0PgASsEWaoWn38b2Goe7m1GKFYfNgnsjSd5Gg+/bQ=
+github.com/ebitengine/oto/v3 v3.4.0/go.mod h1:IOleLVD0m+CMak3mRVwsYY8vTctQgOM0iiL6S7Ar7eI=
+github.com/ebitengine/purego v0.9.1 h1:a/k2f2HQU3Pi399RPW1MOaZyhKJL9w/xFpKAg4q1s0A=
+github.com/ebitengine/purego v0.9.1/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
 github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
 github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
 github.com/gdamore/encoding v1.0.1 h1:YzKZckdBL6jVt2Gc+5p82qhrGiqMdG/eNs6Wy0u3Uhw=
@@ -37,8 +41,13 @@ github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17k
 github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gopxl/beep/v2 v2.1.1 h1:6FYIYMm2qPAdWkjX+7xwKrViS1x0Po5kDMdRkq8NVbU=
+github.com/gopxl/beep/v2 v2.1.1/go.mod h1:ZAm9TGQ9lvpoiFLd4zf5B1IuyxZhgRACMId1XJbaW0E=
+github.com/gordonklaus/portaudio v0.0.0-20250206071425-98a94950218b h1:WEuQWBxelOGHA6z9lABqaMLMrfwVyMdN3UgRLT+YUPo=
+github.com/gordonklaus/portaudio v0.0.0-20250206071425-98a94950218b/go.mod h1:esZFQEUwqC+l76f2R8bIWSwXMaPbp79PppwZ1eJhFco=
 github.com/hajimehoshi/go-mp3 v0.3.4 h1:NUP7pBYH8OguP4diaTZ9wJbUbk3tC0KlfzsEpWmYj68=
 github.com/hajimehoshi/go-mp3 v0.3.4/go.mod h1:fRtZraRFcWb0pu7ok0LqyFhCUrPeMsGRSVop0eemFmo=
+github.com/hajimehoshi/oto/v2 v2.3.1 h1:qrLKpNus2UfD674oxckKjNJmesp9hMh7u7QCrStB3Rc=
 github.com/hajimehoshi/oto/v2 v2.3.1/go.mod h1:seWLbgHH7AyUMYKfKYT9pg7PhUu9/SisyJvNTT+ASQo=
 github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
 github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
@@ -62,6 +71,8 @@ github.com/neurosnap/sentences v1.1.2 h1:iphYOzx/XckXeBiLIUBkPu2EKMJ+6jDbz/sLJZ7
 github.com/neurosnap/sentences v1.1.2/go.mod h1:/pwU4E9XNL21ygMIkOIllv/SMy2ujHwpf8GQPu1YPbQ=
 github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaRUnok+kx1WdO15EQc=
 github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/playwright-community/playwright-go v0.5700.1 h1:PNFb1byWqrTT720rEO0JL88C6Ju0EmUnR5deFLvtP/U=
 github.com/playwright-community/playwright-go v0.5700.1/go.mod h1:MlSn1dZrx8rszbCxY6x3qK89ZesJUYVx21B2JnkoNF0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=

helpfuncs.go

@@ -5,6 +5,7 @@ import (
 	"gf-lt/models"
 	"gf-lt/pngmeta"
 	"image"
+	"net/url"
 	"os"
 	"os/exec"
 	"path"
@@ -15,11 +16,17 @@ import (
 	"time"
 	"unicode"
 
+	"sync/atomic"
+
 	"github.com/rivo/tview"
 )
 
 // Cached model color - updated by background goroutine
-var cachedModelColor string = "orange"
+var cachedModelColor atomic.Value // stores string
+
+func init() {
+	cachedModelColor.Store("orange")
+}
 
 // startModelColorUpdater starts a background goroutine that periodically updates
 // the cached model color. Only runs HTTP requests for local llama.cpp APIs.
@@ -38,20 +45,20 @@ func startModelColorUpdater() {
 // updateCachedModelColor updates the global cachedModelColor variable
 func updateCachedModelColor() {
 	if !isLocalLlamacpp() {
-		cachedModelColor = "orange"
+		cachedModelColor.Store("orange")
 		return
 	}
 	// Check if model is loaded
-	loaded, err := isModelLoaded(chatBody.Model)
+	loaded, err := isModelLoaded(chatBody.GetModel())
 	if err != nil {
 		// On error, assume not loaded (red)
-		cachedModelColor = "red"
+		cachedModelColor.Store("red")
 		return
 	}
 	if loaded {
-		cachedModelColor = "green"
+		cachedModelColor.Store("green")
 	} else {
-		cachedModelColor = "red"
+		cachedModelColor.Store("red")
 	}
 }
 
@@ -102,7 +109,7 @@ func refreshChatDisplay() {
 		viewingAs = cfg.WriteNextMsgAs
 	}
 	// Filter messages for this character
-	filteredMessages := filterMessagesForCharacter(chatBody.Messages, viewingAs)
+	filteredMessages := filterMessagesForCharacter(chatBody.GetMessages(), viewingAs)
 	displayText := chatToText(filteredMessages, cfg.ShowSys)
 	textView.SetText(displayText)
 	colorText()
@@ -216,8 +223,8 @@ func startNewChat(keepSysP bool) {
 		logger.Warn("no such sys msg", "name", cfg.AssistantRole)
 	}
 	// set chat body
-	chatBody.Messages = chatBody.Messages[:2]
+	chatBody.TruncateMessages(2)
-	textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
+	textView.SetText(chatToText(chatBody.GetMessages(), cfg.ShowSys))
 	newChat := &models.Chat{
 		ID:        id + 1,
 		Name:      fmt.Sprintf("%d_%s", id+1, cfg.AssistantRole),
@@ -322,17 +329,19 @@ func strInSlice(s string, sl []string) bool {
 
 // isLocalLlamacpp checks if the current API is a local llama.cpp instance.
 func isLocalLlamacpp() bool {
-	if strings.Contains(cfg.CurrentAPI, "openrouter") || strings.Contains(cfg.CurrentAPI, "deepseek") {
+	u, err := url.Parse(cfg.CurrentAPI)
+	if err != nil {
 		return false
 	}
-	return true
+	host := u.Hostname()
+	return host == "localhost" || host == "127.0.0.1" || host == "::1"
 }
 
 // getModelColor returns the cached color tag for the model name.
 // The cached value is updated by a background goroutine every 5 seconds.
 // For non-local models, returns orange. For local llama.cpp models, returns green if loaded, red if not.
 func getModelColor() string {
-	return cachedModelColor
+	return cachedModelColor.Load().(string)
 }
 
 func makeStatusLine() string {
@@ -367,7 +376,7 @@ func makeStatusLine() string {
 	// Get model color based on load status for local llama.cpp models
 	modelColor := getModelColor()
 	statusLine := fmt.Sprintf(statusLineTempl, activeChatName,
-		boolColors[cfg.ToolUse], modelColor, chatBody.Model, boolColors[cfg.SkipLLMResp],
+		boolColors[cfg.ToolUse], modelColor, chatBody.GetModel(), boolColors[cfg.SkipLLMResp],
 		cfg.CurrentAPI, persona, botPersona)
 	if cfg.STT_ENABLED {
 		recordingS := fmt.Sprintf(" | [%s:-:b]voice recording[-:-:-] (ctrl+r)",
@@ -393,11 +402,11 @@ func makeStatusLine() string {
 }
 
 func getContextTokens() int {
-	if chatBody == nil || chatBody.Messages == nil {
+	if chatBody == nil {
 		return 0
 	}
 	total := 0
-	messages := chatBody.Messages
+	messages := chatBody.GetMessages()
 	for i := range messages {
 		msg := &messages[i]
 		if msg.Stats != nil && msg.Stats.Tokens > 0 {
@@ -412,26 +421,33 @@ func getContextTokens() int {
 const deepseekContext = 128000
 
 func getMaxContextTokens() int {
-	if chatBody == nil || chatBody.Model == "" {
+	if chatBody == nil || chatBody.GetModel() == "" {
 		return 0
 	}
-	modelName := chatBody.Model
+	modelName := chatBody.GetModel()
 	switch {
 	case strings.Contains(cfg.CurrentAPI, "openrouter"):
-		if orModelsData != nil {
+		ord := orModelsData.Load()
-			for i := range orModelsData.Data {
+		if ord != nil {
-				m := &orModelsData.Data[i]
+			data := ord.(*models.ORModels)
+			if data != nil {
+				for i := range data.Data {
+					m := &data.Data[i]
 					if m.ID == modelName {
 						return m.ContextLength
 					}
 				}
 			}
+		}
 	case strings.Contains(cfg.CurrentAPI, "deepseek"):
 		return deepseekContext
 	default:
-		if localModelsData != nil {
+		lmd := localModelsData.Load()
-			for i := range localModelsData.Data {
+		if lmd != nil {
-				m := &localModelsData.Data[i]
+			data := lmd.(*models.LCPModels)
+			if data != nil {
+				for i := range data.Data {
+					m := &data.Data[i]
 					if m.ID == modelName {
 						for _, arg := range m.Status.Args {
 							if strings.HasPrefix(arg, "--ctx-size") {
@@ -460,6 +476,7 @@ func getMaxContextTokens() int {
 				}
 			}
 		}
+	}
 	return 0
 }
 
@@ -487,7 +504,7 @@ func listChatRoles() []string {
 
 func deepseekModelValidator() error {
 	if cfg.CurrentAPI == cfg.DeepSeekChatAPI || cfg.CurrentAPI == cfg.DeepSeekCompletionAPI {
-		if chatBody.Model != "deepseek-chat" && chatBody.Model != "deepseek-reasoner" {
+		if chatBody.GetModel() != "deepseek-chat" && chatBody.GetModel() != "deepseek-reasoner" {
 			showToast("bad request", "wrong deepseek model name")
 			return nil
 		}
@@ -564,13 +581,13 @@ func executeCommandAndDisplay(cmdText string) {
 			outputContent := workingDir
 			// Add the command being executed to the chat
 			fmt.Fprintf(textView, "\n[-:-:b](%d) <%s>: [-:-:-]\n$ %s\n",
-				len(chatBody.Messages), cfg.ToolRole, cmdText)
+				chatBody.GetMessageCount(), cfg.ToolRole, cmdText)
 			fmt.Fprintf(textView, "%s\n", outputContent)
 			combinedMsg := models.RoleMsg{
 				Role:    cfg.ToolRole,
 				Content: "$ " + cmdText + "\n\n" + outputContent,
 			}
-			chatBody.Messages = append(chatBody.Messages, combinedMsg)
+			chatBody.AppendMessage(combinedMsg)
 			if scrollToEndEnabled {
 				textView.ScrollToEnd()
 			}
@@ -579,13 +596,13 @@ func executeCommandAndDisplay(cmdText string) {
 		} else {
 			outputContent := "cd: " + newDir + ": No such file or directory"
 			fmt.Fprintf(textView, "\n[-:-:b](%d) <%s>: [-:-:-]\n$ %s\n",
-				len(chatBody.Messages), cfg.ToolRole, cmdText)
+				chatBody.GetMessageCount(), cfg.ToolRole, cmdText)
 			fmt.Fprintf(textView, "[red]%s[-:-:-]\n", outputContent)
 			combinedMsg := models.RoleMsg{
 				Role:    cfg.ToolRole,
 				Content: "$ " + cmdText + "\n\n" + outputContent,
 			}
-			chatBody.Messages = append(chatBody.Messages, combinedMsg)
+			chatBody.AppendMessage(combinedMsg)
 			if scrollToEndEnabled {
 				textView.ScrollToEnd()
 			}
@@ -601,7 +618,7 @@ func executeCommandAndDisplay(cmdText string) {
 	output, err := cmd.CombinedOutput()
 	// Add the command being executed to the chat
 	fmt.Fprintf(textView, "\n[-:-:b](%d) <%s>: [-:-:-]\n$ %s\n",
-		len(chatBody.Messages), cfg.ToolRole, cmdText)
+		chatBody.GetMessageCount(), cfg.ToolRole, cmdText)
 	var outputContent string
 	if err != nil {
 		// Include both output and error
@@ -632,7 +649,7 @@ func executeCommandAndDisplay(cmdText string) {
 		Role:    cfg.ToolRole,
 		Content: combinedContent,
 	}
-	chatBody.Messages = append(chatBody.Messages, combinedMsg)
+	chatBody.AppendMessage(combinedMsg)
 	// Scroll to end and update colors
 	if scrollToEndEnabled {
 		textView.ScrollToEnd()
@@ -662,7 +679,7 @@ func performSearch(term string) {
 		searchResultLengths = nil
 		originalTextForSearch = ""
 		// Re-render text without highlights
-		textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
+		textView.SetText(chatToText(chatBody.GetMessages(), cfg.ShowSys))
 		colorText()
 		return
 	}
@@ -964,52 +981,3 @@ func extractDisplayPath(p, bp string) string {
 	}
 	return p
 }
-
-func getValidKnowToRecipient(msg *models.RoleMsg) (string, bool) {
-	if cfg == nil || !cfg.CharSpecificContextEnabled {
-		return "", false
-	}
-	// case where all roles are in the tag => public message
-	cr := listChatRoles()
-	slices.Sort(cr)
-	slices.Sort(msg.KnownTo)
-	if slices.Equal(cr, msg.KnownTo) {
-		logger.Info("got msg with tag mentioning every role")
-		return "", false
-	}
-	// Check each character in the KnownTo list
-	for _, recipient := range msg.KnownTo {
-		if recipient == msg.Role || recipient == cfg.ToolRole {
-			// weird cases, skip
-			continue
-		}
-		// Skip if this is the user character (user handles their own turn)
-		// If user is in KnownTo, stop processing - it's the user's turn
-		if recipient == cfg.UserRole || recipient == cfg.WriteNextMsgAs {
-			return "", false
-		}
-		return recipient, true
-	}
-	return "", false
-}
-
-// triggerPrivateMessageResponses checks if a message was sent privately to specific characters
-// and triggers those non-user characters to respond
-func triggerPrivateMessageResponses(msg *models.RoleMsg) {
-	recipient, ok := getValidKnowToRecipient(msg)
-	if !ok || recipient == "" {
-		return
-	}
-	// Trigger the recipient character to respond
-	triggerMsg := recipient + ":\n"
-	// Send empty message so LLM continues naturally from the conversation
-	crr := &models.ChatRoundReq{
-		UserMsg: triggerMsg,
-		Role:    recipient,
-		Resume:  true,
-	}
-	fmt.Fprintf(textView, "\n[-:-:b](%d) ", len(chatBody.Messages))
-	fmt.Fprint(textView, roleToIcon(recipient))
-	fmt.Fprint(textView, "[-:-:-]\n")
-	chatRoundChan <- crr
-}

llm.go

@@ -13,8 +13,9 @@ var lastImg string             // for ctrl+j
 
 // containsToolSysMsg checks if the toolSysMsg already exists in the chat body
 func containsToolSysMsg() bool {
-	for i := range chatBody.Messages {
+	messages := chatBody.GetMessages()
-		if chatBody.Messages[i].Role == cfg.ToolRole && chatBody.Messages[i].Content == toolSysMsg {
+	for i := range messages {
+		if messages[i].Role == cfg.ToolRole && messages[i].Content == toolSysMsg {
 			return true
 		}
 	}
@@ -62,11 +63,11 @@ type ChunkParser interface {
 func choseChunkParser() {
 	chunkParser = LCPCompletion{}
 	switch cfg.CurrentAPI {
-	case "http://localhost:8080/completion", "http://127.0.0.1:8080/completion":
+	case "http://localhost:8080/completion":
 		chunkParser = LCPCompletion{}
 		logger.Debug("chosen lcpcompletion", "link", cfg.CurrentAPI)
 		return
-	case "http://localhost:8080/v1/chat/completions", "http://127.0.0.1:8080/v1/chat/completions":
+	case "http://localhost:8080/v1/chat/completions":
 		chunkParser = LCPChat{}
 		logger.Debug("chosen lcpchat", "link", cfg.CurrentAPI)
 		return
@@ -87,11 +88,6 @@ func choseChunkParser() {
 		logger.Debug("chosen openrouterchat", "link", cfg.CurrentAPI)
 		return
 	default:
-		logger.Warn("unexpected case, assuming llama.cpp on non default address", "link", cfg.CurrentAPI)
-		if strings.Contains(cfg.CurrentAPI, "chat") {
-			chunkParser = LCPChat{}
-			return
-		}
 		chunkParser = LCPCompletion{}
 	}
 }
@@ -140,13 +136,13 @@ func (lcp LCPCompletion) FormMsg(msg, role string, resume bool) (io.Reader, erro
 			newMsg = models.RoleMsg{Role: role, Content: msg}
 		}
 		newMsg = *processMessageTag(&newMsg)
-		chatBody.Messages = append(chatBody.Messages, newMsg)
+		chatBody.AppendMessage(newMsg)
 	}
 	// sending description of the tools and how to use them
 	if cfg.ToolUse && !resume && role == cfg.UserRole && !containsToolSysMsg() {
-		chatBody.Messages = append(chatBody.Messages, models.RoleMsg{Role: cfg.ToolRole, Content: toolSysMsg})
+		chatBody.AppendMessage(models.RoleMsg{Role: cfg.ToolRole, Content: toolSysMsg})
 	}
-	filteredMessages, botPersona := filterMessagesForCurrentCharacter(chatBody.Messages)
+	filteredMessages, botPersona := filterMessagesForCurrentCharacter(chatBody.GetMessages())
 	// Build prompt and extract images inline as we process each message
 	messages := make([]string, len(filteredMessages))
 	for i := range filteredMessages {
@@ -188,7 +184,7 @@ func (lcp LCPCompletion) FormMsg(msg, role string, resume bool) (io.Reader, erro
 	}
 	logger.Debug("checking prompt for /completion", "tool_use", cfg.ToolUse,
 		"msg", msg, "resume", resume, "prompt", prompt, "multimodal_data_count", len(multimodalData))
-	payload := models.NewLCPReq(prompt, chatBody.Model, multimodalData,
+	payload := models.NewLCPReq(prompt, chatBody.GetModel(), multimodalData,
 		defaultLCPProps, chatBody.MakeStopSliceExcluding("", listChatRoles()))
 	data, err := json.Marshal(payload)
 	if err != nil {
@@ -294,17 +290,17 @@ func (op LCPChat) FormMsg(msg, role string, resume bool) (io.Reader, error) {
 			newMsg = models.NewRoleMsg(role, msg)
 		}
 		newMsg = *processMessageTag(&newMsg)
-		chatBody.Messages = append(chatBody.Messages, newMsg)
+		chatBody.AppendMessage(newMsg)
 		logger.Debug("LCPChat FormMsg: added message to chatBody", "role", newMsg.Role,
-			"content_len", len(newMsg.Content), "message_count_after_add", len(chatBody.Messages))
+			"content_len", len(newMsg.Content), "message_count_after_add", chatBody.GetMessageCount())
 	}
-	filteredMessages, _ := filterMessagesForCurrentCharacter(chatBody.Messages)
+	filteredMessages, _ := filterMessagesForCurrentCharacter(chatBody.GetMessages())
 	// openai /v1/chat does not support custom roles; needs to be user, assistant, system
 	// Add persona suffix to the last user message to indicate who the assistant should reply as
 	bodyCopy := &models.ChatBody{
 		Messages: make([]models.RoleMsg, len(filteredMessages)),
-		Model:    chatBody.Model,
+		Model:    chatBody.GetModel(),
-		Stream:   chatBody.Stream,
+		Stream:   chatBody.GetStream(),
 	}
 	for i := range filteredMessages {
 		strippedMsg := *stripThinkingFromMsg(&filteredMessages[i])
@@ -380,13 +376,13 @@ func (ds DeepSeekerCompletion) FormMsg(msg, role string, resume bool) (io.Reader
 	if msg != "" { // otherwise let the bot to continue
 		newMsg := models.RoleMsg{Role: role, Content: msg}
 		newMsg = *processMessageTag(&newMsg)
-		chatBody.Messages = append(chatBody.Messages, newMsg)
+		chatBody.AppendMessage(newMsg)
 	}
 	// sending description of the tools and how to use them
 	if cfg.ToolUse && !resume && role == cfg.UserRole && !containsToolSysMsg() {
-		chatBody.Messages = append(chatBody.Messages, models.RoleMsg{Role: cfg.ToolRole, Content: toolSysMsg})
+		chatBody.AppendMessage(models.RoleMsg{Role: cfg.ToolRole, Content: toolSysMsg})
 	}
-	filteredMessages, botPersona := filterMessagesForCurrentCharacter(chatBody.Messages)
+	filteredMessages, botPersona := filterMessagesForCurrentCharacter(chatBody.GetMessages())
 	messages := make([]string, len(filteredMessages))
 	for i := range filteredMessages {
 		messages[i] = stripThinkingFromMsg(&filteredMessages[i]).ToPrompt()
@@ -399,7 +395,7 @@ func (ds DeepSeekerCompletion) FormMsg(msg, role string, resume bool) (io.Reader
 	}
 	logger.Debug("checking prompt for /completion", "tool_use", cfg.ToolUse,
 		"msg", msg, "resume", resume, "prompt", prompt)
-	payload := models.NewDSCompletionReq(prompt, chatBody.Model,
+	payload := models.NewDSCompletionReq(prompt, chatBody.GetModel(),
 		defaultLCPProps["temp"],
 		chatBody.MakeStopSliceExcluding("", listChatRoles()))
 	data, err := json.Marshal(payload)
@@ -453,15 +449,15 @@ func (ds DeepSeekerChat) FormMsg(msg, role string, resume bool) (io.Reader, erro
 	if msg != "" { // otherwise let the bot continue
 		newMsg := models.RoleMsg{Role: role, Content: msg}
 		newMsg = *processMessageTag(&newMsg)
-		chatBody.Messages = append(chatBody.Messages, newMsg)
+		chatBody.AppendMessage(newMsg)
 	}
 	// Create copy of chat body with standardized user role
-	filteredMessages, _ := filterMessagesForCurrentCharacter(chatBody.Messages)
+	filteredMessages, _ := filterMessagesForCurrentCharacter(chatBody.GetMessages())
 	// Add persona suffix to the last user message to indicate who the assistant should reply as
 	bodyCopy := &models.ChatBody{
 		Messages: make([]models.RoleMsg, len(filteredMessages)),
-		Model:    chatBody.Model,
+		Model:    chatBody.GetModel(),
-		Stream:   chatBody.Stream,
+		Stream:   chatBody.GetStream(),
 	}
 	for i := range filteredMessages {
 		strippedMsg := *stripThinkingFromMsg(&filteredMessages[i])
@@ -532,13 +528,13 @@ func (or OpenRouterCompletion) FormMsg(msg, role string, resume bool) (io.Reader
 	if msg != "" { // otherwise let the bot to continue
 		newMsg := models.RoleMsg{Role: role, Content: msg}
 		newMsg = *processMessageTag(&newMsg)
-		chatBody.Messages = append(chatBody.Messages, newMsg)
+		chatBody.AppendMessage(newMsg)
 	}
 	// sending description of the tools and how to use them
 	if cfg.ToolUse && !resume && role == cfg.UserRole && !containsToolSysMsg() {
-		chatBody.Messages = append(chatBody.Messages, models.RoleMsg{Role: cfg.ToolRole, Content: toolSysMsg})
+		chatBody.AppendMessage(models.RoleMsg{Role: cfg.ToolRole, Content: toolSysMsg})
 	}
-	filteredMessages, botPersona := filterMessagesForCurrentCharacter(chatBody.Messages)
+	filteredMessages, botPersona := filterMessagesForCurrentCharacter(chatBody.GetMessages())
 	messages := make([]string, len(filteredMessages))
 	for i := range filteredMessages {
 		messages[i] = stripThinkingFromMsg(&filteredMessages[i]).ToPrompt()
@@ -552,7 +548,7 @@ func (or OpenRouterCompletion) FormMsg(msg, role string, resume bool) (io.Reader
 	stopSlice := chatBody.MakeStopSliceExcluding("", listChatRoles())
 	logger.Debug("checking prompt for /completion", "tool_use", cfg.ToolUse,
 		"msg", msg, "resume", resume, "prompt", prompt, "stop_strings", stopSlice)
-	payload := models.NewOpenRouterCompletionReq(chatBody.Model, prompt,
+	payload := models.NewOpenRouterCompletionReq(chatBody.GetModel(), prompt,
 		defaultLCPProps, stopSlice)
 	data, err := json.Marshal(payload)
 	if err != nil {
@@ -638,15 +634,15 @@ func (or OpenRouterChat) FormMsg(msg, role string, resume bool) (io.Reader, erro
 			newMsg = models.NewRoleMsg(role, msg)
 		}
 		newMsg = *processMessageTag(&newMsg)
-		chatBody.Messages = append(chatBody.Messages, newMsg)
+		chatBody.AppendMessage(newMsg)
 	}
 	// Create copy of chat body with standardized user role
-	filteredMessages, _ := filterMessagesForCurrentCharacter(chatBody.Messages)
+	filteredMessages, _ := filterMessagesForCurrentCharacter(chatBody.GetMessages())
 	// Add persona suffix to the last user message to indicate who the assistant should reply as
 	bodyCopy := &models.ChatBody{
 		Messages: make([]models.RoleMsg, len(filteredMessages)),
-		Model:    chatBody.Model,
+		Model:    chatBody.GetModel(),
-		Stream:   chatBody.Stream,
+		Stream:   chatBody.GetStream(),
 	}
 	for i := range filteredMessages {
 		strippedMsg := *stripThinkingFromMsg(&filteredMessages[i])

models/models.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 	"strings"
+	"sync"
 )
 
 type FuncCall struct {
@@ -639,3 +640,253 @@ type MultimodalToolResp struct {
 	Type  string              `json:"type"`
 	Parts []map[string]string `json:"parts"`
 }
+
+// SafeChatBody is a thread-safe wrapper around ChatBody using RWMutex.
+// This allows safe concurrent access to chat state from multiple goroutines.
+type SafeChatBody struct {
+	mu sync.RWMutex
+	ChatBody
+}
+
+// NewSafeChatBody creates a new SafeChatBody from an existing ChatBody.
+// If cb is nil, creates an empty ChatBody.
+func NewSafeChatBody(cb *ChatBody) *SafeChatBody {
+	if cb == nil {
+		return &SafeChatBody{
+			ChatBody: ChatBody{
+				Messages: []RoleMsg{},
+			},
+		}
+	}
+	return &SafeChatBody{
+		ChatBody: *cb,
+	}
+}
+
+// GetModel returns the model name (thread-safe read).
+func (s *SafeChatBody) GetModel() string {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.Model
+}
+
+// SetModel sets the model name (thread-safe write).
+func (s *SafeChatBody) SetModel(model string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.Model = model
+}
+
+// GetStream returns the stream flag (thread-safe read).
+func (s *SafeChatBody) GetStream() bool {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.Stream
+}
+
+// SetStream sets the stream flag (thread-safe write).
+func (s *SafeChatBody) SetStream(stream bool) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.Stream = stream
+}
+
+// GetMessages returns a copy of all messages (thread-safe read).
+// Returns a copy to prevent race conditions after the lock is released.
+func (s *SafeChatBody) GetMessages() []RoleMsg {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	// Return a copy to prevent external modification
+	messagesCopy := make([]RoleMsg, len(s.Messages))
+	copy(messagesCopy, s.Messages)
+	return messagesCopy
+}
+
+// SetMessages replaces all messages (thread-safe write).
+func (s *SafeChatBody) SetMessages(messages []RoleMsg) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.Messages = messages
+}
+
+// AppendMessage adds a message to the end (thread-safe write).
+func (s *SafeChatBody) AppendMessage(msg RoleMsg) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.Messages = append(s.Messages, msg)
+}
+
+// GetMessageAt returns a message at a specific index (thread-safe read).
+// Returns the message and a boolean indicating if the index was valid.
+func (s *SafeChatBody) GetMessageAt(index int) (RoleMsg, bool) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	if index < 0 || index >= len(s.Messages) {
+		return RoleMsg{}, false
+	}
+	return s.Messages[index], true
+}
+
+// SetMessageAt updates a message at a specific index (thread-safe write).
+// Returns false if index is out of bounds.
+func (s *SafeChatBody) SetMessageAt(index int, msg RoleMsg) bool {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if index < 0 || index >= len(s.Messages) {
+		return false
+	}
+	s.Messages[index] = msg
+	return true
+}
+
+// GetLastMessage returns the last message (thread-safe read).
+// Returns the message and a boolean indicating if the chat has messages.
+func (s *SafeChatBody) GetLastMessage() (RoleMsg, bool) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	if len(s.Messages) == 0 {
+		return RoleMsg{}, false
+	}
+	return s.Messages[len(s.Messages)-1], true
+}
+
+// GetMessageCount returns the number of messages (thread-safe read).
+func (s *SafeChatBody) GetMessageCount() int {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return len(s.Messages)
+}
+
+// RemoveLastMessage removes the last message (thread-safe write).
+// Returns false if there are no messages.
+func (s *SafeChatBody) RemoveLastMessage() bool {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if len(s.Messages) == 0 {
+		return false
+	}
+	s.Messages = s.Messages[:len(s.Messages)-1]
+	return true
+}
+
+// TruncateMessages keeps only the first n messages (thread-safe write).
+func (s *SafeChatBody) TruncateMessages(n int) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if n < len(s.Messages) {
+		s.Messages = s.Messages[:n]
+	}
+}
+
+// ClearMessages removes all messages (thread-safe write).
+func (s *SafeChatBody) ClearMessages() {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.Messages = []RoleMsg{}
+}
+
+// Rename renames all occurrences of oldname to newname in messages (thread-safe read-modify-write).
+func (s *SafeChatBody) Rename(oldname, newname string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	for i := range s.Messages {
+		s.Messages[i].Content = strings.ReplaceAll(s.Messages[i].Content, oldname, newname)
+		s.Messages[i].Role = strings.ReplaceAll(s.Messages[i].Role, oldname, newname)
+	}
+}
+
+// ListRoles returns all unique roles in messages (thread-safe read).
+func (s *SafeChatBody) ListRoles() []string {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	namesMap := make(map[string]struct{})
+	for i := range s.Messages {
+		namesMap[s.Messages[i].Role] = struct{}{}
+	}
+	resp := make([]string, len(namesMap))
+	i := 0
+	for k := range namesMap {
+		resp[i] = k
+		i++
+	}
+	return resp
+}
+
+// MakeStopSlice returns stop strings for all roles (thread-safe read).
+func (s *SafeChatBody) MakeStopSlice() []string {
+	return s.MakeStopSliceExcluding("", s.ListRoles())
+}
+
+// MakeStopSliceExcluding returns stop strings excluding a specific role (thread-safe read).
+func (s *SafeChatBody) MakeStopSliceExcluding(excludeRole string, roleList []string) []string {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	ss := []string{}
+	for _, role := range roleList {
+		if role == excludeRole {
+			continue
+		}
+		ss = append(ss,
+			role+":\n",
+			role+":",
+			role+": ",
+			role+":  ",
+			role+":  \n",
+			role+":   ",
+		)
+	}
+	return ss
+}
+
+// UpdateMessageFunc updates a message at index using a provided function.
+// The function receives the current message and returns the updated message.
+// This is atomic and thread-safe (read-modify-write under single lock).
+// Returns false if index is out of bounds.
+func (s *SafeChatBody) UpdateMessageFunc(index int, updater func(RoleMsg) RoleMsg) bool {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if index < 0 || index >= len(s.Messages) {
+		return false
+	}
+	s.Messages[index] = updater(s.Messages[index])
+	return true
+}
+
+// AppendMessageFunc appends a new message created by a provided function.
+// The function receives the current message count and returns the new message.
+// This is atomic and thread-safe.
+func (s *SafeChatBody) AppendMessageFunc(creator func(count int) RoleMsg) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	msg := creator(len(s.Messages))
+	s.Messages = append(s.Messages, msg)
+}
+
+// GetMessagesForLLM returns a filtered copy of messages for sending to LLM.
+// This is thread-safe and returns a copy safe for external modification.
+func (s *SafeChatBody) GetMessagesForLLM(filterFunc func([]RoleMsg) []RoleMsg) []RoleMsg {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	if filterFunc == nil {
+		messagesCopy := make([]RoleMsg, len(s.Messages))
+		copy(messagesCopy, s.Messages)
+		return messagesCopy
+	}
+	return filterFunc(s.Messages)
+}
+
+// WithLock executes a function while holding the write lock.
+// Use this for complex operations that need to be atomic.
+func (s *SafeChatBody) WithLock(fn func(*ChatBody)) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	fn(&s.ChatBody)
+}
+
+// WithRLock executes a function while holding the read lock.
+// Use this for complex read-only operations.
+func (s *SafeChatBody) WithRLock(fn func(*ChatBody)) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	fn(&s.ChatBody)
+}

popups.go

@@ -22,7 +22,7 @@ func showModelSelectionPopup() {
 		models, err := fetchLCPModelsWithLoadStatus()
 		if err != nil {
 			logger.Error("failed to fetch models with load status", "error", err)
-			return LocalModels
+			return LocalModels.Load().([]string)
 		}
 		return models
 	}
@@ -30,7 +30,8 @@ func showModelSelectionPopup() {
 	modelList := getModelListForAPI(cfg.CurrentAPI)
 	// Check for empty options list
 	if len(modelList) == 0 {
-		logger.Warn("empty model list for", "api", cfg.CurrentAPI, "localModelsLen", len(LocalModels), "orModelsLen", len(ORFreeModels))
+		localModels := LocalModels.Load().([]string)
+		logger.Warn("empty model list for", "api", cfg.CurrentAPI, "localModelsLen", len(localModels), "orModelsLen", len(ORFreeModels))
 		var message string
 		switch {
 		case strings.Contains(cfg.CurrentAPI, "openrouter.ai"):
@@ -50,7 +51,7 @@ func showModelSelectionPopup() {
 	// Find the current model index to set as selected
 	currentModelIndex := -1
 	for i, model := range modelList {
-		if strings.TrimPrefix(model, models.LoadedMark) == chatBody.Model {
+		if strings.TrimPrefix(model, models.LoadedMark) == chatBody.GetModel() {
 			currentModelIndex = i
 		}
 		modelListWidget.AddItem(model, "", 0, nil)
@@ -61,8 +62,8 @@ func showModelSelectionPopup() {
 	}
 	modelListWidget.SetSelectedFunc(func(index int, mainText string, secondaryText string, shortcut rune) {
 		modelName := strings.TrimPrefix(mainText, models.LoadedMark)
-		chatBody.Model = modelName
+		chatBody.SetModel(modelName)
-		cfg.CurrentModel = chatBody.Model
+		cfg.CurrentModel = chatBody.GetModel()
 		pages.RemovePage("modelSelectionPopup")
 		app.SetFocus(textArea)
 		updateCachedModelColor()
@@ -150,15 +151,13 @@ func showAPILinkSelectionPopup() {
 			}
 			// Assume local llama.cpp
 			refreshLocalModelsIfEmpty()
-			localModelsMu.RLock()
+			return LocalModels.Load().([]string)
-			defer localModelsMu.RUnlock()
-			return LocalModels
 		}
 		newModelList := getModelListForAPI(cfg.CurrentAPI)
 		// Ensure chatBody.Model is in the new list; if not, set to first available model
-		if len(newModelList) > 0 && !slices.Contains(newModelList, chatBody.Model) {
+		if len(newModelList) > 0 && !slices.Contains(newModelList, chatBody.GetModel()) {
-			chatBody.Model = strings.TrimPrefix(newModelList[0], models.LoadedMark)
+			chatBody.SetModel(strings.TrimPrefix(newModelList[0], models.LoadedMark))
-			cfg.CurrentModel = chatBody.Model
+			cfg.CurrentModel = chatBody.GetModel()
 			updateToolCapabilities()
 		}
 		pages.RemovePage("apiLinkSelectionPopup")
@@ -229,7 +228,7 @@ func showUserRoleSelectionPopup() {
 		// Update the user role in config
 		cfg.WriteNextMsgAs = mainText
 		// role got switch, update textview with character specific context for user
-		filtered := filterMessagesForCharacter(chatBody.Messages, mainText)
+		filtered := filterMessagesForCharacter(chatBody.GetMessages(), mainText)
 		textView.SetText(chatToText(filtered, cfg.ShowSys))
 		// Remove the popup page
 		pages.RemovePage("userRoleSelectionPopup")

props_table.go

@@ -4,14 +4,11 @@ import (
 	"fmt"
 	"strconv"
 	"strings"
-	"sync"
 
 	"github.com/gdamore/tcell/v2"
 	"github.com/rivo/tview"
 )
 
-var _ = sync.RWMutex{}
-
 // Define constants for cell types
 const (
 	CellTypeCheckbox  = "checkbox"
@@ -157,9 +154,7 @@ func makePropsTable(props map[string]float32) *tview.Table {
 		}
 		// Assume local llama.cpp
 		refreshLocalModelsIfEmpty()
-		localModelsMu.RLock()
+		return LocalModels.Load().([]string)
-		defer localModelsMu.RUnlock()
-		return LocalModels
 	}
 	// Add input fields
 	addInputRow("New char to write msg as", "", func(text string) {
@@ -262,7 +257,8 @@ func makePropsTable(props map[string]float32) *tview.Table {
 
 				// Check for empty options list
 				if len(data.Options) == 0 {
-					logger.Warn("empty options list for", "label", label, "api", cfg.CurrentAPI, "localModelsLen", len(LocalModels), "orModelsLen", len(ORFreeModels))
+					localModels := LocalModels.Load().([]string)
+					logger.Warn("empty options list for", "label", label, "api", cfg.CurrentAPI, "localModelsLen", len(localModels), "orModelsLen", len(ORFreeModels))
 					message := "No options available for " + label
 					if label == "Select a model" {
 						switch {

session.go

@@ -29,7 +29,7 @@ func historyToSJSON(msgs []models.RoleMsg) (string, error) {
 }
 
 func exportChat() error {
-	data, err := json.MarshalIndent(chatBody.Messages, "", "  ")
+	data, err := json.MarshalIndent(chatBody.GetMessages(), "", "  ")
 	if err != nil {
 		return err
 	}
@@ -54,7 +54,7 @@ func importChat(filename string) error {
 	if _, ok := chatMap[activeChatName]; !ok {
 		addNewChat(activeChatName)
 	}
-	chatBody.Messages = messages
+	chatBody.SetMessages(messages)
 	cfg.AssistantRole = messages[1].Role
 	if cfg.AssistantRole == cfg.UserRole {
 		cfg.AssistantRole = messages[2].Role

tables.go

@@ -128,8 +128,8 @@ func makeChatTable(chatMap map[string]models.Chat) *tview.Table {
 				pages.RemovePage(historyPage)
 				return
 			}
-			chatBody.Messages = history
+			chatBody.SetMessages(history)
-			textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
+			textView.SetText(chatToText(chatBody.GetMessages(), cfg.ShowSys))
 			activeChatName = selectedChat
 			pages.RemovePage(historyPage)
 			return
@@ -149,8 +149,8 @@ func makeChatTable(chatMap map[string]models.Chat) *tview.Table {
 			}
 			showToast("chat deleted", selectedChat+" was deleted")
 			// load last chat
-			chatBody.Messages = loadOldChatOrGetNew()
+			chatBody.SetMessages(loadOldChatOrGetNew())
-			textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
+			textView.SetText(chatToText(chatBody.GetMessages(), cfg.ShowSys))
 			pages.RemovePage(historyPage)
 			return
 		case "update card":
@@ -163,16 +163,24 @@ func makeChatTable(chatMap map[string]models.Chat) *tview.Table {
 				showToast("error", "no such card: "+agentName)
 				return
 			}
-			cc.SysPrompt = chatBody.Messages[0].Content
+			if msg0, ok := chatBody.GetMessageAt(0); ok {
-			cc.FirstMsg = chatBody.Messages[1].Content
+				cc.SysPrompt = msg0.Content
+			}
+			if msg1, ok := chatBody.GetMessageAt(1); ok {
+				cc.FirstMsg = msg1.Content
+			}
 			if err := pngmeta.WriteToPng(cc.ToSpec(cfg.UserRole), cc.FilePath, cc.FilePath); err != nil {
 				logger.Error("failed to write charcard", "error", err)
 			}
 			return
 		case "move sysprompt onto 1st msg":
-			chatBody.Messages[1].Content = chatBody.Messages[0].Content + chatBody.Messages[1].Content
+			chatBody.WithLock(func(cb *models.ChatBody) {
-			chatBody.Messages[0].Content = rpDefenitionSysMsg
+				if len(cb.Messages) >= 2 {
-			textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
+					cb.Messages[1].Content = cb.Messages[0].Content + cb.Messages[1].Content
+					cb.Messages[0].Content = rpDefenitionSysMsg
+				}
+			})
+			textView.SetText(chatToText(chatBody.GetMessages(), cfg.ShowSys))
 			activeChatName = selectedChat
 			pages.RemovePage(historyPage)
 			return
@@ -563,7 +571,7 @@ func makeAgentTable(agentList []string) *tview.Table {
 				return
 			}
 			// replace textview
-			textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
+			textView.SetText(chatToText(chatBody.GetMessages(), cfg.ShowSys))
 			colorText()
 			updateStatusLine()
 			// sysModal.ClearButtons()
@@ -732,7 +740,7 @@ func makeImportChatTable(filenames []string) *tview.Table {
 			colorText()
 			updateStatusLine()
 			// redraw the text in text area
-			textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
+			textView.SetText(chatToText(chatBody.GetMessages(), cfg.ShowSys))
 			pages.RemovePage(historyPage)
 			app.SetFocus(textArea)
 			return

tools.go

@@ -207,7 +207,7 @@ var (
 	modelHasVision       bool
 )
 
-func initTools() {
+func init() {
 	sysMap[basicCard.ID] = basicCard
 	roleToID["assistant"] = basicCard.ID
 	sa, err := searcher.NewWebSurfer(searcher.SearcherTypeScraper, "")
@@ -1215,11 +1215,11 @@ func isCommandAllowed(command string, args ...string) bool {
 }
 
 func summarizeChat(args map[string]string) []byte {
-	if len(chatBody.Messages) == 0 {
+	if chatBody.GetMessageCount() == 0 {
 		return []byte("No chat history to summarize.")
 	}
 	// Format chat history for the agent
-	chatText := chatToText(chatBody.Messages, true) // include system and tool messages
+	chatText := chatToText(chatBody.GetMessages(), true) // include system and tool messages
 	return []byte(chatText)
 }
 
@@ -2273,3 +2273,56 @@ var baseTools = []models.Tool{
 		},
 	},
 }
+
+func init() {
+	if windowToolsAvailable {
+		baseTools = append(baseTools,
+			models.Tool{
+				Type: "function",
+				Function: models.ToolFunc{
+					Name:        "list_windows",
+					Description: "List all visible windows with their IDs and names. Returns a map of window ID to window name.",
+					Parameters: models.ToolFuncParams{
+						Type:       "object",
+						Required:   []string{},
+						Properties: map[string]models.ToolArgProps{},
+					},
+				},
+			},
+			models.Tool{
+				Type: "function",
+				Function: models.ToolFunc{
+					Name:        "capture_window",
+					Description: "Capture a screenshot of a specific window and save it to /tmp. Requires window parameter (window ID or name substring).",
+					Parameters: models.ToolFuncParams{
+						Type:     "object",
+						Required: []string{"window"},
+						Properties: map[string]models.ToolArgProps{
+							"window": models.ToolArgProps{
+								Type:        "string",
+								Description: "window ID or window name (partial match)",
+							},
+						},
+					},
+				},
+			},
+			models.Tool{
+				Type: "function",
+				Function: models.ToolFunc{
+					Name:        "capture_window_and_view",
+					Description: "Capture a screenshot of a specific window, save it to /tmp, and return the image for viewing. Requires window parameter (window ID or name substring).",
+					Parameters: models.ToolFuncParams{
+						Type:     "object",
+						Required: []string{"window"},
+						Properties: map[string]models.ToolArgProps{
+							"window": models.ToolArgProps{
+								Type:        "string",
+								Description: "window ID or window name (partial match)",
+							},
+						},
+					},
+				},
+			},
+		)
+	}
+}

tui.go

@@ -224,7 +224,7 @@ func showToast(title, message string) {
 	})
 }
 
-func initTUI() {
+func init() {
 	// Start background goroutine to update model color cache
 	startModelColorUpdater()
 	tview.Styles = colorschemes["default"]
@@ -355,7 +355,7 @@ func initTUI() {
 				searchResults = nil       // Clear search results
 				searchResultLengths = nil // Clear search result lengths
 				originalTextForSearch = ""
-				textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys)) // Reset text without search regions
+				textView.SetText(chatToText(chatBody.GetMessages(), cfg.ShowSys)) // Reset text without search regions
 				colorText()                                                  // Apply normal chat coloring
 			} else {
 				// Original logic if no search is active
@@ -436,9 +436,11 @@ func initTUI() {
 				pages.RemovePage(editMsgPage)
 				return nil
 			}
-			chatBody.Messages[selectedIndex].SetText(editedMsg)
+			chatBody.WithLock(func(cb *models.ChatBody) {
+				cb.Messages[selectedIndex].SetText(editedMsg)
+			})
 			// change textarea
-			textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
+			textView.SetText(chatToText(chatBody.GetMessages(), cfg.ShowSys))
 			pages.RemovePage(editMsgPage)
 			editMode = false
 			return nil
@@ -466,9 +468,11 @@ func initTUI() {
 					pages.RemovePage(roleEditPage)
 					return
 				}
-				if selectedIndex >= 0 && selectedIndex < len(chatBody.Messages) {
+				if selectedIndex >= 0 && selectedIndex < chatBody.GetMessageCount() {
-					chatBody.Messages[selectedIndex].Role = newRole
+					chatBody.WithLock(func(cb *models.ChatBody) {
-					textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
+						cb.Messages[selectedIndex].Role = newRole
+					})
+					textView.SetText(chatToText(chatBody.GetMessages(), cfg.ShowSys))
 					colorText()
 					pages.RemovePage(roleEditPage)
 				}
@@ -497,7 +501,7 @@ func initTUI() {
 				return nil
 			}
 			selectedIndex = siInt
-			if len(chatBody.Messages)-1 < selectedIndex || selectedIndex < 0 {
+			if chatBody.GetMessageCount()-1 < selectedIndex || selectedIndex < 0 {
 				msg := "chosen index is out of bounds, will copy user input"
 				logger.Warn(msg, "index", selectedIndex)
 				showToast("error", msg)
@@ -507,7 +511,7 @@ func initTUI() {
 				hideIndexBar() // Hide overlay instead of removing page directly
 				return nil
 			}
-			m := chatBody.Messages[selectedIndex]
+			m := chatBody.GetMessages()[selectedIndex]
 			switch {
 			case roleEditMode:
 				hideIndexBar() // Hide overlay first
@@ -574,7 +578,7 @@ func initTUI() {
 					searchResults = nil
 					searchResultLengths = nil
 					originalTextForSearch = ""
-					textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
+					textView.SetText(chatToText(chatBody.GetMessages(), cfg.ShowSys))
 					colorText()
 					return
 				} else {
@@ -632,7 +636,7 @@ func initTUI() {
 	//
 	textArea.SetMovedFunc(updateStatusLine)
 	updateStatusLine()
-	textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
+	textView.SetText(chatToText(chatBody.GetMessages(), cfg.ShowSys))
 	colorText()
 	if scrollToEndEnabled {
 		textView.ScrollToEnd()
@@ -646,7 +650,7 @@ func initTUI() {
 		if event.Key() == tcell.KeyRune && event.Rune() == '5' && event.Modifiers()&tcell.ModAlt != 0 {
 			// switch cfg.ShowSys
 			cfg.ShowSys = !cfg.ShowSys
-			textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
+			textView.SetText(chatToText(chatBody.GetMessages(), cfg.ShowSys))
 			colorText()
 		}
 		if event.Key() == tcell.KeyRune && event.Rune() == '3' && event.Modifiers()&tcell.ModAlt != 0 {
@@ -679,7 +683,7 @@ func initTUI() {
 		// Handle Alt+T to toggle thinking block visibility
 		if event.Key() == tcell.KeyRune && event.Rune() == 't' && event.Modifiers()&tcell.ModAlt != 0 {
 			thinkingCollapsed = !thinkingCollapsed
-			textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
+			textView.SetText(chatToText(chatBody.GetMessages(), cfg.ShowSys))
 			colorText()
 			status := "expanded"
 			if thinkingCollapsed {
@@ -691,7 +695,7 @@ func initTUI() {
 		// Handle Ctrl+T to toggle tool call/response visibility
 		if event.Key() == tcell.KeyCtrlT {
 			toolCollapsed = !toolCollapsed
-			textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
+			textView.SetText(chatToText(chatBody.GetMessages(), cfg.ShowSys))
 			colorText()
 			status := "expanded"
 			if toolCollapsed {
@@ -734,14 +738,14 @@ func initTUI() {
 		}
 		if event.Key() == tcell.KeyF2 && !botRespMode {
 			// regen last msg
-			if len(chatBody.Messages) == 0 {
+			if chatBody.GetMessageCount() == 0 {
 				showToast("info", "no messages to regenerate")
 				return nil
 			}
-			chatBody.Messages = chatBody.Messages[:len(chatBody.Messages)-1]
+			chatBody.TruncateMessages(chatBody.GetMessageCount() - 1)
 			// there is no case where user msg is regenerated
-			// lastRole := chatBody.Messages[len(chatBody.Messages)-1].Role
+			// lastRole := chatBody.GetMessages()[chatBody.GetMessageCount()-1].Role
-			textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
+			textView.SetText(chatToText(chatBody.GetMessages(), cfg.ShowSys))
 			// go chatRound("", cfg.UserRole, textView, true, false)
 			if cfg.TTS_ENABLED {
 				TTSDoneChan <- true
@@ -760,12 +764,12 @@ func initTUI() {
 				colorText()
 				return nil
 			}
-			if len(chatBody.Messages) == 0 {
+			if chatBody.GetMessageCount() == 0 {
 				showToast("info", "no messages to delete")
 				return nil
 			}
-			chatBody.Messages = chatBody.Messages[:len(chatBody.Messages)-1]
+			chatBody.TruncateMessages(chatBody.GetMessageCount() - 1)
-			textView.SetText(chatToText(chatBody.Messages, cfg.ShowSys))
+			textView.SetText(chatToText(chatBody.GetMessages(), cfg.ShowSys))
 			if cfg.TTS_ENABLED {
 				TTSDoneChan <- true
 			}
@@ -813,7 +817,7 @@ func initTUI() {
 		if event.Key() == tcell.KeyF7 {
 			// copy msg to clipboard
 			editMode = false
-			m := chatBody.Messages[len(chatBody.Messages)-1]
+			m := chatBody.GetMessages()[chatBody.GetMessageCount()-1]
 			msgText := m.GetText()
 			if err := copyToClipboard(msgText); err != nil {
 				logger.Error("failed to copy to clipboard", "error", err)
@@ -997,10 +1001,10 @@ func initTUI() {
 			TTSDoneChan <- true
 		}
 		if event.Key() == tcell.KeyRune && event.Rune() == '0' && event.Modifiers()&tcell.ModAlt != 0 && cfg.TTS_ENABLED {
-			if len(chatBody.Messages) > 0 {
+			if chatBody.GetMessageCount() > 0 {
 				// Stop any currently playing TTS first
 				TTSDoneChan <- true
-				lastMsg := chatBody.Messages[len(chatBody.Messages)-1]
+				lastMsg := chatBody.GetMessages()[chatBody.GetMessageCount()-1]
 				cleanedText := models.CleanText(lastMsg.GetText())
 				if cleanedText != "" {
 					// nolint: errcheck
@@ -1012,7 +1016,7 @@ func initTUI() {
 		if event.Key() == tcell.KeyCtrlW {
 			// INFO: continue bot/text message
 			// without new role
-			lastRole := chatBody.Messages[len(chatBody.Messages)-1].Role
+			lastRole := chatBody.GetMessages()[chatBody.GetMessageCount()-1].Role
 			// go chatRound("", lastRole, textView, false, true)
 			chatRoundChan <- &models.ChatRoundReq{Role: lastRole, Resume: true}
 			return nil
@@ -1098,7 +1102,7 @@ func initTUI() {
 		if event.Key() == tcell.KeyRune && event.Modifiers() == tcell.ModAlt && event.Rune() == '9' {
 			// Warm up (load) the currently selected model
 			go warmUpModel()
-			showToast("model warmup", "loading model: "+chatBody.Model)
+			showToast("model warmup", "loading model: "+chatBody.GetModel())
 			return nil
 		}
 		// cannot send msg in editMode or botRespMode
@@ -1137,7 +1141,7 @@ func initTUI() {
 				}
 				// add user icon before user msg
 				fmt.Fprintf(textView, "%s[-:-:b](%d) <%s>: [-:-:-]\n%s\n",
-					nl, len(chatBody.Messages), persona, msgText)
+					nl, chatBody.GetMessageCount(), persona, msgText)
 				textArea.SetText("", true)
 				if scrollToEndEnabled {
 					textView.ScrollToEnd()
@@ -1173,5 +1177,4 @@ func initTUI() {
 		}
 		return event
 	})
-	go updateModelLists()
 }