Show Telegram typing indicator for bridged turns

commit: 92b87ec05b96d07fa852076951384190cd3a16c8
author: patriceckhart · 3mo ago · 2026-07-12 10:26 UTC
parent: 3362bee
signature: unsigned
refs: tag: v0.2.75

1 file · +61 -6

M packages/agent/modes/telegram/bridge.go +61 -6


@@ -44,12 +44,13 @@ type Bridge struct {
44	44		Save func(Config) error
45	45		Host Host
46	46
47		-	mu sync.Mutex
48		-	running bool
49		-	cancel context.CancelFunc
50		-	me *User
51		-	chatID int64 // populated after first DM from the paired user
52		-	replyBuf strings.Builder
	47	+	mu sync.Mutex
	48	+	running bool
	49	+	cancel context.CancelFunc
	50	+	me *User
	51	+	chatID int64 // populated after first DM from the paired user
	52	+	replyBuf strings.Builder
	53	+	workingCancel context.CancelFunc
53	54
54	55		// nextReplyFromTelegram is set when the next assistant reply
55	56		// should be sent bare (no "zot: " prefix) because the turn was

@@ -140,9 +141,14 @@ func (b *Bridge) Start(parent context.Context) error {
140	141		func (b *Bridge) Stop() {
141	142		b.mu.Lock()
142	143		cancel := b.cancel
	144	+	workingCancel := b.workingCancel
143	145		b.running = false
144	146		b.cancel = nil
	147	+	b.workingCancel = nil
145	148		b.mu.Unlock()
	149	+	if workingCancel != nil {
	150	+	workingCancel()
	151	+	}
146	152		if cancel != nil {
147	153		cancel()
148	154		}

@@ -160,11 +166,16 @@ func (b *Bridge) OnAssistantText(text string) {
160	166		b.mu.Lock()
161	167		// prefix := "zot: "
162	168		prefix := ""
	169	+	workingCancel := b.workingCancel
	170	+	b.workingCancel = nil
163	171		if b.nextReplyFromTelegram {
164	172		prefix = ""
165	173		b.nextReplyFromTelegram = false
166	174		}
167	175		b.mu.Unlock()
	176	+	if workingCancel != nil {
	177	+	workingCancel()
	178	+	}
168	179		b.sendToPaired(text, prefix)
169	180		}
170	181

@@ -178,6 +189,47 @@ func (b *Bridge) OnUserTyped(text string) {
178	189		b.sendToPaired(text, "you: ")
179	190		}
180	191
	192	+	// indicateWorking keeps Telegram's typing indicator visible while a turn
	193	+	// submitted from Telegram is waiting or running. Telegram clears chat actions
	194	+	// after a few seconds, so refresh it until the reply is ready or the bridge
	195	+	// stops.
	196	+	func (b *Bridge) indicateWorking(ctx context.Context, chatID int64) {
	197	+	workingCtx, cancel := context.WithCancel(ctx)
	198	+
	199	+	b.mu.Lock()
	200	+	previous := b.workingCancel
	201	+	b.workingCancel = cancel
	202	+	b.mu.Unlock()
	203	+	if previous != nil {
	204	+	previous()
	205	+	}
	206	+
	207	+	go func() {
	208	+	ticker := time.NewTicker(4 * time.Second)
	209	+	defer ticker.Stop()
	210	+	for {
	211	+	_ = b.Client.SendChatAction(workingCtx, chatID, "typing")
	212	+	select {
	213	+	case <-workingCtx.Done():
	214	+	return
	215	+	case <-ticker.C:
	216	+	}
	217	+	}
	218	+	}()
	219	+	}
	220	+
	221	+	// stopWorking clears the local typing-indicator refresh loop. Telegram removes
	222	+	// the visible indicator itself when the next message arrives or it expires.
	223	+	func (b *Bridge) stopWorking() {
	224	+	b.mu.Lock()
	225	+	cancel := b.workingCancel
	226	+	b.workingCancel = nil
	227	+	b.mu.Unlock()
	228	+	if cancel != nil {
	229	+	cancel()
	230	+	}
	231	+	}
	232	+
181	233		// sendToPaired writes text (with an optional prefix, chunked to
182	234		// Telegram's 4096-char cap) to the paired chat. No-op when the
183	235		// bridge is stopped or before the paired chat id is known.

@@ -342,12 +394,14 @@ func (b *Bridge) handleUpdate(ctx context.Context, u Update) {
342	394		return
343	395		case "/stop":
344	396		b.Host.CancelTurn()
	397	+	b.stopWorking()
345	398		_ = b.Client.SendMessage(ctx, msg.Chat.ID,
346	399		"cancelled the current turn.", msg.MessageID)
347	400		return
348	401		}
349	402		if isStopCommand(text) {
350	403		b.Host.CancelTurn()
	404	+	b.stopWorking()
351	405		_ = b.Client.SendMessage(ctx, msg.Chat.ID,
352	406		"cancelled the current turn.", msg.MessageID)
353	407		return

@@ -382,6 +436,7 @@ func (b *Bridge) handleUpdate(ctx context.Context, u Update) {
382	436		b.mu.Lock()
383	437		b.nextReplyFromTelegram = true
384	438		b.mu.Unlock()
	439	+	b.indicateWorking(ctx, msg.Chat.ID)
385	440		b.Host.SubmitOrQueue(prompt, images)
386	441		}
387	442

 	Save   func(Config) error
 	Host   Host
-	mu       sync.Mutex
+	mu            sync.Mutex
-	running  bool
+	running       bool
-	cancel   context.CancelFunc
+	cancel        context.CancelFunc
-	me       *User
+	me            *User
-	chatID   int64 // populated after first DM from the paired user
+	chatID        int64 // populated after first DM from the paired user
-	replyBuf strings.Builder
+	replyBuf      strings.Builder
+	workingCancel context.CancelFunc
 	// nextReplyFromTelegram is set when the next assistant reply
 	// should be sent bare (no "zot: " prefix) because the turn was
 func (b *Bridge) Stop() {
 	b.mu.Lock()
 	cancel := b.cancel
+	workingCancel := b.workingCancel
 	b.running = false
 	b.cancel = nil
+	b.workingCancel = nil
 	b.mu.Unlock()
+	if workingCancel != nil {
+		workingCancel()
+	}
 	if cancel != nil {
 		cancel()
 	}
 	b.mu.Lock()
 	// prefix := "zot: "
 	prefix := ""
+	workingCancel := b.workingCancel
+	b.workingCancel = nil
 	if b.nextReplyFromTelegram {
 		prefix = ""
 		b.nextReplyFromTelegram = false
 	}
 	b.mu.Unlock()
+	if workingCancel != nil {
+		workingCancel()
+	}
 	b.sendToPaired(text, prefix)
 }
 	b.sendToPaired(text, "you: ")
 }
+// indicateWorking keeps Telegram's typing indicator visible while a turn
+// submitted from Telegram is waiting or running. Telegram clears chat actions
+// after a few seconds, so refresh it until the reply is ready or the bridge
+// stops.
+func (b *Bridge) indicateWorking(ctx context.Context, chatID int64) {
+	workingCtx, cancel := context.WithCancel(ctx)
+	b.mu.Lock()
+	previous := b.workingCancel
+	b.workingCancel = cancel
+	b.mu.Unlock()
+	if previous != nil {
+		previous()
+	}
+	go func() {
+		ticker := time.NewTicker(4 * time.Second)
+		defer ticker.Stop()
+		for {
+			_ = b.Client.SendChatAction(workingCtx, chatID, "typing")
+			select {
+			case <-workingCtx.Done():
+				return
+			case <-ticker.C:
+			}
+		}
+	}()
+}
+// stopWorking clears the local typing-indicator refresh loop. Telegram removes
+// the visible indicator itself when the next message arrives or it expires.
+func (b *Bridge) stopWorking() {
+	b.mu.Lock()
+	cancel := b.workingCancel
+	b.workingCancel = nil
+	b.mu.Unlock()
+	if cancel != nil {
+		cancel()
+	}
+}
 // sendToPaired writes text (with an optional prefix, chunked to
 // Telegram's 4096-char cap) to the paired chat. No-op when the
 // bridge is stopped or before the paired chat id is known.
 		return
 	case "/stop":
 		b.Host.CancelTurn()
+		b.stopWorking()
 		_ = b.Client.SendMessage(ctx, msg.Chat.ID,
 			"cancelled the current turn.", msg.MessageID)
 		return
 	}
 	if isStopCommand(text) {
 		b.Host.CancelTurn()
+		b.stopWorking()
 		_ = b.Client.SendMessage(ctx, msg.Chat.ID,
 			"cancelled the current turn.", msg.MessageID)
 		return
 	b.mu.Lock()
 	b.nextReplyFromTelegram = true
 	b.mu.Unlock()
+	b.indicateWorking(ctx, msg.Chat.ID)
 	b.Host.SubmitOrQueue(prompt, images)
 }