Files
archie/internal/channels/telegram/live.go
T
sam 8485f24332 fix(messaging): render a tool call as one line with its own icon
A tool call rendered as a label line plus a ```text fence. Telegram draws a
fenced block as a full code widget (language header bar, copy button, panel),
and the block parser inserts a spacer paragraph before every block, so one
call cost four rendered elements. Three calls filled the screen to show three
word counts.

Every toolPreview path already summarises to a single line, so the fence was
never wrapping more than one. Drop it and put the preview on the header line.
Tool lines now join with a hard break rather than a bare newline: a soft
break would space-join them into one run-on paragraph, and a blank line would
put the spacer back. Three calls are now three consecutive blocks.

Two hardcoded values go with it. The status word is printed only when the
outcome is not success, since every line otherwise read "done" and
distinguished nothing. The icon is no longer a literal in the renderer: each
builtin declares its own on tools.Tool (not on Schema, which is the model's
contract), the provider carries it into ToolEntry, and the turn snapshots the
registry's icons alongside its tool set. A tool that declares none renders
without one rather than borrowing a generic wrench.

Carries a dependency upgrade (go.mod, go.sum, tools/go.mod, tools/go.sum).
2026-09-22 21:36:02 +10:00

848 lines
31 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package telegram
import (
"context"
"errors"
"fmt"
"slices"
"strings"
"sync"
"time"
"unicode/utf8"
"github.com/go-telegram/bot"
"github.com/go-telegram/bot/models"
"github.com/samcharles93/archie-core/internal/domain/messaging"
)
const (
// liveInterval is the minimum gap between live updates. Telegram rate
// limits per-chat writes, and an LLM emits tokens far faster than any
// human reads, so deltas are coalesced into one edit per tick rather
// than sent individually.
liveInterval = 1 * time.Second
// liveCursor marks the reply as still being written. It is appended at
// render time and never stored in the buffer, so every frame carries
// exactly one cursor and it is always at the current end.
liveCursor = "▌"
// fallbackMediaLinePrefix opens the line Media appends when it could
// not deliver an attachment inline, so the user still gets the asset.
fallbackMediaLinePrefix = "📎 "
// liveBodyMaxRunes bounds one mid-turn frame. Telegram rejects a
// message over its character limit outright, so an unbounded frame
// means every edit past that point fails and the live message freezes
// at the last frame that fit -- for the rest of the turn, since the
// buffer only grows. The bound is in runes rather than bytes because
// the limit Telegram applies is a character count, not a byte count.
//
// Only the live frame is bounded. finalize sends the whole reply,
// split across as many messages as it needs.
liveBodyMaxRunes = 3900
// Keep tool activity to a minority of a live frame so the answer remains
// readable even when a turn makes many calls. The remainder is reserved
// for the answer (and the cursor).
liveToolMaxRunes = (liveBodyMaxRunes - 2) / 3
)
// liveReply renders one chat turn into a single Telegram message as it is
// generated, so the user watches the answer being written instead of waiting
// on a silent "typing…" indicator.
//
// It keeps one canonical buffer and sends the whole of it on every update:
// the first update creates the message, every later one edits that same
// message. Editing has replace semantics, which is what makes a partial frame
// impossible to append to the last one. (It previously streamed through
// sendMessageDraft, whose drafts are ephemeral 30-second previews -- a tool
// call longer than that outlived the preview, and successive frames were
// observed concatenated, cursors and all.)
//
// Rendering is deliberately best-effort: it never blocks the generating
// goroutine and never surfaces an error. The authoritative reply is the one
// finalize writes when the turn completes -- if every live update failed,
// the user simply sees the finished message appear the way it did before
// streaming existed.
//
// A known, accepted trade-off of editing rather than sending: Telegram does
// not change a message's date on edit, so the finished reply carries the
// timestamp of the first streamed frame, not of finalize. A turn with a long
// tool phase can therefore produce an answer timestamped before a user
// message sent later, during that phase, and sort before the conversation
// that produced it. Delete-and-resend on finalize would fix the ordering but
// reintroduce the flicker/reorder streaming was built to avoid, so this is
// left as-is rather than "fixed."
type liveReply struct {
g *Gateway
b *bot.Bot
chatID int64
messageThreadID int
showToolCalls bool
// interval throttles updates; zero renders every change.
interval time.Duration
// mediaWg lets tests (and a future bounded drain, mirroring
// abandonAllLive) wait for in-flight Media deliveries. Callers other
// than tests must not block on it: Media is fire-and-forget by
// contract, same as Delta and ToolCall.
mediaWg sync.WaitGroup
// newMediaSender builds the MediaSender Media delivers through.
// Defaults to g.NewMediaSender; tests override it to inject a sender
// with fixed Capabilities(), which the real Telegram one can't
// express (it always reports Media: true) but a future channel or a
// capability-limited deployment might.
newMediaSender func(b *bot.Bot, chatID int64, threadID int) messaging.MediaSender
cancelRender context.CancelFunc
renderRequests chan chan struct{}
renderDone chan struct{}
mu sync.Mutex
// answerBuf is the assistant text streamed so far, in the order the
// model produced it. Tool activity is not appended here: it is tracked
// separately in toolLines so it can be kept whole and in front of the
// answer at every rendering stage (mid-turn frame, abandon, finalize)
// instead of scrolling out of the frame once the answer grows past the
// live clamp.
answerBuf strings.Builder
// toolLines holds the tool activity for this turn, in call order, so
// every rendering stage can lead with it rather than have it buried
// mid-answer or clamped away.
toolLines []string
// failureLines and failureCounts let ToolCall replace a repeated failure
// in place with one counted entry instead of appending noisy retries.
failureLines map[string]int
failureCounts map[string]int
// rendered is the last body actually sent. Telegram rejects an edit
// that changes nothing, so an unchanged body is not sent at all.
rendered string
messageID int
last time.Time
// finalized is set once stopRendering returns, the single point every
// finalize/abandon path funnels through to retire the renderer
// goroutine. After that point requestRender is a silent no-op (a
// non-blocking send into a channel nothing reads any more), so any
// caller still trying to append to the live message after this point
// -- Media's fire-and-forget delivery has its own 30s budget, far
// longer than the turn's text usually takes -- must send its own
// follow-up message instead of writing into a buffer nothing renders.
finalized bool
// terminal guards finalize and abandon so exactly one of them actually
// runs its body. Without this, a turn finishing naturally (finalize)
// and a concurrent Gateway.Stop (abandon, via abandonRestarted) can
// both reach their own Telegram edit for the same message: both edits
// go through, and whichever HTTP response Telegram processes last
// decides what the user sees, nondeterministically -- including a
// completed real answer getting silently overwritten by a restart
// marker. The loser's call blocks until the winner's body returns
// (sync.Once's own guarantee), then does nothing, so cleanup that must
// happen exactly once (stopRendering, forgetLive) is never skipped or
// duplicated regardless of which side wins.
terminal sync.Once
}
// newLiveReply creates a renderer bound to one chat/thread. showToolCalls is
// copied into the reply so a config reload cannot change a turn mid-stream.
func (g *Gateway) newLiveReply(ctx context.Context, b *bot.Bot, chatID int64, messageThreadID int, showToolCalls bool) *liveReply {
renderCtx, cancelRender := context.WithCancel(ctx)
live := &liveReply{
g: g,
b: b,
chatID: chatID,
messageThreadID: messageThreadID,
showToolCalls: showToolCalls,
interval: liveInterval,
newMediaSender: g.NewMediaSender,
cancelRender: cancelRender,
renderRequests: make(chan chan struct{}, 1),
renderDone: make(chan struct{}),
failureLines: make(map[string]int),
failureCounts: make(map[string]int),
}
go live.runRenderer(renderCtx)
g.registerLive(ctx, live)
return live
}
// resetLiveRegistry clears the previous launch's stopped mark. Called once
// per launch, alongside rebuilding turns: a /restart's Stop marks the
// registry stopped so nothing straggling from the outgoing bot instance
// gets silently registered into it, but the incoming instance needs a live
// registry of its own.
func (g *Gateway) resetLiveRegistry() {
g.liveMu.Lock()
g.liveStopped = false
g.liveMu.Unlock()
}
// registerLive adds l to the set Stop drains on shutdown or restart. If a
// drain already claimed the registry for this launch, l is abandoned
// immediately instead of being registered: it arrived in the narrow window
// between that claim and this call, and without this it would sit in no
// registry, with nothing left to ever drain it.
func (g *Gateway) registerLive(ctx context.Context, l *liveReply) {
g.liveMu.Lock()
if g.liveStopped {
g.liveMu.Unlock()
go l.abandonRestarted(context.WithoutCancel(ctx))
return
}
if g.liveReplies == nil {
g.liveReplies = make(map[*liveReply]struct{})
}
g.liveReplies[l] = struct{}{}
g.liveMu.Unlock()
}
// forgetLive removes l from the registry. Called at the top of doFinalize
// and doAbandon -- reached through l.terminal, so by the time this runs the
// caller has already exclusively won the right to decide this reply's
// outcome (see the terminal field doc) -- so a reply that completed on its
// own is never picked up a second time by a later Stop, and a reply Stop
// has already claimed is never double-processed.
func (g *Gateway) forgetLive(l *liveReply) {
g.liveMu.Lock()
defer g.liveMu.Unlock()
delete(g.liveReplies, l)
}
// abandonAllLiveTimeout bounds how long Stop waits for in-flight replies to
// be marked before giving up and returning anyway. A single stalled
// Telegram API call must not hang gateway (and therefore daemon) shutdown
// indefinitely; entries still in flight past this deadline keep running in
// the background and finish (or die with the process) on their own.
const abandonAllLiveTimeout = 5 * time.Second
// abandonAllLive drops the cursor, marked as interrupted, on every turn
// still streaming when the gateway stops or restarts. It exists because
// nothing else guarantees this happens: cancelling turnCtx does not
// guarantee the goroutine that owns a liveReply ever runs again to notice
// and clean up after itself, and a full daemon process exit gives it no
// chance to run at all, so this must not wait on that goroutine and must not
// skip a reply just because its owning turn is still technically running.
//
// Marking liveStopped and draining the registry happen together, under the
// same lock, so registerLive can never observe "stopped" without also
// observing an empty-of-this-entry registry, or vice versa.
func (g *Gateway) abandonAllLive(ctx context.Context) {
g.liveMu.Lock()
g.liveStopped = true
live := make([]*liveReply, 0, len(g.liveReplies))
for l := range g.liveReplies {
live = append(live, l)
}
clear(g.liveReplies)
g.liveMu.Unlock()
if len(live) == 0 {
return
}
timeout := g.liveDrainTimeout
if timeout <= 0 {
timeout = abandonAllLiveTimeout
}
done := make(chan struct{})
go func() {
defer close(done)
var wg sync.WaitGroup
for _, l := range live {
wg.Go(func() { l.abandonRestarted(ctx) })
}
wg.Wait()
}()
select {
case <-done:
case <-time.After(timeout):
g.log.Warn("gateway stop: gave up waiting for in-flight replies to be marked as restarted",
"pending", len(live), "timeout", timeout)
}
}
func (l *liveReply) runRenderer(ctx context.Context) {
defer close(l.renderDone)
for {
select {
case <-ctx.Done():
return
case completed := <-l.renderRequests:
l.render(ctx)
if completed != nil {
close(completed)
}
}
}
}
func (l *liveReply) requestRender() {
select {
case l.renderRequests <- nil:
default:
}
}
func (l *liveReply) flushRendering() {
completed := make(chan struct{})
select {
case l.renderRequests <- completed:
case <-l.renderDone:
return
}
select {
case <-completed:
case <-l.renderDone:
}
}
func (l *liveReply) stopRendering() {
l.cancelRender()
<-l.renderDone
l.mu.Lock()
l.finalized = true
l.mu.Unlock()
}
// Delta appends the next fragment of assistant text. It satisfies
// gateway.TurnStream.
func (l *liveReply) Delta(text string) {
if text == "" {
return
}
l.mu.Lock()
l.answerBuf.WriteString(text)
throttled := time.Since(l.last) < l.interval
l.mu.Unlock()
if throttled {
return
}
l.requestRender()
}
// ToolCall appends one tool-activity line. It satisfies gateway.TurnStream.
//
// Tool activity is opt-in per deployment: without it the user cannot tell a
// hallucinated action from a real one, but it also narrates every internal
// step, which is noise in a conversation that is going fine.
//
// The name, parameters and summary all come from tool execution, not the
// model's prose, and can carry raw Markdown metacharacters (a grep hit with
// '*', a JSON parameter with '_' or backticks). They are escaped before
// joining the line because the tool line and the model's reply share one
// Markdown body (finalText): an unbalanced marker in the tool line breaks
// parsing for the whole message, including the reply's own formatting.
func (l *liveReply) ToolCall(event messaging.ToolCallEvent) {
if !l.showToolCalls || event.Name == "" {
return
}
// Render the completed result as a compact fenced block. Do not append the
// raw/JSON-shaped parameters: they are noisy, can expose secrets, and were
// the source of unreadable schema placeholders in Telegram.
line := messaging.RenderToolCall(event)
key := messaging.FailureKey(event)
l.mu.Lock()
if index, ok := l.failureLines[key]; key != "" && ok {
l.failureCounts[key]++
l.toolLines[index] = countedToolLine(line, l.failureCounts[key])
} else {
l.toolLines = append(l.toolLines, line)
if key != "" {
l.failureLines[key] = len(l.toolLines) - 1
l.failureCounts[key] = 1
}
}
l.mu.Unlock()
// A tool call is a discrete event rather than a token, and there are
// few of them: wake the renderer immediately so the user sees what ran
// while it is still relevant. The callback itself never waits on HTTP.
l.requestRender()
}
// countedToolLine marks a collapsed entry with how many calls it stands for.
// The count belongs to the status, not to the preview, so it is inserted
// before the preview separator rather than appended: "grep — done ×14 · 2
// matches" counts calls, while "· 2 matches ×14" reads as counting matches.
// toolLineSeparator joins tool lines. It ends each one with CommonMark's
// hard-break marker rather than a blank line: a bare "\n" is a soft break,
// which the block parser space-joins into one run-on paragraph, while a blank
// line would insert a spacer block between every pair. A hard break gives
// each line its own block AND suppresses the spacer, so a turn's activity
// reads as consecutive lines instead of a double-spaced list.
const toolLineSeparator = " \n"
func countedToolLine(line string, count int) string {
if count <= 1 {
return line
}
marker := fmt.Sprintf(" ×%d", count)
if cut := strings.Index(line, messaging.ToolPreviewSeparator); cut >= 0 {
return line[:cut] + marker + line[cut:]
}
return line + marker
}
// mediaSendTimeout bounds one Media delivery. It is independent of the
// render loop's own lifecycle (unlike answerBuf/toolLines, which a
// /restart abandons via abandonAllLive): an upload in flight when the live
// reply finalizes should still be allowed to land, since the asset is worth
// delivering on its own even after the surrounding turn is done narrating.
const mediaSendTimeout = 30 * time.Second
// Media delivers the attachment through the media-specific Bot API, off the
// generating goroutine: unlike Delta/ToolCall, this is a real network
// upload, and TurnStream implementations must not block generation on one.
// It satisfies gateway.TurnStream.
//
// An attachment carrying neither a URL to fetch nor a local Path to
// upload is silently skipped: SendMedia would reject it as
// invalid_message, there is nothing to fall back to, and Media has no
// error return to report it through.
//
// This used to skip on a missing URL alone, which dropped every local
// file before it reached the sender -- the guard, not just the sender,
// was part of making a local path undeliverable.
func (l *liveReply) Media(ctx context.Context, event messaging.MediaEvent) {
if event.Attachment.URL == "" && event.Attachment.Path == "" {
return
}
l.mediaWg.Go(func() {
sender := l.newMediaSender(l.b, l.chatID, l.messageThreadID)
// Checked before attempting delivery, not just on failure: that is
// the entire point of CapabilityReporter over attempt-then-catch
// -- a sender that already knows it cannot deliver a given media
// kind should never cost a doomed network round trip to find out.
if !messaging.CapabilitiesOf(sender).Media {
l.g.log.Debug("channel cannot deliver media inline, falling back to a link",
"tool", event.ToolName, "type", event.Attachment.Type)
l.appendFallbackLine(ctx, event.Attachment)
return
}
sendCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), mediaSendTimeout)
defer cancel()
_, err := sender.SendMedia(sendCtx, messaging.MessageEvent{
Media: []messaging.MediaAttachment{event.Attachment},
})
if err == nil {
return
}
l.g.log.Warn("media delivery failed, falling back to a link",
"tool", event.ToolName, "type", event.Attachment.Type, "error", err)
l.appendFallbackLine(ctx, event.Attachment)
})
}
// appendFallbackLine renders att as a visible link in the reply, for a
// MediaEvent that could not be (or was not attempted to be) delivered
// inline.
func (l *liveReply) appendFallbackLine(ctx context.Context, att messaging.MediaAttachment) {
// A local attachment has no URL to fall back to, and printing an empty
// one reads as a delivered file. Say plainly that it was not sent:
// the whole defect this path exists around is that non-delivery and
// success looked the same to everyone downstream, the agent included.
line := fallbackMediaLinePrefix + bot.EscapeMarkdown(att.Type) + ": " + att.URL
if att.URL == "" {
name := att.FileName
if name == "" {
name = att.Path
}
line = fallbackMediaLinePrefix + "could not send " + bot.EscapeMarkdown(name)
}
l.mu.Lock()
if l.finalized {
// The renderer that would have picked up toolLines is already
// gone -- requestRender below would be a silent no-op, and the
// live message it would have edited is done being edited. Send
// this as its own message instead of dropping it.
l.mu.Unlock()
sendCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), mediaSendTimeout)
defer cancel()
l.g.sendMessage(sendCtx, l.b, l.chatID, l.messageThreadID, line)
return
}
l.toolLines = append(l.toolLines, line)
l.mu.Unlock()
l.requestRender()
}
// waitMedia blocks until every Media delivery started so far has finished.
// Tests only: production callers never wait on Media's fire-and-forget
// goroutines.
func (l *liveReply) waitMedia() {
l.mediaWg.Wait()
}
// render writes the current buffer, cursor and all, to the live message.
func (l *liveReply) render(ctx context.Context) {
l.mu.Lock()
body := l.body()
if body == "" || body == l.rendered {
l.mu.Unlock()
return
}
messageID := l.messageID
l.mu.Unlock()
// Mid-stream text is frequently unbalanced Markdown (an unclosed ** or
// code fence); a rejected update is logged and skipped, and the next
// tick -- or finalize -- corrects it.
if messageID == 0 {
l.open(ctx, markdownToBlocks(body))
return
}
if err := l.edit(ctx, messageID, markdownToBlocks(body)); err == nil {
l.markRendered(body)
}
}
func (l *liveReply) markRendered(body string) {
l.mu.Lock()
l.rendered = body
l.last = time.Now()
l.mu.Unlock()
}
// finalize replaces the live message with the turn's authoritative reply,
// led by the tool activity that produced it, and drops the cursor. When
// nothing was ever streamed -- a non-streaming provider, or a reply served
// from the turn ledger -- it sends the reply as a new message instead.
//
// ctx is stripped of cancellation before anything is sent: the reply is
// already decided and persisted by the time finalize runs, so a /stop
// landing mid-finalize must not abort delivery the way it aborts the turn
// itself -- that would strand the live message on a frame with the cursor
// still attached, forever. Doing this inside finalize rather than trusting
// each caller to pass a live context is what keeps this fix from silently
// regressing the next time a caller is added.
//
// The actual work runs inside l.terminal so a concurrent abandon (a gateway
// shutdown abandoning every in-flight reply while this turn is finishing
// naturally, see Gateway.abandonAllLive) cannot send its own conflicting
// edit for the same message -- see the terminal field doc.
func (l *liveReply) finalize(ctx context.Context, reply string) {
ctx = context.WithoutCancel(ctx)
l.terminal.Do(func() { l.doFinalize(ctx, reply) })
}
func (l *liveReply) doFinalize(ctx context.Context, reply string) {
l.g.forgetLive(l)
// Finish any queued live frame before replacing it, then retire the
// worker so no stale edit can race the authoritative delivery.
l.flushRendering()
l.stopRendering()
l.mu.Lock()
content := l.finalText(reply)
messageID := l.messageID
l.mu.Unlock()
if content == "" {
l.abandonStopped(ctx)
return
}
if messageID == 0 {
l.g.sendMessage(ctx, l.b, l.chatID, l.messageThreadID, content)
return
}
// The live message is one message, so an oversized reply keeps it as
// the first part and sends the remainder after it. If the edit cannot
// be delivered in either rich or plain form, send the complete reply
// through the normal split path rather than losing the authoritative
// answer behind a stale live frame.
parts := splitBlocks(markdownToBlocks(content), messageMaxLen)
if len(parts) == 0 {
l.abandonStopped(ctx)
return
}
if err := l.edit(ctx, messageID, parts[0]); err != nil {
l.g.sendMessage(ctx, l.b, l.chatID, l.messageThreadID, content)
return
}
l.markRendered(strings.Join(blocksToPlainText(parts[0]), "\n\n"))
for _, part := range parts[1:] {
l.g.sendBlocks(ctx, l.b, l.chatID, l.messageThreadID, part, "send message part failed")
}
}
// abandonMarker is appended to a failed turn's partial text so it cannot be
// mistaken for a finished answer: without it, a truncated reply and a
// completed one are visually identical, and Telegram messages are
// immutable, so nothing can correct that impression after the fact.
const abandonMarker = "\n\n❌ _turn failed before finishing_"
// abandon leaves a stopped turn readable: the partial text stays, but the
// cursor goes, so the message does not claim to still be writing. A /stop is
// a deliberate, acknowledged interruption, not a fault, so the partial is
// left clean rather than marked as a failure.
//
// Like finalize, it strips ctx of cancellation before sending: abandon runs
// precisely when a /stop has cancelled turnCtx, so honouring that
// cancellation in the very edit meant to drop the cursor would leave the
// cursor blinking on a message nothing will ever finish. And like finalize,
// the actual work runs inside l.terminal -- see the terminal field doc and
// finalize's.
func (l *liveReply) abandon(ctx context.Context) {
ctx = context.WithoutCancel(ctx)
l.terminal.Do(func() { l.doAbandon(ctx) })
}
func (l *liveReply) doAbandon(ctx context.Context) {
l.g.forgetLive(l)
l.stopRendering()
l.abandonStopped(ctx)
}
// abandonFailed leaves a failed turn readable and visibly marked as failed,
// unlike abandon: a provider error is not an acknowledged interruption, so
// the partial text alone would read as the finished answer and the user
// could act on incomplete information.
func (l *liveReply) abandonFailed(ctx context.Context) {
l.mu.Lock()
l.answerBuf.WriteString(abandonMarker)
l.mu.Unlock()
l.abandon(ctx)
}
// restartMarker distinguishes a gateway-restart abandon from both a clean
// /stop (abandon) and a provider failure (abandonFailed): the turn was cut
// off by an operational event rather than a fault in it or a deliberate
// stop, and unlike either of those the user's message is still worth
// resending once the gateway is back.
const restartMarker = "\n\n⚠️ _archie restarted before finishing -- send your message again_"
// abandonRestarted leaves a turn interrupted by gateway shutdown or restart
// readable and marked, for the same reason abandonFailed marks a provider
// error: nothing will ever resume this turn, and an unmarked partial reads
// as a finished answer either way. Called by Gateway.abandonAllLive, never
// by the turn's own goroutine.
func (l *liveReply) abandonRestarted(ctx context.Context) {
l.mu.Lock()
l.answerBuf.WriteString(restartMarker)
l.mu.Unlock()
l.abandon(ctx)
}
func (l *liveReply) abandonStopped(ctx context.Context) {
l.mu.Lock()
answer := strings.TrimRight(l.answerBuf.String(), " \t\n")
// Bounded for the same reason a live frame is: this is still one edit
// of one message, and a stopped turn that had already streamed past
// the limit would keep its cursor if the edit were rejected.
text := l.framedText(answer)
messageID := l.messageID
if text == "" || text == l.rendered {
l.mu.Unlock()
return
}
l.mu.Unlock()
if messageID == 0 {
l.g.sendMessage(ctx, l.b, l.chatID, l.messageThreadID, text)
return
}
if err := l.edit(ctx, messageID, markdownToBlocks(text)); err == nil {
l.markRendered(text)
}
}
// body renders a mid-turn frame: tool activity so far, then the answer text
// streamed so far, then the cursor. The caller holds the lock.
func (l *liveReply) body() string {
answer := strings.TrimRight(l.answerBuf.String(), " \t\n")
if answer == "" && len(l.toolLines) == 0 {
return ""
}
return l.framedText(answer) + " " + liveCursor
}
// framedText composes tool activity ahead of the answer text and clamps the
// whole thing to fit one Telegram message. The caller holds the lock.
func (l *liveReply) framedText(answer string) string {
if len(l.toolLines) == 0 {
return l.clampAnswer(answer, liveBodyMaxRunes-2)
}
block := l.toolBlock()
if answer == "" {
return block
}
// Reserve the larger share of the frame for the answer. The two extra
// runes are the separator and the cursor appended by body.
budget := liveBodyMaxRunes - 2 - utf8.RuneCountInString(block) - 2
if budget <= 0 {
return block
}
return block + "\n\n" + l.clampAnswer(answer, budget)
}
// clampAnswer cuts the answer to its budget, retaining the newest text and
// marking the cut with a leading ellipsis.
//
// The marker matters on every frame, including the opening one. A turn that
// streams a large first chunk, or that never opens a reply at all (so
// messageID stays 0), would otherwise render text that appears to begin
// mid-sentence with nothing to say a cut was made -- and Telegram messages are
// immutable, so it can never be corrected afterwards.
func (l *liveReply) clampAnswer(answer string, budget int) string {
return clampToRunes(answer, budget)
}
// toolBlock returns the most recent activity that fits its deliberately
// smaller frame budget, prefixed with a count of what was left out.
//
// The search runs from the newest line backwards, widening the window while
// the result still fits, so EVERY line that fits is kept: returning as soon as
// the newest line alone fits would discard history that was never over budget
// and report a "+N earlier" that is simply untrue.
//
// The caller holds the lock.
func (l *liveReply) toolBlock() string {
if len(l.toolLines) == 0 {
return ""
}
best := -1
for start := range slices.Backward(l.toolLines) {
if utf8.RuneCountInString(l.toolBlockWith(start)) > liveToolMaxRunes {
break
}
best = start
}
if best >= 0 {
return l.toolBlockWith(best)
}
// Even the newest line alone overflows, so it is the only line retained
// and every older line must be reflected in the indicator.
omitted := len(l.toolLines) - 1
prefix := ""
if omitted > 0 {
prefix = fmt.Sprintf("+%d earlier\n\n", omitted)
}
available := liveToolMaxRunes - utf8.RuneCountInString(prefix)
if available <= 0 {
return clampToRunes(prefix, liveToolMaxRunes)
}
return prefix + clampToRunes(l.toolLines[len(l.toolLines)-1], available)
}
// toolBlockWith renders the activity from index start to the newest line,
// including the "+N earlier" indicator for whatever precedes start.
func (l *liveReply) toolBlockWith(start int) string {
prefix := ""
if omitted := start; omitted > 0 {
prefix = fmt.Sprintf("+%d earlier\n\n", omitted)
}
return prefix + strings.Join(l.toolLines[start:], toolLineSeparator)
}
// clampToRunes cuts s to its last maxRunes runes, marking the cut with a
// leading ellipsis.
func clampToRunes(s string, maxRunes int) string {
runes := []rune(s)
if len(runes) <= maxRunes {
return s
}
if maxRunes <= 1 {
return "…"
}
return "…" + string(runes[len(runes)-(maxRunes-1):])
}
// finalText composes the finished message: the tool activity in the order it
// happened, then the authoritative reply. The caller holds the lock.
//
// The reply is used rather than the streamed buffer because it is what the
// turn actually returned and what was persisted to the conversation -- a
// dropped or throttled frame cannot leave the visible message disagreeing
// with the stored one.
//
// A turn that ran tools but produced no reply text still needs to say so:
// the tool block alone reads as a completed answer that said nothing, and
// Telegram messages are immutable, so nothing can correct it after the
// fact. An empty reply with no tool activity either is left to the
// content == "" path in finalize, which abandons instead of sending.
func (l *liveReply) finalText(reply string) string {
reply = strings.TrimSpace(reply)
if len(l.toolLines) == 0 {
return reply
}
block := strings.Join(l.toolLines, toolLineSeparator)
if reply == "" {
return block + "\n\n_(no response)_"
}
return block + "\n\n" + reply
}
// open creates the live message and records its ID for later edits.
func (l *liveReply) open(ctx context.Context, blocks []models.InputRichBlock) {
params := &bot.SendRichMessageParams{
ChatID: l.chatID,
RichMessage: models.InputRichMessage{Blocks: blocks},
}
if l.messageThreadID != 0 {
params.MessageThreadID = l.messageThreadID
}
msg, err := l.b.SendRichMessage(ctx, params)
if err != nil {
l.g.log.Debug("live reply rich send failed, retrying unformatted", "error", err)
plain := &bot.SendMessageParams{ChatID: l.chatID, Text: strings.Join(blocksToPlainText(blocks), "\n\n")}
if l.messageThreadID != 0 {
plain.MessageThreadID = l.messageThreadID
}
msg, err = l.b.SendMessage(ctx, plain)
if err != nil {
l.g.log.Debug("live reply send failed", "error", err)
return
}
}
l.mu.Lock()
l.messageID = msg.ID
l.rendered = strings.Join(blocksToPlainText(blocks), "\n\n")
l.last = time.Now()
l.mu.Unlock()
}
// edit replaces the live message's content.
//
// Rich messages are a recent Bot API addition, and text is only optional on
// an edit that carries one, so a server that rejects the rich body rejects
// the whole edit. As with send, that is treated as "unsupported" rather than
// fatal: retry unformatted so the user still gets the reply.
func (l *liveReply) edit(ctx context.Context, messageID int, blocks []models.InputRichBlock) error {
_, richErr := l.b.EditMessageText(ctx, &bot.EditMessageTextParams{
ChatID: l.chatID,
MessageID: messageID,
RichMessage: &models.InputRichMessage{Blocks: blocks},
})
if richErr == nil {
return nil
}
l.g.log.Debug("live reply rich edit failed, retrying unformatted", "error", richErr)
if _, plainErr := l.b.EditMessageText(ctx, &bot.EditMessageTextParams{
ChatID: l.chatID,
MessageID: messageID,
Text: strings.Join(blocksToPlainText(blocks), "\n\n"),
}); plainErr != nil {
l.g.log.Debug("live reply edit failed", "error", plainErr)
return errors.Join(
fmt.Errorf("rich edit: %w", richErr),
fmt.Errorf("plain edit: %w", plainErr),
)
}
return nil
}