handletelegram: don't return errors from message converter

pkg/connector/backfill.go

@@ -305,7 +305,7 @@ func (t *TelegramClient) FetchMessages(ctx context.Context, fetchParams bridgev2
 		if !ok {
 			continue
 		}
-		converted, err := t.convertToMatrixWithRefetch(ctx, portal, intent, message)
+		converted, err := t.convertToMatrix(ctx, portal, intent, message)
 		if err != nil {
 			return nil, err
 		}

pkg/connector/config.go

@@ -61,8 +61,7 @@ type TelegramConfig struct {
 	AnimatedSticker   media.AnimatedStickerConfig `yaml:"animated_sticker"`
 	ImageAsFilePixels int                         `yaml:"image_as_file_pixels"`
 
-	DisableViewOnce     bool `yaml:"disable_view_once"`
+	DisableViewOnce bool `yaml:"disable_view_once"`
-	DisableDisappearing bool `yaml:"disable_disappearing"`
 
 	MemberList MemberListConfig `yaml:"member_list"`
 
@@ -110,7 +109,6 @@ func upgradeConfig(helper up.Helper) {
 	helper.Copy(up.Int, "animated_sticker", "args", "fps")
 	helper.Copy(up.Int, "image_as_file_pixels")
 	helper.Copy(up.Bool, "disable_view_once")
-	helper.Copy(up.Bool, "disable_disappearing")
 	helper.Copy(up.Int, "member_list", "max_initial_sync")
 	helper.Copy(up.Bool, "member_list", "sync_broadcast_channels")
 	helper.Copy(up.Bool, "member_list", "skip_deleted")

pkg/connector/directdownload.go

@@ -34,6 +34,62 @@ import (
 
 var _ bridgev2.DirectMediableNetwork = (*TelegramConnector)(nil)
 
+func (tc *TelegramClient) refetchMedia(ctx context.Context, peerType ids.PeerType, peerID int64, msgID int) (tg.MessageMediaClass, error) {
+	var messages tg.ModifiedMessagesMessages
+	var err error
+	switch peerType {
+	case ids.PeerTypeUser, ids.PeerTypeChat:
+		messages, err = APICallWithUpdates(ctx, tc, func() (tg.ModifiedMessagesMessages, error) {
+			m, err := tc.client.API().MessagesGetMessages(ctx, []tg.InputMessageClass{
+				&tg.InputMessageID{ID: msgID},
+			})
+			if err != nil {
+				return nil, err
+			} else if messages, ok := m.(tg.ModifiedMessagesMessages); !ok {
+				return nil, fmt.Errorf("unsupported messages type %T", messages)
+			} else {
+				return messages, nil
+			}
+		})
+	case ids.PeerTypeChannel:
+		var accessHash int64
+		accessHash, err = tc.ScopedStore.GetAccessHash(ctx, ids.PeerTypeChannel, peerID)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get channel access hash: %w", err)
+		}
+		messages, err = APICallWithUpdates(ctx, tc, func() (tg.ModifiedMessagesMessages, error) {
+			m, err := tc.client.API().ChannelsGetMessages(ctx, &tg.ChannelsGetMessagesRequest{
+				Channel: &tg.InputChannel{ChannelID: peerID, AccessHash: accessHash},
+				ID: []tg.InputMessageClass{
+					&tg.InputMessageID{ID: msgID},
+				},
+			})
+			if err != nil {
+				return nil, err
+			} else if messages, ok := m.(tg.ModifiedMessagesMessages); !ok {
+				return nil, fmt.Errorf("unsupported messages type %T", messages)
+			} else {
+				return messages, nil
+			}
+		})
+	default:
+		return nil, fmt.Errorf("unknown peer type %s", peerType)
+	}
+	if err != nil {
+		return nil, fmt.Errorf("failed to get message %d/%d for media info: %w", peerID, msgID, err)
+	}
+
+	if len(messages.GetMessages()) != 1 {
+		return nil, fmt.Errorf("wrong number of messages retrieved %d", len(messages.GetMessages()))
+	} else if msg, ok := messages.GetMessages()[0].(*tg.Message); !ok {
+		return nil, fmt.Errorf("message was of the wrong type %s", messages.GetMessages()[0].TypeName())
+	} else if msg.ID != msgID {
+		return nil, fmt.Errorf("no media found with ID %d", msgID)
+	} else {
+		return msg.Media, nil
+	}
+}
+
 func (tc *TelegramConnector) Download(ctx context.Context, mediaID networkid.MediaID, params map[string]string) (mediaproxy.GetMediaResponse, error) {
 	info, err := ids.ParseDirectMediaInfo(mediaID)
 	if err != nil {
@@ -79,62 +135,12 @@ func (tc *TelegramConnector) Download(ctx context.Context, mediaID networkid.Med
 	var readyTransferer *media.ReadyTransferer
 
 	if info.MessageID > 0 {
-		var messages tg.ModifiedMessagesMessages
+		rawMsgMedia, err := client.refetchMedia(ctx, info.PeerType, info.PeerID, int(info.MessageID))
-		switch info.PeerType {
-		case ids.PeerTypeUser, ids.PeerTypeChat:
-			messages, err = APICallWithUpdates(ctx, client, func() (tg.ModifiedMessagesMessages, error) {
-				m, err := client.client.API().MessagesGetMessages(ctx, []tg.InputMessageClass{
-					&tg.InputMessageID{ID: int(info.MessageID)},
-				})
-				if err != nil {
-					return nil, err
-				} else if messages, ok := m.(tg.ModifiedMessagesMessages); !ok {
-					return nil, fmt.Errorf("unsupported messages type %T", messages)
-				} else {
-					return messages, nil
-				}
-			})
-		case ids.PeerTypeChannel:
-			var accessHash int64
-			accessHash, err = client.ScopedStore.GetAccessHash(ctx, ids.PeerTypeChannel, info.PeerID)
-			if err != nil {
-				return nil, fmt.Errorf("failed to get channel access hash: %w", err)
-			} else {
-				messages, err = APICallWithUpdates(ctx, client, func() (tg.ModifiedMessagesMessages, error) {
-					m, err := client.client.API().ChannelsGetMessages(ctx, &tg.ChannelsGetMessagesRequest{
-						Channel: &tg.InputChannel{ChannelID: info.PeerID, AccessHash: accessHash},
-						ID: []tg.InputMessageClass{
-							&tg.InputMessageID{ID: int(info.MessageID)},
-						},
-					})
-					if err != nil {
-						return nil, err
-					} else if messages, ok := m.(tg.ModifiedMessagesMessages); !ok {
-						return nil, fmt.Errorf("unsupported messages type %T", messages)
-					} else {
-						return messages, nil
-					}
-				})
-			}
-		default:
-			return nil, fmt.Errorf("unknown peer type %s", info.PeerType)
-		}
 		if err != nil {
-			return nil, fmt.Errorf("failed to get messages for %+v: %w", info, err)
+			return nil, fmt.Errorf("failed to refetch media message: %w", err)
 		}
 
-		var msgMedia tg.MessageMediaClass
+		switch msgMedia := rawMsgMedia.(type) {
-		if len(messages.GetMessages()) != 1 {
-			return nil, fmt.Errorf("wrong number of messages retrieved %d", len(messages.GetMessages()))
-		} else if msg, ok := messages.GetMessages()[0].(*tg.Message); !ok {
-			return nil, fmt.Errorf("message was of the wrong type %s", messages.GetMessages()[0].TypeName())
-		} else if msg.ID != int(info.MessageID) {
-			return nil, fmt.Errorf("no media found with ID %d", info.MessageID)
-		} else {
-			msgMedia = msg.Media
-		}
-
-		switch msgMedia := msgMedia.(type) {
 		case *tg.MessageMediaPhoto:
 			log.Debug().
 				Int64("photo_id", msgMedia.Photo.GetID()).

pkg/connector/example-config.yaml

@@ -36,8 +36,6 @@ image_as_file_pixels: 16777216
 
 # Should view-once messages be disabled entirely?
 disable_view_once: false
-# Should disappearing messages be disabled entirely?
-disable_disappearing: false
 
 # Settings for syncing the member list for portals.
 member_list:

pkg/connector/handletelegram.go

@@ -154,7 +154,7 @@ func (t *TelegramClient) onUpdateNewMessage(ctx context.Context, entities tg.Ent
 			},
 			ID:                 ids.GetMessageIDFromMessage(msg),
 			Data:               msg,
-			ConvertMessageFunc: t.convertToMatrixWithRefetch,
+			ConvertMessageFunc: t.convertToMatrix,
 		})
 
 		if err := resultToError(res); err != nil {
@@ -901,7 +901,7 @@ func (t *TelegramClient) onMessageEdit(ctx context.Context, update IGetMessage)
 		Data:          msg,
 		ConvertEditFunc: func(ctx context.Context, portal *bridgev2.Portal, intent bridgev2.MatrixAPI, existing []*database.Message, data *tg.Message) (*bridgev2.ConvertedEdit, error) {
 			log := zerolog.Ctx(ctx)
-			converted, err := t.convertToMatrixWithRefetch(ctx, portal, intent, msg)
+			converted, err := t.convertToMatrix(ctx, portal, intent, msg)
 			if err != nil {
 				return nil, err
 			}

pkg/connector/telegramfmt/convert.go

@@ -63,7 +63,7 @@ func (ctx formatContext) TextToHTML(text string) string {
 	return event.TextToHTML(text)
 }
 
-func Parse(ctx context.Context, message string, entities []tg.MessageEntityClass, params FormatParams) (*event.MessageEventContent, error) {
+func Parse(ctx context.Context, message string, entities []tg.MessageEntityClass, params FormatParams) *event.MessageEventContent {
 	log := zerolog.Ctx(ctx).With().Str("func", "Parse").Logger()
 	content := &event.MessageEventContent{
 		MsgType:  event.MsgText,
@@ -71,7 +71,7 @@ func Parse(ctx context.Context, message string, entities []tg.MessageEntityClass
 		Mentions: &event.Mentions{},
 	}
 	if len(entities) == 0 {
-		return content, nil
+		return content
 	}
 
 	lrt := &LinkedRangeTree{}
@@ -142,5 +142,5 @@ func Parse(ctx context.Context, message string, entities []tg.MessageEntityClass
 	content.Mentions.UserIDs = maps.Keys(mentions)
 	content.FormattedBody = lrt.Format(utf16Message, formatContext{})
 	content.Format = event.FormatHTML
-	return content, nil
+	return content
 }

pkg/connector/telegramfmt/convert_test.go

@@ -22,7 +22,6 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	"maunium.net/go/mautrix/event"
 	"maunium.net/go/mautrix/id"
 
@@ -75,8 +74,7 @@ func TestParse(t *testing.T) {
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			parsed, err := telegramfmt.Parse(context.TODO(), test.ins, test.ine, formatParams)
+			parsed := telegramfmt.Parse(context.TODO(), test.ins, test.ine, formatParams)
-			require.NoError(t, err)
 			assert.Equal(t, test.body, parsed.Body)
 			assert.Equal(t, test.html, parsed.FormattedBody)
 		})

pkg/connector/telegramfmt/html.go

@@ -71,11 +71,13 @@ func (s Style) Format(message string) string {
 	case StyleCustomEmoji:
 		if s.EmojiInfo.Emoji != "" {
 			return s.EmojiInfo.Emoji
-		} else {
+		} else if s.EmojiInfo.EmojiURI != "" {
 			return fmt.Sprintf(
 				`<img data-mx-emoticon data-mau-animated-emoji src="%s" height="32" width="32" alt="%s" title="%s"/>`,
 				s.EmojiInfo.EmojiURI, message, message,
 			)
+		} else {
+			return message
 		}
 	case StyleBotCommand:
 		return fmt.Sprintf("<font color='#3771bb'>%s</font>", message)

pkg/connector/tomatrix.go

@@ -69,16 +69,21 @@ func mediaHashID(ctx context.Context, m tg.MessageMediaClass) []byte {
 	return nil
 }
 
-func (c *TelegramClient) mediaToMatrix(ctx context.Context, portal *bridgev2.Portal, intent bridgev2.MatrixAPI, msg *tg.Message) (*bridgev2.ConvertedMessagePart, *database.DisappearingSetting, []byte, error) {
+func (c *TelegramClient) mediaToMatrix(
+	ctx context.Context,
+	portal *bridgev2.Portal,
+	intent bridgev2.MatrixAPI,
+	msg *tg.Message,
+) (*bridgev2.ConvertedMessagePart, *database.DisappearingSetting, []byte) {
 	media, ok := msg.GetMedia()
 	if !ok {
-		return nil, nil, nil, nil
+		return nil, nil, nil
 	}
 
 	switch media.TypeID() {
 	case tg.MessageMediaWebPageTypeID:
 		// Already handled in the message handling
-		return nil, nil, nil, nil
+		return nil, nil, nil
 	case tg.MessageMediaUnsupportedTypeID:
 		return &bridgev2.ConvertedMessagePart{
 			Type: event.EventMessage,
@@ -89,21 +94,20 @@ func (c *TelegramClient) mediaToMatrix(ctx context.Context, portal *bridgev2.Por
 			Extra: map[string]any{
 				"fi.mau.telegram.unsupported": true,
 			},
-		}, nil, nil, nil
+		}, nil, nil
 	case tg.MessageMediaPhotoTypeID, tg.MessageMediaDocumentTypeID:
-		converted, disappearingSetting, err := c.convertMediaRequiringUpload(ctx, portal, intent, msg.ID, media)
+		converted, disappearingSetting := c.convertMediaRequiringUpload(ctx, portal, intent, msg.ID, media, true)
-		return converted, disappearingSetting, mediaHashID(ctx, media), err
+		return converted, disappearingSetting, mediaHashID(ctx, media)
 	case tg.MessageMediaContactTypeID:
-		return c.convertContact(media), nil, nil, nil
+		return c.convertContact(media), nil, nil
 	case tg.MessageMediaGeoTypeID, tg.MessageMediaGeoLiveTypeID, tg.MessageMediaVenueTypeID:
-		location, err := convertLocation(media)
+		return convertLocation(media), nil, nil
-		return location, nil, nil, err
 	case tg.MessageMediaPollTypeID:
-		return convertPoll(media), nil, nil, nil
+		return convertPoll(media), nil, nil
 	case tg.MessageMediaDiceTypeID:
-		return convertDice(media), nil, nil, nil
+		return convertDice(media), nil, nil
 	case tg.MessageMediaGameTypeID:
-		return convertGame(media), nil, nil, nil
+		return convertGame(media), nil, nil
 	default:
 		// TODO: support these properly
 		return &bridgev2.ConvertedMessagePart{
@@ -116,64 +120,16 @@ func (c *TelegramClient) mediaToMatrix(ctx context.Context, portal *bridgev2.Por
 				"fi.mau.telegram.unsupported": true,
 				"fi.mau.telegram.type_id":     media.TypeID(),
 			},
-		}, nil, nil, nil
+		}, nil, nil
 	}
 }
 
-func (c *TelegramClient) convertToMatrixWithRefetch(ctx context.Context, portal *bridgev2.Portal, intent bridgev2.MatrixAPI, msg *tg.Message) (cm *bridgev2.ConvertedMessage, err error) {
+func (c *TelegramClient) convertToMatrix(
-	cm, err = c.convertToMatrix(ctx, portal, intent, msg)
+	ctx context.Context,
-	if !tgerr.Is(err, tg.ErrFileReferenceExpired) {
+	portal *bridgev2.Portal,
-		return cm, err
+	intent bridgev2.MatrixAPI,
-	}
+	msg *tg.Message,
-
+) (cm *bridgev2.ConvertedMessage, err error) {
-	// If the error is that the file reference expired, refetch the message and
-	// try to convert it again.
-	log := zerolog.Ctx(ctx).With().Bool("message_refetch", true).Logger()
-	ctx = log.WithContext(ctx)
-	log.Warn().Err(err).Msg("Refetching message to convert media")
-
-	// TODO deduplicate this with the direct download code
-	var m tg.MessagesMessagesClass
-	peerType, id, err := ids.ParsePortalID(portal.ID)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse portal ID: %w", err)
-	} else if peerType == ids.PeerTypeChannel {
-		var accessHash int64
-		accessHash, err = c.ScopedStore.GetAccessHash(ctx, ids.PeerTypeChannel, id)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get channel access hash: %w", err)
-		}
-		m, err = c.client.API().ChannelsGetMessages(ctx, &tg.ChannelsGetMessagesRequest{
-			Channel: &tg.InputChannel{
-				ChannelID:  id,
-				AccessHash: accessHash,
-			},
-			ID: []tg.InputMessageClass{
-				&tg.InputMessageID{ID: msg.ID},
-			},
-		})
-	} else {
-		m, err = c.client.API().MessagesGetMessages(ctx, []tg.InputMessageClass{
-			&tg.InputMessageID{ID: msg.ID},
-		})
-	}
-
-	if err != nil {
-		return nil, err
-	} else if messages, ok := m.(tg.ModifiedMessagesMessages); !ok {
-		return nil, fmt.Errorf("unsupported messages type %T", messages)
-	} else if len(messages.GetMessages()) != 1 {
-		return nil, fmt.Errorf("wrong number of messages retrieved %d", len(messages.GetMessages()))
-	} else if refetchedMsg, ok := messages.GetMessages()[0].(*tg.Message); !ok {
-		return nil, fmt.Errorf("message was of the wrong type %s", messages.GetMessages()[0].TypeName())
-	} else if refetchedMsg.ID != msg.ID {
-		return nil, fmt.Errorf("no media found with ID %d", msg.ID)
-	} else {
-		return c.convertToMatrix(ctx, portal, intent, refetchedMsg)
-	}
-}
-
-func (c *TelegramClient) convertToMatrix(ctx context.Context, portal *bridgev2.Portal, intent bridgev2.MatrixAPI, msg *tg.Message) (cm *bridgev2.ConvertedMessage, err error) {
 	log := zerolog.Ctx(ctx).With().Str("conversion_direction", "to_matrix").Logger()
 	ctx = log.WithContext(ctx)
 
@@ -183,7 +139,7 @@ func (c *TelegramClient) convertToMatrix(ctx context.Context, portal *bridgev2.P
 
 	var perMessageProfile *event.BeeperPerMessageProfile
 	if peerType, _, err := ids.ParsePortalID(portal.ID); err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to parse portal ID: %w", err)
 	} else if peerType == ids.PeerTypeChannel && !portal.Metadata.(*PortalMetadata).IsSuperGroup {
 		var sender *networkid.UserID
 		if msg.Out {
@@ -194,7 +150,7 @@ func (c *TelegramClient) convertToMatrix(ctx context.Context, portal *bridgev2.P
 		if sender != nil {
 			profile, err := portal.PerMessageProfileForSender(ctx, *sender)
 			if err != nil {
-				return nil, err
+				return nil, fmt.Errorf("failed to get per-message profile for sender %s: %w", *sender, err)
 			}
 			perMessageProfile = &profile
 		}
@@ -205,35 +161,28 @@ func (c *TelegramClient) convertToMatrix(ctx context.Context, portal *bridgev2.P
 	if len(msg.Message) > 0 {
 		hasher.Write([]byte(msg.Message))
 
-		content, err := c.parseBodyAndHTML(ctx, msg.Message, msg.Entities)
+		content := c.parseBodyAndHTML(ctx, msg.Message, msg.Entities)
-		if err != nil {
-			return nil, err
-		}
 		if media, ok := msg.GetMedia(); ok && media.TypeID() == tg.MessageMediaWebPageTypeID {
 			webpageCtx, webpageCtxCancel := context.WithTimeout(ctx, time.Second*5)
 			defer webpageCtxCancel()
 			preview, err := c.webpageToBeeperLinkPreview(webpageCtx, portal, intent, msg, media)
 			if err != nil {
-				log.Err(err).Msg("error converting webpage to link preview")
+				log.Err(err).Msg("Failed to convert webpage to link preview")
 			} else if preview != nil {
 				hasher.Write([]byte(preview.MatchedURL))
 				content.BeeperLinkPreviews = append(content.BeeperLinkPreviews, preview)
 			}
 		}
 
-		cm.Parts = []*bridgev2.ConvertedMessagePart{
+		cm.Parts = []*bridgev2.ConvertedMessagePart{{
-			{
+			Type:    event.EventMessage,
-				Type:    event.EventMessage,
+			Content: content,
-				Content: content,
+		}}
-			},
-		}
 	}
 
 	var contentURI id.ContentURIString
-	mediaPart, disappearingSetting, mediaHashID, err := c.mediaToMatrix(ctx, portal, intent, msg)
+	mediaPart, disappearingSetting, mediaHashID := c.mediaToMatrix(ctx, portal, intent, msg)
-	if err != nil {
+	if mediaPart != nil {
-		return nil, err
-	} else if mediaPart != nil {
 		hasher.Write(mediaHashID)
 		cm.Parts = append(cm.Parts, mediaPart)
 		cm.MergeCaption()
@@ -283,9 +232,9 @@ func (c *TelegramClient) convertToMatrix(ctx context.Context, portal *bridgev2.P
 	return
 }
 
-func (t *TelegramClient) parseBodyAndHTML(ctx context.Context, message string, entities []tg.MessageEntityClass) (*event.MessageEventContent, error) {
+func (t *TelegramClient) parseBodyAndHTML(ctx context.Context, message string, entities []tg.MessageEntityClass) *event.MessageEventContent {
 	if len(entities) == 0 {
-		return &event.MessageEventContent{MsgType: event.MsgText, Body: message}, nil
+		return &event.MessageEventContent{MsgType: event.MsgText, Body: message}
 	}
 
 	var customEmojiIDs []int64
@@ -297,7 +246,9 @@ func (t *TelegramClient) parseBodyAndHTML(ctx context.Context, message string, e
 	}
 	customEmojis, err := t.transferEmojisToMatrix(ctx, customEmojiIDs)
 	if err != nil {
-		return nil, err
+		zerolog.Ctx(ctx).Err(err).
+			Ints64("emoji_ids", customEmojiIDs).
+			Msg("Failed to transfer custom emojis to Matrix")
 	}
 	return telegramfmt.Parse(ctx, message, entities, t.telegramFmtParams.WithCustomEmojis(customEmojis))
 }
@@ -335,7 +286,14 @@ func (c *TelegramClient) webpageToBeeperLinkPreview(ctx context.Context, portal
 	return preview, nil
 }
 
-func (c *TelegramClient) convertMediaRequiringUpload(ctx context.Context, portal *bridgev2.Portal, intent bridgev2.MatrixAPI, msgID int, msgMedia tg.MessageMediaClass) (*bridgev2.ConvertedMessagePart, *database.DisappearingSetting, error) {
+func (c *TelegramClient) convertMediaRequiringUpload(
+	ctx context.Context,
+	portal *bridgev2.Portal,
+	intent bridgev2.MatrixAPI,
+	msgID int,
+	msgMedia tg.MessageMediaClass,
+	allowRefetch bool,
+) (converted *bridgev2.ConvertedMessagePart, disappearingSetting *database.DisappearingSetting) {
 	log := zerolog.Ctx(ctx).With().
 		Str("conversion_direction", "to_matrix").
 		Str("portal_id", string(portal.ID)).
@@ -350,7 +308,6 @@ func (c *TelegramClient) convertMediaRequiringUpload(ctx context.Context, portal
 	transferer := media.NewTransferer(c.client.API()).WithRoomID(portal.MXID)
 	var mediaTransferer *media.ReadyTransferer
 
-	var disappearingSetting *database.DisappearingSetting
 	if t, ok := msgMedia.(ttlable); ok {
 		if ttl, ok := t.GetTTLSeconds(); ok {
 			typeName := "photo"
@@ -363,26 +320,17 @@ func (c *TelegramClient) convertMediaRequiringUpload(ctx context.Context, portal
 				ttl = 15
 
 				if c.main.Config.DisableViewOnce {
-					return &bridgev2.ConvertedMessagePart{
+					converted = &bridgev2.ConvertedMessagePart{
 						Type: event.EventMessage,
 						Content: &event.MessageEventContent{
 							MsgType: event.MsgNotice,
 							Body:    fmt.Sprintf("You received a view once %s. For added privacy, you can only open it on the Telegram app.", typeName),
 						},
-					}, nil, nil
+					}
+					return
 				}
 			}
 
-			if c.main.Config.DisableDisappearing {
-				return &bridgev2.ConvertedMessagePart{
-					Type: event.EventMessage,
-					Content: &event.MessageEventContent{
-						MsgType: event.MsgNotice,
-						Body:    fmt.Sprintf("You received a disappearing %s. For added privacy, you can only open it on the Telegram app.", typeName),
-					},
-				}, nil, nil
-			}
-
 			disappearingSetting = &database.DisappearingSetting{
 				// Even though normal message TTLs are after send, media is after read
 				Type:  event.DisappearingTypeAfterRead,
@@ -402,14 +350,28 @@ func (c *TelegramClient) convertMediaRequiringUpload(ctx context.Context, portal
 		}
 		photo, ok := msgMedia.Photo.(*tg.Photo)
 		if !ok {
-			return nil, nil, fmt.Errorf("unrecognized photo type %T", msgMedia.Photo)
+			converted = &bridgev2.ConvertedMessagePart{
+				Type: event.EventMessage,
+				Content: &event.MessageEventContent{
+					MsgType: event.MsgNotice,
+					Body:    "Unsupported photo message. Check Telegram app.",
+				},
+			}
+			return
 		}
 		telegramMediaID = photo.GetID()
 		mediaTransferer = transferer.WithPhoto(photo)
 	case *tg.MessageMediaDocument:
 		document, ok := msgMedia.Document.(*tg.Document)
 		if !ok {
-			return nil, nil, fmt.Errorf("unrecognized document type %T", msgMedia.Document)
+			converted = &bridgev2.ConvertedMessagePart{
+				Type: event.EventMessage,
+				Content: &event.MessageEventContent{
+					MsgType: event.MsgNotice,
+					Body:    "Unsupported document message. Check Telegram app.",
+				},
+			}
+			return
 		}
 		telegramMediaID = document.GetID()
 
@@ -522,37 +484,65 @@ func (c *TelegramClient) convertMediaRequiringUpload(ctx context.Context, portal
 			if c.main.useDirectMedia {
 				thumbnailURL, thumbnailInfo, err = thumbnailTransferer.DirectDownloadURL(ctx, c.telegramUserID, portal, msgID, true, document.ID)
 				if err != nil {
-					log.Err(err).Msg("error getting direct download URL for thumbnail")
+					log.Err(err).Msg("Failed to create direct download URL for thumbnail")
 				}
 			}
 			if thumbnailURL == "" {
 				thumbnailURL, thumbnailFile, thumbnailInfo, err = thumbnailTransferer.Transfer(ctx, c.main.Store, intent)
 				if err != nil {
-					return nil, nil, fmt.Errorf("error transferring thumbnail: %w", err)
+					log.Err(err).Msg("Failed to transfer thumbnail")
 				}
 			}
-
+			if thumbnailURL != "" || thumbnailFile != nil {
-			transferer = transferer.WithThumbnail(thumbnailURL, thumbnailFile, thumbnailInfo)
+				transferer = transferer.WithThumbnail(thumbnailURL, thumbnailFile, thumbnailInfo)
+			}
 		}
 
 		mediaTransferer = transferer.
 			WithFilename(content.Body).
 			WithDocument(msgMedia.Document, false)
 	default:
-		return nil, nil, fmt.Errorf("unhandled media type %T", msgMedia)
+		converted = &bridgev2.ConvertedMessagePart{
+			Type: event.EventMessage,
+			Content: &event.MessageEventContent{
+				MsgType: event.MsgNotice,
+				Body:    "Unsupported media message. Check Telegram app.",
+			},
+		}
+		return
 	}
 
 	var err error
 	if c.main.useDirectMedia && (!isSticker || c.main.Config.AnimatedSticker.Target == "disable") {
 		content.URL, content.Info, err = mediaTransferer.DirectDownloadURL(ctx, c.telegramUserID, portal, msgID, false, telegramMediaID)
 		if err != nil {
-			log.Err(err).Msg("error getting direct download URL for media")
+			log.Err(err).Msg("Failed to create direct download URL for media")
 		}
 	}
 	if content.URL == "" {
 		content.URL, content.File, content.Info, err = mediaTransferer.Transfer(ctx, c.main.Store, intent)
 		if err != nil {
-			return nil, nil, fmt.Errorf("error transferring media: %w", err)
+			if tgerr.Is(err, tg.ErrFileReferenceExpired) && allowRefetch {
+				log.Warn().Err(err).Msg("Failed to transfer media, trying to refetch from message")
+				peerType, peerID, err := ids.ParsePortalID(portal.ID)
+				if err != nil {
+					log.Err(err).Msg("Failed to parse portal ID to refetch media")
+				} else if msgMedia, err = c.refetchMedia(ctx, peerType, peerID, msgID); err != nil {
+					log.Err(err).Msg("Failed to refetch media after file reference expired error")
+				} else {
+					return c.convertMediaRequiringUpload(ctx, portal, intent, msgID, msgMedia, false)
+				}
+			} else {
+				log.Err(err).Msg("Failed to transfer media")
+			}
+			converted = &bridgev2.ConvertedMessagePart{
+				Type: event.EventMessage,
+				Content: &event.MessageEventContent{
+					MsgType: event.MsgNotice,
+					Body:    "Failed to transfer media. Check Telegram app.",
+				},
+			}
+			return
 		}
 		if msgMedia.TypeID() == tg.MessageMediaPhotoTypeID {
 			content.Body = content.Body + exmime.ExtensionFromMimetype(content.Info.MimeType)
@@ -572,11 +562,12 @@ func (c *TelegramClient) convertMediaRequiringUpload(ctx context.Context, portal
 		info["fi.mau.telegram.spoiler"] = true
 	}
 
-	return &bridgev2.ConvertedMessagePart{
+	converted = &bridgev2.ConvertedMessagePart{
 		Type:    eventType,
 		Content: &content,
 		Extra:   extra,
-	}, disappearingSetting, nil
+	}
+	return
 }
 
 func (c *TelegramClient) convertContact(media tg.MessageMediaClass) *bridgev2.ConvertedMessagePart {
@@ -617,10 +608,16 @@ type hasGeo interface {
 	GetGeo() tg.GeoPointClass
 }
 
-func convertLocation(media tg.MessageMediaClass) (*bridgev2.ConvertedMessagePart, error) {
+func convertLocation(media tg.MessageMediaClass) *bridgev2.ConvertedMessagePart {
 	g, ok := media.(hasGeo)
 	if !ok || g.GetGeo().TypeID() != tg.GeoPointTypeID {
-		return nil, fmt.Errorf("location didn't have geo or geo is wrong type")
+		return &bridgev2.ConvertedMessagePart{
+			Type: event.EventMessage,
+			Content: &event.MessageEventContent{
+				MsgType: event.MsgNotice,
+				Body:    "Unsupported location message. Check Telegram app.",
+			},
+		}
 	}
 	point := g.GetGeo().(*tg.GeoPoint)
 	var longChar, latChar string
@@ -667,7 +664,7 @@ func convertLocation(media tg.MessageMediaClass) (*bridgev2.ConvertedMessagePart
 			FormattedBody: fmt.Sprintf(`%s: <a href="%s">%s</a>`, note, url, body),
 		},
 		Extra: extra,
-	}, nil
+	}
 }
 
 func convertPoll(media tg.MessageMediaClass) *bridgev2.ConvertedMessagePart {