Debounce and caching

typing.go

@@ -0,0 +1,65 @@
+package main
+
+import (
+	"context"
+	"time"
+
+	"github.com/go-telegram/bot"
+	"github.com/go-telegram/bot/models"
+)
+
+// typingRefreshInterval re-arms the chat action before Telegram expires it.
+// The Bot API sets the status "for 5 seconds or less", so anything at or above
+// 5s leaves visible gaps. Telegram also clears the status as soon as the bot
+// sends a message, so streamed segments naturally interrupt it until the next
+// tick; there is no API call to clear it early.
+const typingRefreshInterval = 4 * time.Second
+
+// startChatAction shows a chat action (typing, uploading a photo, recording a
+// voice note) and keeps it alive until the returned stop function runs.
+//
+// The returned function is idempotent and MUST be deferred by the caller. A
+// keepalive loop that can outlive its turn is the failure mode behind
+// openclaw/openclaw#27177, where the indicator stuck on until the process was
+// restarted, so the loop here owns a derived context and exits on the first of:
+// stop being called, or the parent context ending.
+func (b *Bot) startChatAction(
+	ctx context.Context,
+	chatID int64,
+	businessConnectionID string,
+	action models.ChatAction,
+) (stop func()) {
+	actionCtx, cancel := context.WithCancel(ctx)
+
+	send := func() {
+		params := &bot.SendChatActionParams{
+			ChatID: chatID,
+			Action: action,
+		}
+		if businessConnectionID != "" {
+			params.BusinessConnectionID = businessConnectionID
+		}
+		if _, err := b.tgBot.SendChatAction(actionCtx, params); err != nil {
+			// Cosmetic only: a failed indicator must never abort the turn.
+			InfoLogger.Printf("[%s] chat action %q failed for chat %d: %v",
+				b.config.ID, action, chatID, err)
+		}
+	}
+
+	send()
+
+	go func() {
+		ticker := time.NewTicker(typingRefreshInterval)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-actionCtx.Done():
+				return
+			case <-ticker.C:
+				send()
+			}
+		}
+	}()
+
+	return cancel
+}