feat(channel): inbound rich Parts across IMs (#644)

* feat(pipeline): consume inbound MessagePart in adapt

Adapters that populate Message.Parts (currently only Telegram, for mentions)
had their structured data silently dropped: adaptMessage and adaptEdit only
read msg.Message.Text, so the canonical ContentNode tree the renderer is
designed to consume was never built.

Add adaptBody/adaptParts/partToNode that translate channel.MessagePart into
the ContentNode shape the renderer already supports (mention/link/pre/code
plus nested bold/italic/strikethrough wrappers). Fall back to the existing
plain-text path when Parts is empty.

Telegram inbound mentions now reach the LLM as <mention uid="..."> instead
of being flattened to plain text.

* feat(telegram): extract bold/italic/code/link entities as inbound parts

The previous extractor only recognised mention/text_mention, so Telegram
formatting (bold, italic, code, code blocks, text_link, bare URLs) was
flattened to plain text before reaching the pipeline. With the renderer
now consuming MessagePart via adaptBody, populating the full entity set
lets the LLM see the user's formatting intent.

The new extractor walks rune offsets, sorts entities by (offset asc,
length desc) so an outer span wins on overlap, emits plain-text Parts
for the gaps between entities, and returns nil when the result carries
no rich content so callers fall back to the Text field unchanged.

* feat(feishu): emit inbound post structure as MessagePart

Feishu post messages already carry a structured tree (lines of typed
elements: text with style, link, at-mention, code block). The inbound
path flattened it to a space-joined string, so style, link URLs, and
@user IDs never reached the pipeline.

extractFeishuPostParts walks the same lines/parts structure as the
existing text and attachment extractors, translates each tag (text +
style array, a, at, code_block) into channel.MessagePart, and inserts
a newline text part between lines so the LLM sees the paragraph break.
Returns nil for single-line all-unstyled posts so callers fall back to
the plain Text field unchanged.

* fix(telegram): slice entities by UTF-16 code units

Telegram entity offset and length are documented as UTF-16 code units,
but the parser indexed into []rune, which under-counts every
supplementary-plane character (most emoji) by one position. A bold
entity following 🎉 in the message would land one character left of
its real target, so the LLM would see "old" wrapped in <b> instead of
"bold", and any further entity in the same message would compound the
drift.

Switch the parser to walk utf16.Encode/Decode of the text, matching
the Telegram spec. The BMP-only test is kept (CJK still indexes the
same under either model) and the surrogate-pair case is now covered by
TestExtractTelegramMessageParts_HandlesSupplementaryPlaneEmoji.

* fix(telegram): bump inbound Format to rich when Parts populate

toInboundTelegramMessage hard-coded MessageFormatPlain regardless of
whether entity parsing produced rich Parts, so an inbound message with
bold/italic/code spans reached downstream consumers tagged as plain
even though Parts already carried the structure. Discord/Slack/Feishu
inbound flip Format to Rich in the same condition; align Telegram.

Also rename the local variable from mentionParts to richParts now that
the extractor covers all supported entity types, not just mentions.

* fix(pipeline): preserve whitespace-only text parts in adapt

adaptParts rejected any text MessagePart whose body trimmed to empty,
so structured-post adapters that interleave content with newline
separators (Feishu emits a "\n" text Part between lines) lost the
separators and the agent saw `line1line2` instead of `line1\nline2`.

Only drop literally empty parts now; whitespace-only spans flow through
unchanged. The existing single-line "all-plain-no-styles → nil" guards
on the adapter side still elide whole-message whitespace runs, so this
loosening only matters once at least one rich span makes the message
non-trivial.

* fix(feishu): keep text from unknown post tags

extractFeishuPostText's default branch reads part["text"] for any
unrecognised tag, so the legacy text path always surfaced user-visible
copy from forward-compat tags. The new Parts builder's default branch
silently dropped them, so a post mixing a styled element (which flips
adaptBody to the Parts path) with an unknown text-bearing tag lost
that content from the LLM context entirely.

Forward text-bearing unknown tags as plain text Parts. rich=false stays
so this alone never promotes an all-plain post into the rich path.

* fix(telegram): preserve sender text on text_mention parts

The text_mention branch overwrote the entity slice with "@" plus the
linked profile's first name. When a sender anchored a tg://user link
to a custom label such as "the reviewer", the LLM saw "@alice"
instead of what was actually written; the link target also lost the
visible context the sender chose.

Use the entity slice as the mention display, surface the linked user's
id and profile via Metadata, and set ChannelIdentityID to the platform
user id so downstream identity rendering still works.

* fix(telegram): split outer entity around nested link/mention

Telegram delivers overlapping entities natively (a bold span covers
the whole rendered text, a text_link/text_mention pin a sub-range).
The cursor guard dropped any nested entity, so a bold-with-link
message reached the LLM as bold text only — the URL/identity signal
was lost, even though the wire payload carried it.

Pre-pass to identify each structural entity's smallest container. In
the main loop, when an outer entity has nested structural children,
emit the outer in segments around the children: lead styled run, then
the child (link or mention with full URL/ChannelIdentityID), then the
tail styled run. The flat MessagePart schema still can't carry both
the outer style and the link at the same position, so the link span
itself appears without the outer's style — but the URL is preserved,
and the surrounding text keeps the user's emphasis.

* fix(telegram): treat coextensive style+structural as nested

The split pre-pass skipped any candidate whose range exactly matched the
structural entity's. A fully bold link (bold and text_link covering the
identical span) therefore had no recognised parent, the main loop emitted
only the styled span, and the cursor guard then dropped the text_link —
the URL never reached the LLM even though Telegram delivered it.

Drop the equality exclusion so a style entity on the same range counts
as the structural's parent, and explicitly skip structural candidates
when picking a parent so two coextensive links don't mutually adopt each
other and disappear. The split path then emits just the link Part (the
flat schema still can't carry both style and link at the same span; the
URL wins).

Author: ChrAlpha

internal/channel/adapters/feishu/inbound.go

@@ -51,6 +51,10 @@ func extractFeishuInbound(event *larkim.P2MessageReceiveV1, botOpenID string, lo
 			if postText != "" {
 				msg.Text = postText
 			}
+			if postParts := extractFeishuPostParts(contentMap); len(postParts) > 0 {
+				msg.Parts = postParts
+				msg.Format = channel.MessageFormatRich
+			}
 			postAtts := extractFeishuPostAttachments(contentMap, msg.ID)
 			msg.Attachments = append(msg.Attachments, postAtts...)
 			if len(postAtts) > 0 || postText != "" {

internal/channel/adapters/feishu/inbound_post.go

@@ -128,3 +128,133 @@ func stringValue(raw any) string {
 	}
 	return fmt.Sprint(raw)
 }
+
+func extractFeishuPostParts(contentMap map[string]any) []channel.MessagePart {
+	linesRaw := getFeishuPostContentLines(contentMap)
+	if linesRaw == nil {
+		return nil
+	}
+	var parts []channel.MessagePart
+	hasRich := false
+	for li, rawLine := range linesRaw {
+		line, ok := rawLine.([]any)
+		if !ok {
+			continue
+		}
+		if li > 0 && len(parts) > 0 {
+			parts = append(parts, channel.MessagePart{Type: channel.MessagePartText, Text: "\n"})
+			hasRich = true
+		}
+		for _, rawPart := range line {
+			part, ok := rawPart.(map[string]any)
+			if !ok {
+				continue
+			}
+			mp, rich, ok := feishuPostPartToMessagePart(part)
+			if !ok {
+				continue
+			}
+			if rich {
+				hasRich = true
+			}
+			parts = append(parts, mp)
+		}
+	}
+	if !hasRich {
+		return nil
+	}
+	return parts
+}
+
+func feishuPostPartToMessagePart(part map[string]any) (channel.MessagePart, bool, bool) {
+	tag := strings.ToLower(strings.TrimSpace(stringValue(part["tag"])))
+	switch tag {
+	case "text":
+		text := stringValue(part["text"])
+		if text == "" {
+			return channel.MessagePart{}, false, false
+		}
+		styles := feishuPostStyles(part["style"])
+		return channel.MessagePart{
+			Type:   channel.MessagePartText,
+			Text:   text,
+			Styles: styles,
+		}, len(styles) > 0, true
+	case "a":
+		text := stringValue(part["text"])
+		href := strings.TrimSpace(stringValue(part["href"]))
+		if text == "" && href == "" {
+			return channel.MessagePart{}, false, false
+		}
+		if text == "" {
+			text = href
+		}
+		return channel.MessagePart{
+			Type: channel.MessagePartLink,
+			Text: text,
+			URL:  href,
+		}, true, true
+	case "at":
+		uid := strings.TrimSpace(stringValue(part["user_id"]))
+		display := strings.TrimSpace(stringValue(part["text"]))
+		if display == "" {
+			display = strings.TrimSpace(stringValue(part["name"]))
+		}
+		if display == "" {
+			display = strings.TrimSpace(stringValue(part["user_name"]))
+		}
+		if display == "" {
+			if uid == "" {
+				return channel.MessagePart{}, false, false
+			}
+			display = "@" + uid
+		} else if !strings.HasPrefix(display, "@") {
+			display = "@" + display
+		}
+		return channel.MessagePart{
+			Type:              channel.MessagePartMention,
+			Text:              display,
+			ChannelIdentityID: uid,
+		}, true, true
+	case "code_block":
+		text := stringValue(part["text"])
+		if text == "" {
+			return channel.MessagePart{}, false, false
+		}
+		return channel.MessagePart{
+			Type:     channel.MessagePartCodeBlock,
+			Text:     text,
+			Language: strings.TrimSpace(stringValue(part["language"])),
+		}, true, true
+	default:
+		// Forward-compatible: any future tag carrying a `text` field should
+		// still surface its body so users don't lose content when a styled
+		// element promotes the post to rich (and adaptBody picks Parts over
+		// Text). rich=false keeps this from falsely promoting a plain-only
+		// post on its own.
+		text := stringValue(part["text"])
+		if text == "" {
+			return channel.MessagePart{}, false, false
+		}
+		return channel.MessagePart{Type: channel.MessagePartText, Text: text}, false, true
+	}
+}
+
+func feishuPostStyles(raw any) []channel.MessageTextStyle {
+	arr, ok := raw.([]any)
+	if !ok || len(arr) == 0 {
+		return nil
+	}
+	var styles []channel.MessageTextStyle
+	for _, item := range arr {
+		switch strings.ToLower(strings.TrimSpace(stringValue(item))) {
+		case "bold":
+			styles = append(styles, channel.MessageStyleBold)
+		case "italic":
+			styles = append(styles, channel.MessageStyleItalic)
+		case "linethrough", "strike", "strikethrough":
+			styles = append(styles, channel.MessageStyleStrikethrough)
+		}
+	}
+	return styles
+}

internal/channel/adapters/feishu/inbound_post_parts_test.go

@@ -0,0 +1,186 @@
+package feishu
+
+import (
+	"testing"
+
+	"github.com/memohai/memoh/internal/channel"
+)
+
+func TestExtractFeishuPostParts_StyleArrayIsRespected(t *testing.T) {
+	t.Parallel()
+	content := map[string]any{
+		"content": []any{
+			[]any{
+				map[string]any{"tag": "text", "text": "shout", "style": []any{"bold", "italic"}},
+			},
+		},
+	}
+	parts := extractFeishuPostParts(content)
+	if len(parts) != 1 {
+		t.Fatalf("got %+v", parts)
+	}
+	styles := parts[0].Styles
+	if len(styles) != 2 || styles[0] != channel.MessageStyleBold || styles[1] != channel.MessageStyleItalic {
+		t.Fatalf("expected bold+italic styles, got %+v", styles)
+	}
+}
+
+func TestExtractFeishuPostParts_LineThroughMapsToStrike(t *testing.T) {
+	t.Parallel()
+	content := map[string]any{
+		"content": []any{
+			[]any{
+				map[string]any{"tag": "text", "text": "gone", "style": []any{"lineThrough"}},
+			},
+		},
+	}
+	parts := extractFeishuPostParts(content)
+	if len(parts) != 1 || len(parts[0].Styles) != 1 || parts[0].Styles[0] != channel.MessageStyleStrikethrough {
+		t.Fatalf("expected strikethrough, got %+v", parts)
+	}
+}
+
+func TestExtractFeishuPostParts_LinkTag(t *testing.T) {
+	t.Parallel()
+	content := map[string]any{
+		"content": []any{
+			[]any{
+				map[string]any{"tag": "a", "text": "Memoh", "href": "https://example.com"},
+			},
+		},
+	}
+	parts := extractFeishuPostParts(content)
+	if len(parts) != 1 || parts[0].Type != channel.MessagePartLink {
+		t.Fatalf("expected link part, got %+v", parts)
+	}
+	if parts[0].URL != "https://example.com" || parts[0].Text != "Memoh" {
+		t.Fatalf("link content wrong: %+v", parts[0])
+	}
+}
+
+func TestExtractFeishuPostParts_AtTag(t *testing.T) {
+	t.Parallel()
+	content := map[string]any{
+		"content": []any{
+			[]any{
+				map[string]any{"tag": "at", "user_id": "ou_xyz", "text": "@Alice"},
+			},
+		},
+	}
+	parts := extractFeishuPostParts(content)
+	if len(parts) != 1 || parts[0].Type != channel.MessagePartMention {
+		t.Fatalf("expected mention, got %+v", parts)
+	}
+	if parts[0].ChannelIdentityID != "ou_xyz" || parts[0].Text != "@Alice" {
+		t.Fatalf("mention content wrong: %+v", parts[0])
+	}
+}
+
+func TestExtractFeishuPostParts_CodeBlock(t *testing.T) {
+	t.Parallel()
+	content := map[string]any{
+		"content": []any{
+			[]any{
+				map[string]any{"tag": "code_block", "text": "fn main(){}", "language": "rust"},
+			},
+		},
+	}
+	parts := extractFeishuPostParts(content)
+	if len(parts) != 1 || parts[0].Type != channel.MessagePartCodeBlock {
+		t.Fatalf("expected code_block, got %+v", parts)
+	}
+	if parts[0].Language != "rust" || parts[0].Text != "fn main(){}" {
+		t.Fatalf("code_block content wrong: %+v", parts[0])
+	}
+}
+
+func TestExtractFeishuPostParts_MixedLineBreaksWithNewline(t *testing.T) {
+	t.Parallel()
+	content := map[string]any{
+		"content": []any{
+			[]any{
+				map[string]any{"tag": "text", "text": "line1"},
+			},
+			[]any{
+				map[string]any{"tag": "text", "text": "line2"},
+			},
+		},
+	}
+	parts := extractFeishuPostParts(content)
+	if len(parts) != 3 {
+		t.Fatalf("expected 3 parts (text, newline, text), got %+v", parts)
+	}
+	if parts[0].Text != "line1" {
+		t.Fatalf("part 0 wrong: %+v", parts[0])
+	}
+	if parts[1].Type != channel.MessagePartText || parts[1].Text != "\n" {
+		t.Fatalf("expected newline separator, got %+v", parts[1])
+	}
+	if parts[2].Text != "line2" {
+		t.Fatalf("part 2 wrong: %+v", parts[2])
+	}
+}
+
+func TestExtractFeishuPostParts_KeepsTextFromUnknownTag(t *testing.T) {
+	t.Parallel()
+	// When a styled element promotes the post to "rich", adaptBody picks Parts
+	// over Text. Any text-bearing unknown tag must still surface its body or
+	// the LLM loses that content entirely.
+	content := map[string]any{
+		"content": []any{
+			[]any{
+				map[string]any{"tag": "text", "text": "intro", "style": []any{"bold"}},
+				map[string]any{"tag": "unknown_future_tag", "text": "important detail"},
+			},
+		},
+	}
+	parts := extractFeishuPostParts(content)
+	if len(parts) != 2 {
+		t.Fatalf("expected 2 parts (bold + unknown's text), got %+v", parts)
+	}
+	if parts[1].Type != channel.MessagePartText || parts[1].Text != "important detail" {
+		t.Fatalf("expected unknown tag's text preserved, got %+v", parts[1])
+	}
+}
+
+func TestExtractFeishuPostParts_ImagesAndFilesSkipped(t *testing.T) {
+	t.Parallel()
+	content := map[string]any{
+		"content": []any{
+			[]any{
+				map[string]any{"tag": "text", "text": "see", "style": []any{"bold"}},
+				map[string]any{"tag": "img", "image_key": "img_x"},
+				map[string]any{"tag": "file", "file_key": "f_y"},
+			},
+		},
+	}
+	parts := extractFeishuPostParts(content)
+	if len(parts) != 1 || parts[0].Text != "see" || parts[0].Type != channel.MessagePartText {
+		t.Fatalf("img/file tags should be skipped (extracted as attachments elsewhere), got %+v", parts)
+	}
+}
+
+func TestExtractFeishuPostParts_NoContentReturnsNil(t *testing.T) {
+	t.Parallel()
+	if got := extractFeishuPostParts(nil); got != nil {
+		t.Fatalf("expected nil for nil content, got %+v", got)
+	}
+	if got := extractFeishuPostParts(map[string]any{}); got != nil {
+		t.Fatalf("expected nil for empty content, got %+v", got)
+	}
+}
+
+func TestExtractFeishuPostParts_PlainOnlyReturnsNil(t *testing.T) {
+	t.Parallel()
+	content := map[string]any{
+		"content": []any{
+			[]any{
+				map[string]any{"tag": "text", "text": "just text"},
+			},
+		},
+	}
+	parts := extractFeishuPostParts(content)
+	if parts != nil {
+		t.Fatalf("expected nil when only unstyled plain text (caller falls back to Text), got %+v", parts)
+	}
+}