X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/6d96a69d33eb634f61f809001aca19ae57113180..56d959f2d573eef1be5c04d0bf1659fa30d36e7c:/telegram.go?ds=sidebyside diff --git a/telegram.go b/telegram.go index 13196d4..814f454 100644 --- a/telegram.go +++ b/telegram.go @@ -160,10 +160,15 @@ type TelegramBot struct { } // Notify queues event for the chat. It never blocks, so a slow network does not -// stop the agent. +// stop the agent. The WhatsApp batches do not go to the chat: the reply of the +// agent tells the user what needs the user. func (b *TelegramBot) Notify(event Event) { switch event.Kind { - case "busy", "idle", "reply", "error", "notice": + case "busy", "idle", "reply", "error", "notice", "subagent": + case "work": + if event.Source == whatsappSource { + return + } case "user": if event.Source == telegramSource { return @@ -185,7 +190,7 @@ func (b *TelegramBot) Notify(event Event) { // Run polls for the messages of the owner and sends the queued events to the // chat until ctx ends. It returns an error only when a message or the offset // cannot be written, because then the bot would lose or repeat messages. -func (b *TelegramBot) Run(ctx context.Context, l *TurnLoop) error { +func (b *TelegramBot) Run(ctx context.Context, l *TurnLoop, whatsapp *WhatsApp) error { ctx, cancel := context.WithCancel(ctx) defer cancel() @@ -197,7 +202,7 @@ func (b *TelegramBot) Run(ctx context.Context, l *TurnLoop) error { b.send(ctx) }() - err := b.poll(ctx, l) + err := b.poll(ctx, l, whatsapp) cancel() sender.Wait() @@ -247,7 +252,7 @@ func (b *TelegramBot) send(ctx context.Context) { // poll gets the updates from the stored offset on and handles each one, until // ctx ends. Each update is handled to its end also when ctx ends during it, so // a stop does not repeat its message. -func (b *TelegramBot) poll(ctx context.Context, l *TurnLoop) error { +func (b *TelegramBot) poll(ctx context.Context, l *TurnLoop, whatsapp *WhatsApp) error { offset, err := telegramLoadOffset(b.offsetPath) if err != nil { return err @@ -273,7 +278,7 @@ func (b *TelegramBot) poll(ctx context.Context, l *TurnLoop) error { return nil } - err = b.handle(context.WithoutCancel(ctx), l, update) + err = b.handle(context.WithoutCancel(ctx), l, whatsapp, update) if err != nil { return err } @@ -311,8 +316,9 @@ func (b *TelegramBot) typing(ctx context.Context) { } // post sends event to the chat. A reply goes as rich messages of its Markdown, -// split with telegramSplitRich. Every other event goes as plain text, split -// with telegramSplitMessage. +// with each < and & outside code escaped by telegramEscapeTags and then split +// with telegramSplitRich, so that the length limit counts the escaped text. +// Every other event goes as plain text, split with telegramSplitMessage. func (b *TelegramBot) post(ctx context.Context, event Event) { if event.Kind != "reply" { for _, text := range telegramSplitMessage(telegramText(event), telegramMessageUnits) { @@ -324,7 +330,7 @@ func (b *TelegramBot) post(ctx context.Context, event Event) { return } - for _, markdown := range telegramSplitRich(event.Text, telegramRichBytes) { + for _, markdown := range telegramSplitRich(telegramEscapeTags(event.Text), telegramRichBytes) { b.deliverRich(ctx, markdown) } } @@ -348,16 +354,20 @@ func (b *TelegramBot) pause(ctx context.Context, err error, wait, asked time.Dur // handle runs one update. A text message of the owner in the private chat goes // to the agent, and handle returns when it is durable in the log. The line -// /stop interrupts the turn. Any other message of the owner gets the answer +// /stop interrupts the turn, the line /stop NAME stops the subagent NAME, and a +// line that starts with /whatsapp runs a WhatsApp command on whatsapp, whose +// answers go to the chat only. Any other message of the owner gets the answer // that only text is supported. Every other update is ignored, and its content // is not logged. -func (b *TelegramBot) handle(ctx context.Context, l *TurnLoop, update TelegramUpdate) error { +func (b *TelegramBot) handle(ctx context.Context, l *TurnLoop, whatsapp *WhatsApp, update TelegramUpdate) error { message := update.Message if message == nil || message.Chat.Type != "private" || message.Chat.ID != b.owner || message.From == nil || message.From.ID != b.owner { b.logger.Print("update ignored: not a message of the owner in the private chat") return nil } + name, stop := stopSubagentName(message.Text) + args, isWhatsApp := whatsappCommandArgs(message.Text) switch { case message.Text == "": b.notice(telegramTextOnly) @@ -365,6 +375,17 @@ func (b *TelegramBot) handle(ctx context.Context, l *TurnLoop, update TelegramUp if !l.Interrupt() { b.notice("No turn runs.") } + case stop: + found, err := l.StopSubagent(name) + if err != nil { + return fmt.Errorf("stop subagent %s: %w", name, err) + } + + if !found { + b.notice("No subagent " + name + " runs.") + } + case isWhatsApp: + whatsapp.Command(args, b.notice) default: _, err := l.Submit(telegramSource, message.Text) if err != nil { @@ -410,11 +431,13 @@ func (b *TelegramBot) deliver(ctx context.Context, part TelegramPart) { } } -// deliverRich sends markdown to the chat as a rich message. When the Bot API -// refuses it with HTTP 400 or 404, the message was not sent, so deliverRich -// sends the same Markdown once with message entities, and the reply is not -// lost and does not repeat. It tries again after each failure that a later try -// can fix, until ctx ends. It drops the message after any other failure. +// deliverRich sends markdown, escaped with telegramEscapeTags, to the chat as a +// rich message. When the Bot API refuses it with HTTP 400 or 404, the message +// was not sent, so deliverRich sends the text of the part once with message +// entities, and the reply is not lost and does not repeat. Message entities +// read no HTML, so the fallback gets the Markdown of telegramUnescapeTags, as +// the model wrote it. It tries again after each failure that a later try can +// fix, until ctx ends. It drops the message after any other failure. func (b *TelegramBot) deliverRich(ctx context.Context, markdown string) { wait := b.minWait for { @@ -425,7 +448,7 @@ func (b *TelegramBot) deliverRich(ctx context.Context, markdown string) { if telegramRejected(err) { b.logger.Printf("rich message refused, the reply goes with entities: %v", err) - for _, part := range telegramReplyParts(markdown) { + for _, part := range telegramReplyParts(telegramUnescapeTags(markdown)) { b.deliver(ctx, part) } @@ -527,11 +550,17 @@ func telegramSplitMessage(text string, limit int) []string { } // telegramText returns the text of event for the chat. A user message of -// another client has its source as a mark. +// another client has its source as a mark. A subagent shows only its start and +// how its run ended, because the reply of the agent carries the content of the +// report. func telegramText(event Event) string { switch event.Kind { case "user": return "[" + event.Source + "] " + event.Text + case "subagent": + return "[" + event.Text + "] started" + case "work": + return "[" + event.Source + "] " + event.Status case "error": return "Error: " + event.Text default: @@ -545,7 +574,8 @@ func telegramText(event Event) string { // after the last line break outside a code block, then after the last line // break in a code block, which it closes at the end of the part and opens again // in the next part with the same fence line. A line longer than limit is cut at -// the limit. It never cuts a character. +// the limit, or before an & in the four bytes before the limit, so that it does +// not cut an entity of telegramEscapeTags. It never cuts a character. func telegramSplitRich(markdown string, limit int) []string { var parts []string for len(markdown) > limit { @@ -648,6 +678,12 @@ func telegramRichCut(markdown string, limit int) (int, string, string) { cut-- } + start := max(cut-len("&")+1, 0) + entity := strings.LastIndexByte(markdown[start:cut], '&') + if entity >= 0 && start+entity > 0 { + cut = start + entity + } + return cut, "", "" }