Separate multiline Go statements

[onechat] / telegram.go

diff --git a/telegram.go b/telegram.go
index f3b3bb22ee30db537859b1a6682294e18becd010..59ea9b4d928a1247e8e54cff2f1871c9b565c002 100644 (file)
--- a/telegram.go
+++ b/telegram.go
@@ -58,6 +58,66 @@ const (
        telegramTextOnly = "Only text messages are supported."
 )
 
        telegramTextOnly = "Only text messages are supported."
 )
 

+// TelegramConfig holds the settings of telegram.json: the bot token and the
+// user ID of the owner. The token is a secret, so the file must have mode 0600.
+type TelegramConfig struct {
+       Token string `json:"token"`
+       Owner int64  `json:"owner"`
+}
+
+// TelegramBot connects the private chat of the owner with the agent. It polls
+// the Bot API for new messages and sends owner text, images, and voice notes to
+// the agent. It ignores every other update. Its sender sends the replies, the
+// errors, the notices of the bot, and the user messages of the other clients to
+// the chat, and shows the typing action while a turn runs. Only the replies
+// have a format: their Markdown goes as rich messages, which Telegram renders
+// itself, and as message entities only when Telegram refuses a rich message.
+// The rest is plain text. Tool calls do not go to the chat.
+//
+// The offset file holds the ID of the next update. It moves past an update
+// only after the message of the update is durable in the log, so a restart
+// does not lose a message. A crash between the flush and the offset write
+// makes Telegram send the update again, and the message repeats once.
+//
+// A failed Bot API call waits and tries again, from telegramRetryDelay up to
+// telegramRetryLimit, or as long as the Bot API asks. It never stops the agent.
+// A TelegramOutage logs the first failure and the end of each run of failures,
+// and the retries between them log nothing.
+type TelegramBot struct {
+       api        *TelegramAPI
+       voice      *VoiceTranscriber
+       owner      int64
+       offsetPath string
+       logger     *slog.Logger
+
+       mutex sync.Mutex
+       queue []Event
+       ready chan struct{}
+}
+
+// TelegramOutage is one run of failures of a kind of Bot API call. The first
+// failure logs loss, its cause, and the wait of the next try. The retries log
+// nothing. The next answer of Telegram logs back and the length of the outage.
+// loss and back say what the user loses and gets again.
+type TelegramOutage struct {
+       logger *slog.Logger
+       loss   string
+       back   string
+       start  time.Time
+}
+
+// TelegramPart is the text of one message to the chat, at most
+// telegramMessageUnits long, and its entities.
+type TelegramPart struct {
+       text     string
+       entities []TelegramEntity
+}
+
+// TelegramOffsetFile is the content of the offset file.
+type TelegramOffsetFile struct {
+       Offset int64 `json:"offset"`
+}
+

 // loadTelegramConfig reads telegram.json in dir. It returns false when the file
 // does not exist. An error never holds the token.
 func loadTelegramConfig(dir string) (TelegramConfig, bool, error) {
 // loadTelegramConfig reads telegram.json in dir. It returns false when the file
 // does not exist. An error never holds the token.
 func loadTelegramConfig(dir string) (TelegramConfig, bool, error) {


@@ -108,6 +168,7 @@ func loadTelegramConfig(dir string) (TelegramConfig, bool, error) {
 func newTelegramBot(api *TelegramAPI, owner int64, offsetPath string, logger *slog.Logger) *TelegramBot {
        return &TelegramBot{
                api:        api,
 func newTelegramBot(api *TelegramAPI, owner int64, offsetPath string, logger *slog.Logger) *TelegramBot {
        return &TelegramBot{
                api:        api,

+               voice:      &VoiceTranscriber{},

                owner:      owner,
                offsetPath: offsetPath,
                logger:     logger,
                owner:      owner,
                offsetPath: offsetPath,
                logger:     logger,


@@ -115,13 +176,6 @@ func newTelegramBot(api *TelegramAPI, owner int64, offsetPath string, logger *sl
        }
 }
 
        }
 }
 

-// TelegramConfig holds the settings of telegram.json: the bot token and the
-// user ID of the owner. The token is a secret, so the file must have mode 0600.
-type TelegramConfig struct {
-       Token string `json:"token"`
-       Owner int64  `json:"owner"`
-}
-

 // validate makes sure that the token has the form of a bot token and that the
 // owner is a user ID. The token goes into a URL path, so it can only hold the
 // characters of a bot token.
 // validate makes sure that the token has the form of a bot token and that the
 // owner is a user ID. The token goes into a URL path, so it can only hold the
 // characters of a bot token.


@@ -138,35 +192,6 @@ func (c TelegramConfig) validate() error {
        return nil
 }
 
        return nil
 }
 

-// TelegramBot connects the private chat of the owner with the agent. It polls
-// the Bot API for new messages and sends owner text and images to the agent. It
-// ignores every other update. Its sender sends the replies, the errors, the
-// notices of the bot, and the user messages of the other clients to the chat,
-// and shows the typing action while a turn runs. Only the replies have a
-// format: their Markdown goes as rich messages, which Telegram renders itself,
-// and as message entities only when Telegram refuses a rich message. The rest
-// is plain text. Tool calls do not go to the chat.
-//
-// The offset file holds the ID of the next update. It moves past an update
-// only after the message of the update is durable in the log, so a restart
-// does not lose a message. A crash between the flush and the offset write
-// makes Telegram send the update again, and the message repeats once.
-//
-// A failed Bot API call waits and tries again, from telegramRetryDelay up to
-// telegramRetryLimit, or as long as the Bot API asks. It never stops the agent.
-// A TelegramOutage logs the first failure and the end of each run of failures,
-// and the retries between them log nothing.
-type TelegramBot struct {
-       api        *TelegramAPI
-       owner      int64
-       offsetPath string
-       logger     *slog.Logger
-
-       mutex sync.Mutex
-       queue []Event
-       ready chan struct{}
-}
-

 // Notify queues event for the chat. It never blocks, so a slow network does not
 // stop the agent. The WhatsApp batches and the runs of the schedules do not go
 // to the chat: the reply of the agent tells the user what needs the user.
 // Notify queues event for the chat. It never blocks, so a slow network does not
 // stop the agent. The WhatsApp batches and the runs of the schedules do not go
 // to the chat: the reply of the agent tells the user what needs the user.


@@ -399,8 +424,9 @@ func (b *TelegramBot) pause(ctx context.Context, outage *TelegramOutage, err err
 // /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. Photos and image documents enter the shared
 // /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. Photos and image documents enter the shared

-// image store with their caption. Other media keep the text-only answer. Every
-// other update is ignored, and its content is not logged.
+// image store with their caption. Voice notes keep their audio and local
+// transcript. Other media keep the text-only answer. Every other update is
+// ignored, and its content is not logged.

 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 {
 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 {


@@ -412,6 +438,17 @@ func (b *TelegramBot) handle(ctx context.Context, l *TurnLoop, whatsapp *WhatsAp
        name, stop := stopSubagentName(message.Text)
        args, isWhatsApp := whatsappCommandArgs(message.Text)
        switch {
        name, stop := stopSubagentName(message.Text)
        args, isWhatsApp := whatsappCommandArgs(message.Text)
        switch {

+       case message.Voice != nil:
+               text := telegramVoiceText(ctx, b.api, l.agent.Voices(), b.voice, message)
+               _, err := l.Submit(telegramSource, text)
+               if err != nil {
+                       return fmt.Errorf("submit Telegram voice: %w", err)
+               }
+
+               err = l.Flush(context.WithoutCancel(ctx))
+               if err != nil {
+                       return fmt.Errorf("flush Telegram voice: %w", err)
+               }

        case len(message.Photo) > 0 || message.Document != nil:
                text, err := telegramImageText(ctx, b.api, l.agent.Images(), message)
                if err != nil {
        case len(message.Photo) > 0 || message.Document != nil:
                text, err := telegramImageText(ctx, b.api, l.agent.Images(), message)
                if err != nil {


@@ -575,17 +612,6 @@ func (b *TelegramBot) notice(text string) {
        })
 }
 
        })
 }
 

-// TelegramOutage is one run of failures of a kind of Bot API call. The first
-// failure logs loss, its cause, and the wait of the next try. The retries log
-// nothing. The next answer of Telegram logs back and the length of the outage.
-// loss and back say what the user loses and gets again.
-type TelegramOutage struct {
-       logger *slog.Logger
-       loss   string
-       back   string
-       start  time.Time
-}
-

 // Fail logs the start of an outage with err and delay, unless an outage runs.
 func (o *TelegramOutage) Fail(err error, delay time.Duration) {
        if !o.start.IsZero() {
 // Fail logs the start of an outage with err and delay, unless an outage runs.
 func (o *TelegramOutage) Fail(err error, delay time.Duration) {
        if !o.start.IsZero() {


@@ -607,18 +633,6 @@ func (o *TelegramOutage) End() {
        o.start = time.Time{}
 }
 
        o.start = time.Time{}
 }
 

-// TelegramPart is the text of one message to the chat, at most
-// telegramMessageUnits long, and its entities.
-type TelegramPart struct {
-       text     string
-       entities []TelegramEntity
-}
-
-// TelegramOffsetFile is the content of the offset file.
-type TelegramOffsetFile struct {
-       Offset int64 `json:"offset"`
-}
-

 // telegramLoadOffset reads the update offset at path. A missing file gives 0,
 // which asks for every update that Telegram keeps.
 func telegramLoadOffset(path string) (int64, error) {
 // telegramLoadOffset reads the update offset at path. A missing file gives 0,
 // which asks for every update that Telegram keeps.
 func telegramLoadOffset(path string) (int64, error) {