feed stuff

events.go

···
 	"github.com/jackc/pgx/v5/pgconn"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gorm.io/gorm"
+
+	. "github.com/whyrusleeping/konbini/models"
 )
 
 type PostgresBackend struct {
···
 		Author:  repo.ID,
 		Rkey:    rkey,
 		Did:     rec.Did,
+		Raw:     recb,
 	}).Error; err != nil {
 		return err
 	}

handlers.go

···
 	"github.com/labstack/echo/v4/middleware"
 	"github.com/labstack/gommon/log"
 	"github.com/whyrusleeping/market/models"
+
+	. "github.com/whyrusleeping/konbini/models"
 )
 
 func (s *Server) runApiServer() error {

hydration/hydrator.go

···
 	db  *gorm.DB
 	dir identity.Directory
 
-	missingActorCallback func(string)
-	missingPostCallback  func(string)
+	missingActorCallback         func(string)
+	missingPostCallback          func(string)
+	missingFeedGeneratorCallback func(string)
 }
 
 // NewHydrator creates a new Hydrator
···
 func (h *Hydrator) addMissingActor(did string) {
 	if h.missingActorCallback != nil {
 		h.missingActorCallback(did)
+	}
+}
+
+func (h *Hydrator) SetMissingFeedGeneratorCallback(fn func(string)) {
+	h.missingFeedGeneratorCallback = fn
+}
+
+func (h *Hydrator) AddMissingFeedGenerator(uri string) {
+	if h.missingFeedGeneratorCallback != nil {
+		h.missingFeedGeneratorCallback(uri)
 	}
 }
 

hydration/utils.go

···
+package hydration
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/bluesky-social/indigo/atproto/syntax"
+)
+
+func (h *Hydrator) NormalizeUri(ctx context.Context, uri string) (string, error) {
+	puri, err := syntax.ParseATURI(uri)
+	if err != nil {
+		return "", fmt.Errorf("invalid uri: %w", err)
+	}
+
+	var did string
+	if !puri.Authority().IsDID() {
+		resp, err := h.dir.LookupHandle(ctx, syntax.Handle(puri.Authority().String()))
+		if err != nil {
+			return "", err
+		}
+
+		did = resp.DID.String()
+	} else {
+		did = puri.Authority().String()
+	}
+
+	return fmt.Sprintf("at://%s/%s/%s", did, puri.Collection().String(), puri.RecordKey().String()), nil
+}

main.go

···
 	"github.com/urfave/cli/v2"
 	"github.com/whyrusleeping/konbini/xrpc"
 	"gorm.io/gorm/logger"
+
+	. "github.com/whyrusleeping/konbini/models"
 )
 
 var handleOpHist = promauto.NewHistogramVec(prometheus.HistogramOpts{
···
 			client: cc,
 			dir:    dir,
 
-			missingProfiles: make(chan string, 1024),
-			missingPosts:    make(chan string, 1024),
+			missingProfiles:       make(chan string, 1024),
+			missingPosts:          make(chan string, 1024),
+			missingFeedGenerators: make(chan string, 1024),
 		}
 		fmt.Println("MY DID: ", s.mydid)
 
···
 
 		go s.missingProfileFetcher()
 		go s.missingPostFetcher()
+		go s.missingFeedGeneratorFetcher()
 
 		seqno, err := loadLastSeq(db, "firehose_seq")
 		if err != nil {
···
 	seqLk   sync.Mutex
 	lastSeq int64
 
-	mpLk            sync.Mutex
-	missingProfiles chan string
-	missingPosts    chan string
+	mpLk                  sync.Mutex
+	missingProfiles       chan string
+	missingPosts          chan string
+	missingFeedGenerators chan string
 }
 
 func (s *Server) getXrpcClient() (*xrpclib.Client, error) {

missing.go

···
 
 	return s.backend.HandleCreatePost(ctx, repo, rkey, buf.Bytes(), cc)
 }
+
+func (s *Server) addMissingFeedGenerator(ctx context.Context, uri string) {
+	slog.Info("adding missing feed generator to fetch queue", "uri", uri)
+	select {
+	case s.missingFeedGenerators <- uri:
+	case <-ctx.Done():
+	}
+}
+
+func (s *Server) missingFeedGeneratorFetcher() {
+	for uri := range s.missingFeedGenerators {
+		if err := s.fetchMissingFeedGenerator(context.TODO(), uri); err != nil {
+			log.Warn("failed to fetch missing feed generator", "uri", uri, "error", err)
+		}
+	}
+}
+
+func (s *Server) fetchMissingFeedGenerator(ctx context.Context, uri string) error {
+	// Parse AT URI: at://did:plc:xxx/app.bsky.feed.generator/rkey
+	puri, err := syntax.ParseATURI(uri)
+	if err != nil {
+		return fmt.Errorf("invalid AT URI: %s", uri)
+	}
+
+	did := puri.Authority().String()
+	collection := puri.Collection().String()
+	rkey := puri.RecordKey().String()
+
+	repo, err := s.backend.getOrCreateRepo(ctx, did)
+	if err != nil {
+		return err
+	}
+
+	resp, err := s.dir.LookupDID(ctx, syntax.DID(did))
+	if err != nil {
+		return err
+	}
+
+	c := &xrpclib.Client{
+		Host: resp.PDSEndpoint(),
+	}
+
+	rec, err := atproto.RepoGetRecord(ctx, c, "", collection, did, rkey)
+	if err != nil {
+		return err
+	}
+
+	feedGen, ok := rec.Value.Val.(*bsky.FeedGenerator)
+	if !ok {
+		return fmt.Errorf("record we got back wasn't a feed generator somehow")
+	}
+
+	buf := new(bytes.Buffer)
+	if err := feedGen.MarshalCBOR(buf); err != nil {
+		return err
+	}
+
+	cc, err := cid.Decode(*rec.Cid)
+	if err != nil {
+		return err
+	}
+
+	return s.backend.HandleCreateFeedGenerator(ctx, repo, rkey, buf.Bytes(), cc)
+}

models.go models/models.go

···
-package main
+package models
 
 import (
 	"time"

pgbackend.go

···
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
 	"gorm.io/gorm/logger"
+
+	. "github.com/whyrusleeping/konbini/models"
 )
 
 func (b *PostgresBackend) getOrCreateRepo(ctx context.Context, did string) (*Repo, error) {
···
 func (b *PostgresBackend) TrackMissingActor(did string) {
 	b.s.addMissingProfile(context.TODO(), did)
 }
+
+func (b *PostgresBackend) TrackMissingFeedGenerator(uri string) {
+	b.s.addMissingFeedGenerator(context.TODO(), uri)
+}

seqno.go

···
 import (
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
+
+	. "github.com/whyrusleeping/konbini/models"
 )
 
 func storeLastSeq(db *gorm.DB, key string, seq int64) error {

views/feed.go

···
 package views
 
 import (
+	"fmt"
+
 	"github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/lex/util"
 	"github.com/whyrusleeping/konbini/hydration"
···
 		}
 	}
 
-	// TODO: Add embed handling - need to convert embed types to proper views
-	// if post.Post.Embed != nil {
-	// 	view.Embed = formatEmbed(post.Post.Embed)
-	// }
+	// Add embed handling
+	if post.Post.Embed != nil {
+		view.Embed = formatEmbed(post.Post.Embed, post.Author)
+	}
 
 	return view
 }
···
 }
 
 // ThreadViewPost builds a thread view post (app.bsky.feed.defs#threadViewPost)
-func ThreadViewPost(post *hydration.PostInfo, author *hydration.ActorInfo, parent, replies interface{}) *bsky.FeedDefs_ThreadViewPost {
+func ThreadViewPost(post *hydration.PostInfo, author *hydration.ActorInfo, parent, replies any) *bsky.FeedDefs_ThreadViewPost {
 	view := &bsky.FeedDefs_ThreadViewPost{
 		LexiconTypeID: "app.bsky.feed.defs#threadViewPost",
 		Post:          PostView(post, author),
···
 
 	return view
 }
+
+func formatEmbed(embed *bsky.FeedPost_Embed, authorDID string) *bsky.FeedDefs_PostView_Embed {
+	if embed == nil {
+		return nil
+	}
+
+	result := &bsky.FeedDefs_PostView_Embed{}
+
+	// Handle images
+	if embed.EmbedImages != nil {
+		viewImages := make([]*bsky.EmbedImages_ViewImage, len(embed.EmbedImages.Images))
+		for i, img := range embed.EmbedImages.Images {
+			// Convert blob to CDN URLs
+			fullsize := ""
+			thumb := ""
+			if img.Image != nil {
+				// CDN URL format for feed images
+				cid := img.Image.Ref.String()
+				fullsize = fmt.Sprintf("https://cdn.bsky.app/img/feed_fullsize/plain/%s/%s@jpeg", authorDID, cid)
+				thumb = fmt.Sprintf("https://cdn.bsky.app/img/feed_thumbnail/plain/%s/%s@jpeg", authorDID, cid)
+			}
+
+			viewImages[i] = &bsky.EmbedImages_ViewImage{
+				Alt:         img.Alt,
+				AspectRatio: img.AspectRatio,
+				Fullsize:    fullsize,
+				Thumb:       thumb,
+			}
+		}
+		result.EmbedImages_View = &bsky.EmbedImages_View{
+			LexiconTypeID: "app.bsky.embed.images#view",
+			Images:        viewImages,
+		}
+		return result
+	}
+
+	// Handle external links
+	if embed.EmbedExternal != nil && embed.EmbedExternal.External != nil {
+		// Convert blob thumb to CDN URL if present
+		var thumbURL *string
+		if embed.EmbedExternal.External.Thumb != nil {
+			// CDN URL for external link thumbnails
+			cid := embed.EmbedExternal.External.Thumb.Ref.String()
+			url := fmt.Sprintf("https://cdn.bsky.app/img/feed_thumbnail/plain/%s/%s@jpeg", authorDID, cid)
+			thumbURL = &url
+		}
+
+		result.EmbedExternal_View = &bsky.EmbedExternal_View{
+			LexiconTypeID: "app.bsky.embed.external#view",
+			External: &bsky.EmbedExternal_ViewExternal{
+				Uri:         embed.EmbedExternal.External.Uri,
+				Title:       embed.EmbedExternal.External.Title,
+				Description: embed.EmbedExternal.External.Description,
+				Thumb:       thumbURL,
+			},
+		}
+		return result
+	}
+
+	// Handle video
+	if embed.EmbedVideo != nil {
+		// TODO: Implement video embed view
+		// This would require converting video blob to CDN URLs and playlist URLs
+		return nil
+	}
+
+	// Handle record (quote posts, etc.)
+	if embed.EmbedRecord != nil {
+		// TODO: Implement record embed view
+		// This requires hydrating the embedded record, which is complex
+		// For now, return nil to skip these embeds
+		return nil
+	}
+
+	// Handle record with media (quote post with images/external)
+	if embed.EmbedRecordWithMedia != nil {
+		// TODO: Implement record with media embed view
+		// This combines record hydration with media conversion
+		return nil
+	}
+
+	return nil
+}
+
+// GeneratorView builds a feed generator view (app.bsky.feed.defs#generatorView)
+func GeneratorView(uri, cid string, record *bsky.FeedGenerator, creator *hydration.ActorInfo, likeCount int64, viewerLike string, indexedAt string) *bsky.FeedDefs_GeneratorView {
+	view := &bsky.FeedDefs_GeneratorView{
+		LexiconTypeID: "app.bsky.feed.defs#generatorView",
+		Uri:           uri,
+		Cid:           cid,
+		Did:           record.Did,
+		Creator:       ProfileView(creator),
+		DisplayName:   record.DisplayName,
+		Description:   record.Description,
+		IndexedAt:     indexedAt,
+	}
+
+	// Add optional fields
+	if record.Avatar != nil {
+		avatarURL := fmt.Sprintf("https://cdn.bsky.app/img/avatar/plain/%s/%s@jpeg", creator.DID, record.Avatar.Ref.String())
+		view.Avatar = &avatarURL
+	}
+
+	if record.DescriptionFacets != nil && len(record.DescriptionFacets) > 0 {
+		view.DescriptionFacets = record.DescriptionFacets
+	}
+
+	if record.AcceptsInteractions != nil {
+		view.AcceptsInteractions = record.AcceptsInteractions
+	}
+
+	if record.ContentMode != nil {
+		view.ContentMode = record.ContentMode
+	}
+
+	// Add like count if present
+	if likeCount > 0 {
+		view.LikeCount = &likeCount
+	}
+
+	// Add viewer state if viewer has liked
+	if viewerLike != "" {
+		view.Viewer = &bsky.FeedDefs_GeneratorViewerState{
+			Like: &viewerLike,
+		}
+	}
+
+	return view
+}

xrpc/actor/getProfiles.go

···
 import (
 	"net/http"
 
+	"github.com/bluesky-social/indigo/api/bsky"
 	"github.com/labstack/echo/v4"
 	"github.com/whyrusleeping/konbini/hydration"
 	"github.com/whyrusleeping/konbini/views"
···
 	ctx := c.Request().Context()
 
 	// Resolve all actors to DIDs and hydrate profiles
-	profiles := make([]interface{}, 0)
+	profiles := make([]*bsky.ActorDefs_ProfileViewDetailed, 0, len(actors))
 	for _, actor := range actors {
 		// Resolve actor to DID
 		did, err := hydrator.ResolveDID(ctx, actor)
···
 			// Skip actors that can't be hydrated
 			continue
 		}
-
-		// Get counts for the profile
-		type counts struct {
-			Followers int
-			Follows   int
-			Posts     int
-		}
-		var c counts
-		db.Raw(`
-			SELECT
-				(SELECT COUNT(*) FROM follows WHERE subject = (SELECT id FROM repos WHERE did = ?)) as followers,
-				(SELECT COUNT(*) FROM follows WHERE author = (SELECT id FROM repos WHERE did = ?)) as follows,
-				(SELECT COUNT(*) FROM posts WHERE author = (SELECT id FROM repos WHERE did = ?)) as posts
-		`, did, did, did).Scan(&c)
 
 		profiles = append(profiles, views.ProfileViewDetailed(actorInfo))
 	}

xrpc/feed/getAuthorFeed.go

···
 package feed
 
 import (
+	"context"
+	"log/slog"
 	"net/http"
 	"strconv"
+	"sync"
 	"time"
 
+	"github.com/bluesky-social/indigo/api/bsky"
 	"github.com/labstack/echo/v4"
 	"github.com/whyrusleeping/konbini/hydration"
 	"github.com/whyrusleeping/konbini/views"
 	"gorm.io/gorm"
 )
 
+type postRow struct {
+	URI      string
+	AuthorID uint
+}
+
 // HandleGetAuthorFeed implements app.bsky.feed.getAuthorFeed
 func HandleGetAuthorFeed(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
 	actorParam := c.QueryParam("actor")
 	if actorParam == "" {
-		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+		return c.JSON(http.StatusBadRequest, map[string]any{
 			"error":   "InvalidRequest",
 			"message": "actor parameter is required",
 		})
···
 	// Resolve actor to DID
 	did, err := hydrator.ResolveDID(ctx, actorParam)
 	if err != nil {
-		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+		return c.JSON(http.StatusBadRequest, map[string]any{
 			"error":   "ActorNotFound",
 			"message": "actor not found",
 		})
···
 		`
 	}
 
-	type postRow struct {
-		URI      string
-		AuthorID uint
-	}
 	var rows []postRow
 	if err := db.Raw(query, did, cursor, limit).Scan(&rows).Error; err != nil {
-		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+		return c.JSON(http.StatusInternalServerError, map[string]any{
 			"error":   "InternalError",
 			"message": "failed to query author feed",
 		})
 	}
 
-	// Hydrate posts
-	feed := make([]interface{}, 0)
-	for _, row := range rows {
-		postInfo, err := hydrator.HydratePost(ctx, row.URI, viewer)
-		if err != nil {
-			continue
-		}
-
-		// Hydrate author
-		authorInfo, err := hydrator.HydrateActor(ctx, postInfo.Author)
-		if err != nil {
-			continue
-		}
-
-		feedItem := views.FeedViewPost(postInfo, authorInfo)
-		feed = append(feed, feedItem)
-	}
+	feed := hydratePostRows(ctx, hydrator, viewer, rows)
 
 	// Generate next cursor
 	var nextCursor string
···
 		}
 	}
 
-	return c.JSON(http.StatusOK, map[string]interface{}{
+	return c.JSON(http.StatusOK, map[string]any{
 		"feed":   feed,
 		"cursor": nextCursor,
 	})
 }
+
+func hydratePostRows(ctx context.Context, hydrator *hydration.Hydrator, viewer string, rows []postRow) []*bsky.FeedDefs_FeedViewPost {
+	// Hydrate posts
+	var wg sync.WaitGroup
+
+	var outLk sync.Mutex
+	feed := make([]*bsky.FeedDefs_FeedViewPost, len(rows))
+	for i, row := range rows {
+		wg.Add(1)
+		go func(i int, row postRow) {
+			defer wg.Done()
+
+			postInfo, err := hydrator.HydratePost(ctx, row.URI, viewer)
+			if err != nil {
+				slog.Error("failed to hydrate post", "uri", row.URI, "error", err)
+				return
+			}
+
+			// Hydrate author
+			authorInfo, err := hydrator.HydrateActor(ctx, postInfo.Author)
+			if err != nil {
+				slog.Error("failed to hydrate actor", "actor", postInfo.Author, "error", err)
+				return
+			}
+
+			feedItem := views.FeedViewPost(postInfo, authorInfo)
+			outLk.Lock()
+			feed[i] = feedItem
+			outLk.Unlock()
+		}(i, row)
+	}
+	wg.Wait()
+
+	x := 0
+	for i := 0; i < len(feed); i++ {
+		if feed[i] != nil {
+			feed[x] = feed[i]
+			x++
+			continue
+		}
+	}
+	feed = feed[:x]
+
+	return feed
+}

xrpc/feed/getFeed.go

···
+package feed
+
+import (
+	"bytes"
+	"log/slog"
+	"net/http"
+	"strconv"
+
+	"github.com/bluesky-social/indigo/api/bsky"
+	"github.com/bluesky-social/indigo/atproto/identity"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"github.com/whyrusleeping/konbini/views"
+	"github.com/whyrusleeping/market/models"
+	"gorm.io/gorm"
+)
+
+// HandleGetFeed implements app.bsky.feed.getFeed
+// Gets posts from a custom feed generator
+func HandleGetFeed(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator, dir identity.Directory) error {
+	// Parse parameters
+	feedURI := c.QueryParam("feed")
+	if feedURI == "" {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "InvalidRequest",
+			"message": "feed parameter is required",
+		})
+	}
+
+	// Parse limit
+	limit := int64(50)
+	if limitParam := c.QueryParam("limit"); limitParam != "" {
+		if l, err := strconv.ParseInt(limitParam, 10, 64); err == nil && l > 0 && l <= 100 {
+			limit = l
+		}
+	}
+
+	// Parse cursor
+	cursor := c.QueryParam("cursor")
+
+	ctx := c.Request().Context()
+	viewer := getUserDID(c)
+
+	// Extract feed generator DID and rkey from URI
+	// URI format: at://did:plc:xxx/app.bsky.feed.generator/rkey
+	did := extractDIDFromURI(feedURI)
+	rkey := extractRkeyFromURI(feedURI)
+
+	if did == "" || rkey == "" {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "InvalidRequest",
+			"message": "invalid feed URI format",
+		})
+	}
+
+	// Check if feed generator exists in database
+	var feedGen models.FeedGenerator
+	if err := db.Raw(`
+		SELECT * FROM feed_generators fg WHERE fg.author = (select id from repos where did = ?) AND fg.rkey = ?
+	`, did, rkey).Scan(&feedGen).Error; err != nil {
+		return err
+	}
+
+	if feedGen.ID == 0 {
+		hydrator.AddMissingFeedGenerator(feedURI)
+		return c.JSON(http.StatusNotFound, map[string]interface{}{
+			"error":   "NotFound",
+			"message": "feed generator not found",
+		})
+	}
+
+	// Decode the feed generator record to get the service DID
+	var feedGenRecord bsky.FeedGenerator
+	if err := feedGenRecord.UnmarshalCBOR(bytes.NewReader(feedGen.Raw)); err != nil {
+		slog.Error("failed to decode feed generator record", "error", err)
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"error":   "InternalError",
+			"message": "failed to decode feed generator record",
+		})
+	}
+
+	// Parse the service DID
+	serviceDID, err := syntax.ParseDID(feedGenRecord.Did)
+	if err != nil {
+		slog.Error("invalid service DID in feed generator", "error", err, "did", feedGenRecord.Did)
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"error":   "InternalError",
+			"message": "invalid service DID",
+		})
+	}
+
+	// Resolve the service DID to get its endpoint
+	serviceIdent, err := dir.LookupDID(ctx, serviceDID)
+	if err != nil {
+		slog.Error("failed to resolve service DID", "error", err, "did", serviceDID)
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"error":   "InternalError",
+			"message": "failed to resolve service endpoint",
+		})
+	}
+
+	serviceEndpoint := serviceIdent.GetServiceEndpoint("bsky_fg")
+	if serviceEndpoint == "" {
+		slog.Error("service has no bsky_fg endpoint", "did", serviceDID)
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"error":   "InternalError",
+			"message": "service has no endpoint",
+		})
+	}
+
+	// Create XRPC client for the feed generator service
+	client := &xrpc.Client{
+		Host: serviceEndpoint,
+	}
+
+	// Call getFeedSkeleton on the service
+	skeleton, err := bsky.FeedGetFeedSkeleton(ctx, client, cursor, feedURI, limit)
+	if err != nil {
+		slog.Error("failed to call getFeedSkeleton", "error", err, "service", serviceEndpoint)
+		// Return empty feed on error rather than failing completely
+		return c.JSON(http.StatusOK, &bsky.FeedGetFeed_Output{
+			Feed: make([]*bsky.FeedDefs_FeedViewPost, 0),
+		})
+	}
+
+	// Hydrate the posts from the skeleton
+	posts := make([]*bsky.FeedDefs_FeedViewPost, 0, len(skeleton.Feed))
+	for _, skeletonPost := range skeleton.Feed {
+		postURI, err := syntax.ParseATURI(skeletonPost.Post)
+		if err != nil {
+			slog.Warn("invalid post URI in skeleton", "uri", skeletonPost.Post, "error", err)
+			continue
+		}
+
+		postInfo, err := hydrator.HydratePost(ctx, string(postURI), viewer)
+		if err != nil {
+			slog.Warn("failed to hydrate post", "uri", postURI, "error", err)
+			continue
+		}
+
+		authorInfo, err := hydrator.HydrateActor(ctx, postInfo.Author)
+		if err != nil {
+			slog.Warn("failed to hydrate author", "did", postInfo.Author, "error", err)
+			continue
+		}
+
+		posts = append(posts, views.FeedViewPost(postInfo, authorInfo))
+	}
+
+	output := &bsky.FeedGetFeed_Output{
+		Feed:   posts,
+		Cursor: skeleton.Cursor,
+	}
+
+	return c.JSON(http.StatusOK, output)
+}

xrpc/feed/getFeedGenerator.go

···
+package feed
+
+import (
+	"bytes"
+	"log/slog"
+	"net/http"
+	"time"
+
+	"github.com/bluesky-social/indigo/api/bsky"
+	"github.com/bluesky-social/indigo/atproto/identity"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	cid "github.com/ipfs/go-cid"
+	"github.com/labstack/echo/v4"
+	mh "github.com/multiformats/go-multihash"
+	"github.com/whyrusleeping/konbini/hydration"
+	"github.com/whyrusleeping/konbini/views"
+	"gorm.io/gorm"
+)
+
+// HandleGetFeedGenerator implements app.bsky.feed.getFeedGenerator
+func HandleGetFeedGenerator(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator, dir identity.Directory) error {
+	ctx := c.Request().Context()
+
+	// Parse parameters
+	feedURI := c.QueryParam("feed")
+	if feedURI == "" {
+		return c.JSON(http.StatusBadRequest, map[string]any{
+			"error":   "InvalidRequest",
+			"message": "feed parameter is required",
+		})
+	}
+
+	nu, err := hydrator.NormalizeUri(ctx, feedURI)
+	if err != nil {
+		return err
+	}
+	feedURI = nu
+
+	viewer := getUserDID(c)
+	_ = viewer
+
+	// Extract feed generator DID and rkey from URI
+	did := extractDIDFromURI(feedURI)
+	rkey := extractRkeyFromURI(feedURI)
+
+	if did == "" || rkey == "" {
+		return c.JSON(http.StatusBadRequest, map[string]any{
+			"error":   "InvalidRequest",
+			"message": "invalid feed URI format",
+		})
+	}
+
+	// Query feed generator from database
+	type feedGenRow struct {
+		ID        uint
+		Did       string
+		Raw       []byte
+		AuthorDid string
+		Indexed   time.Time
+	}
+	var feedGen feedGenRow
+	err = db.Raw(`
+		SELECT fg.id, fg.did, fg.raw, r.did as author_did, indexed
+		FROM feed_generators fg
+		JOIN repos r ON r.id = fg.author
+		WHERE r.did = ? AND fg.rkey = ?
+	`, did, rkey).Scan(&feedGen).Error
+
+	if err != nil || feedGen.ID == 0 {
+		// Track this missing feed generator for fetching
+		hydrator.AddMissingFeedGenerator(feedURI)
+
+		return c.JSON(http.StatusNotFound, map[string]any{
+			"error":   "NotFound",
+			"message": "feed generator not found",
+		})
+	}
+
+	// Decode the feed generator record
+	var feedGenRecord bsky.FeedGenerator
+	if err := feedGenRecord.UnmarshalCBOR(bytes.NewReader(feedGen.Raw)); err != nil {
+		slog.Error("failed to decode feed generator record", "error", err)
+		return c.JSON(http.StatusInternalServerError, map[string]any{
+			"error":   "InternalError",
+			"message": "failed to decode feed generator record",
+		})
+	}
+
+	// Compute CID from raw bytes
+	hash, err := mh.Sum(feedGen.Raw, mh.SHA2_256, -1)
+	if err != nil {
+		slog.Error("failed to hash record", "error", err)
+		return c.JSON(http.StatusInternalServerError, map[string]any{
+			"error":   "InternalError",
+			"message": "failed to compute CID",
+		})
+	}
+	recordCid := cid.NewCidV1(cid.DagCBOR, hash).String()
+
+	// Hydrate the creator
+	creatorInfo, err := hydrator.HydrateActor(ctx, feedGen.AuthorDid)
+	if err != nil {
+		slog.Error("failed to hydrate creator", "error", err, "did", feedGen.AuthorDid)
+		return c.JSON(http.StatusInternalServerError, map[string]any{
+			"error":   "InternalError",
+			"message": "failed to hydrate creator",
+		})
+	}
+
+	// Count likes for this feed generator
+	var likeCount int64
+
+	// Check if viewer has liked this feed generator
+	viewerLike := ""
+
+	// Validate the service DID (check if it's resolvable)
+	serviceDID, err := syntax.ParseDID(feedGenRecord.Did)
+	if err != nil {
+		slog.Error("invalid service DID in feed generator", "error", err, "did", feedGenRecord.Did)
+		return c.JSON(http.StatusInternalServerError, map[string]any{
+			"error":   "InternalError",
+			"message": "invalid service DID",
+		})
+	}
+
+	// Try to resolve the service DID to check if it's online/valid
+	isOnline := true
+	isValid := true
+	serviceIdent, err := dir.LookupDID(ctx, serviceDID)
+	if err != nil {
+		slog.Warn("failed to resolve service DID", "error", err, "did", serviceDID)
+		isOnline = false
+		isValid = false
+	} else {
+		// Check if service has an endpoint
+		serviceEndpoint := serviceIdent.PDSEndpoint()
+		if serviceEndpoint == "" {
+			slog.Warn("service has no PDS endpoint", "did", serviceDID)
+			isValid = false
+		}
+	}
+
+	// Build the generator view
+	generatorView := views.GeneratorView(
+		feedURI,
+		recordCid,
+		&feedGenRecord,
+		creatorInfo,
+		likeCount,
+		viewerLike,
+		feedGen.Indexed.Format(time.RFC3339),
+	)
+
+	output := &bsky.FeedGetFeedGenerator_Output{
+		View:     generatorView,
+		IsOnline: isOnline,
+		IsValid:  isValid,
+	}
+
+	return c.JSON(http.StatusOK, output)
+}

xrpc/feed/getTimeline.go

···
 package feed
 
 import (
-	"log/slog"
 	"net/http"
 	"strconv"
 	"time"
 
 	"github.com/labstack/echo/v4"
 	"github.com/whyrusleeping/konbini/hydration"
-	"github.com/whyrusleeping/konbini/views"
 	"gorm.io/gorm"
 )
 
···
 func HandleGetTimeline(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
 	viewer := getUserDID(c)
 	if viewer == "" {
-		return c.JSON(http.StatusUnauthorized, map[string]interface{}{
+		return c.JSON(http.StatusUnauthorized, map[string]any{
 			"error":   "AuthenticationRequired",
 			"message": "authentication required",
 		})
···
 	// Get viewer's repo ID
 	var viewerRepoID uint
 	if err := db.Raw("SELECT id FROM repos WHERE did = ?", viewer).Scan(&viewerRepoID).Error; err != nil {
-		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+		return c.JSON(http.StatusInternalServerError, map[string]any{
 			"error":   "InternalError",
 			"message": "failed to load viewer",
 		})
 	}
 
 	// Query posts from followed users
-	type postRow struct {
-		URI      string
-		AuthorID uint
-	}
 	var rows []postRow
 	err := db.Raw(`
 		SELECT
···
 	`, viewerRepoID, cursor, limit).Scan(&rows).Error
 
 	if err != nil {
-		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+		return c.JSON(http.StatusInternalServerError, map[string]any{
 			"error":   "InternalError",
 			"message": "failed to query timeline",
 		})
 	}
 
 	// Hydrate posts
-	feed := make([]interface{}, 0)
-	for _, row := range rows {
-		postInfo, err := hydrator.HydratePost(ctx, row.URI, viewer)
-		if err != nil {
-			continue
-		}
-
-		// Hydrate author
-		authorInfo, err := hydrator.HydrateActor(ctx, postInfo.Author)
-		if err != nil {
-			slog.Error("failed to hydrate actor", "author", postInfo.Author, "error", err)
-			continue
-		}
-
-		feedItem := views.FeedViewPost(postInfo, authorInfo)
-		feed = append(feed, feedItem)
-	}
+	feed := hydratePostRows(ctx, hydrator, viewer, rows)
 
 	// Generate next cursor
 	var nextCursor string
···
 		}
 	}
 
-	return c.JSON(http.StatusOK, map[string]interface{}{
+	return c.JSON(http.StatusOK, map[string]any{
 		"feed":   feed,
 		"cursor": nextCursor,
 	})

xrpc/notification/listNotifications.go

···
 package notification
 
 import (
+	"bytes"
+	"fmt"
 	"net/http"
 	"strconv"
+	"time"
 
+	"github.com/bluesky-social/indigo/api/atproto"
+	"github.com/bluesky-social/indigo/api/bsky"
+	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 	"github.com/labstack/echo/v4"
 	"github.com/whyrusleeping/konbini/hydration"
 	"github.com/whyrusleeping/konbini/views"
+	"github.com/whyrusleeping/market/models"
 	"gorm.io/gorm"
 )
 
···
 	}
 
 	// Hydrate notifications
-	notifications := make([]interface{}, 0)
+	notifications := make([]*bsky.NotificationListNotifications_Notification, 0)
 	for _, row := range rows {
 		authorInfo, err := hydrator.HydrateActor(ctx, row.AuthorDid)
 		if err != nil {
 			continue
 		}
 
-		notif := map[string]interface{}{
-			"uri":       row.Source,
-			"author":    views.ProfileView(authorInfo),
-			"reason":    mapNotifKind(row.Kind),
-			"record":    nil, // Could hydrate the source record here
-			"isRead":    false,
-			"indexedAt": row.CreatedAt,
-			"labels":    []interface{}{},
+		// Skip notifications without CIDs as they're invalid
+		if row.SourceCid == "" {
+			continue
 		}
 
-		// Only include CID if we have one (required field)
-		if row.SourceCid != "" {
-			notif["cid"] = row.SourceCid
-		} else {
-			// Skip notifications without CIDs as they're invalid
+		// Fetch and decode the raw record
+		recordDecoder, err := fetchNotificationRecord(db, row.Source, row.Kind)
+		if err != nil {
 			continue
 		}
 
+		notif := &bsky.NotificationListNotifications_Notification{
+			Uri:       row.Source,
+			Cid:       row.SourceCid,
+			Author:    views.ProfileView(authorInfo),
+			Reason:    mapNotifKind(row.Kind),
+			Record:    recordDecoder,
+			IsRead:    false,
+			IndexedAt: row.CreatedAt,
+		}
+
 		notifications = append(notifications, notif)
 	}
 
 	// Generate next cursor
-	var nextCursor string
+	var cursorPtr *string
 	if len(rows) > 0 {
-		nextCursor = strconv.FormatUint(uint64(rows[len(rows)-1].ID), 10)
+		cursor := strconv.FormatUint(uint64(rows[len(rows)-1].ID), 10)
+		cursorPtr = &cursor
+	}
+
+	output := &bsky.NotificationListNotifications_Output{
+		Notifications: notifications,
+		Cursor:        cursorPtr,
 	}
 
-	return c.JSON(http.StatusOK, map[string]interface{}{
-		"notifications": notifications,
-		"cursor":        nextCursor,
-	})
+	return c.JSON(http.StatusOK, output)
 }
 
 // HandleGetUnreadCount implements app.bsky.notification.getUnreadCount
···
 		return "repost"
 	case "mention":
 		return "mention"
+	case "follow":
+		return "follow"
 	default:
 		return kind
 	}
 }
+
+// fetchNotificationRecord fetches and decodes the raw record for a notification
+func fetchNotificationRecord(db *gorm.DB, sourceURI string, kind string) (*util.LexiconTypeDecoder, error) {
+	// Parse the source URI to extract DID and rkey
+	// URI format: at://did:plc:xxx/collection/rkey
+	did := extractDIDFromURI(sourceURI)
+	rkey := extractRkeyFromURI(sourceURI)
+
+	if did == "" || rkey == "" {
+		return nil, fmt.Errorf("invalid source URI")
+	}
+
+	var raw []byte
+	var err error
+
+	// Fetch raw data based on notification kind
+	switch kind {
+	case "reply", "mention", "quote":
+		// These reference posts
+		err = db.Raw(`
+			SELECT p.raw
+			FROM posts p
+			JOIN repos r ON r.id = p.author
+			WHERE r.did = ? AND p.rkey = ?
+		`, did, rkey).Scan(&raw).Error
+
+	case "like":
+		// we don't store the raw like objects, so we just reconstruct it here...
+		// These reference like records
+		var like models.Like
+		err = db.Raw(`
+			SELECT *
+			FROM likes l
+			JOIN repos r ON r.id = l.author
+			WHERE r.did = ? AND l.rkey = ?
+		`, did, rkey).Scan(&like).Error
+
+		lk := bsky.FeedLike{
+			CreatedAt: like.Created.Format(time.RFC3339),
+			Subject: &atproto.RepoStrongRef{
+				Cid: "",
+				Uri: "",
+			},
+		}
+		buf := new(bytes.Buffer)
+		if err := lk.MarshalCBOR(buf); err != nil {
+			return nil, fmt.Errorf("failed to marshal reconstructed like: %w", err)
+		}
+		raw = buf.Bytes()
+
+	case "repost":
+		// These reference repost records
+		err = db.Raw(`
+			SELECT r.raw
+			FROM reposts r
+			JOIN repos repo ON repo.id = r.author
+			WHERE repo.did = ? AND r.rkey = ?
+		`, did, rkey).Scan(&raw).Error
+
+	case "follow":
+		// These reference follow records
+		err = db.Raw(`
+			SELECT f.raw
+			FROM follows f
+			JOIN repos r ON r.id = f.author
+			WHERE r.did = ? AND f.rkey = ?
+		`, did, rkey).Scan(&raw).Error
+
+	default:
+		return nil, fmt.Errorf("unknown notification kind: %s", kind)
+	}
+
+	if err != nil || len(raw) == 0 {
+		return nil, fmt.Errorf("failed to fetch record: %w", err)
+	}
+
+	// Decode the CBOR data
+	decoded, err := lexutil.CborDecodeValue(raw)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode CBOR: %w", err)
+	}
+
+	return &util.LexiconTypeDecoder{
+		Val: decoded,
+	}, nil
+}
+
+func extractDIDFromURI(uri string) string {
+	// URI format: at://did:plc:xxx/collection/rkey
+	if len(uri) < 5 || uri[:5] != "at://" {
+		return ""
+	}
+	parts := []rune(uri[5:])
+	for i, r := range parts {
+		if r == '/' {
+			return string(parts[:i])
+		}
+	}
+	return string(parts)
+}
+
+func extractRkeyFromURI(uri string) string {
+	// URI format: at://did:plc:xxx/collection/rkey
+	if len(uri) < 5 || uri[:5] != "at://" {
+		return ""
+	}
+	// Find last slash
+	for i := len(uri) - 1; i >= 5; i-- {
+		if uri[i] == '/' {
+			return uri[i+1:]
+		}
+	}
+	return ""
+}

xrpc/server.go

···
 	// Add methods as needed for data access
 
 	TrackMissingActor(did string)
+	TrackMissingFeedGenerator(uri string)
 }
 
 // NewServer creates a new XRPC server
···
 	}
 
 	s.hydrator.SetMissingActorCallback(backend.TrackMissingActor)
+	s.hydrator.SetMissingFeedGeneratorCallback(backend.TrackMissingFeedGenerator)
 
 	// Register XRPC endpoints
 	s.registerEndpoints()
···
 	xrpcGroup.GET("/app.bsky.feed.getActorLikes", func(c echo.Context) error {
 		return feed.HandleGetActorLikes(c, s.db, s.hydrator)
 	}, s.requireAuth)
+	xrpcGroup.GET("/app.bsky.feed.getFeed", func(c echo.Context) error {
+		return feed.HandleGetFeed(c, s.db, s.hydrator, s.dir)
+	})
+	xrpcGroup.GET("/app.bsky.feed.getFeedGenerator", func(c echo.Context) error {
+		return feed.HandleGetFeedGenerator(c, s.db, s.hydrator, s.dir)
+	})
 
 	// app.bsky.graph.*
 	xrpcGroup.GET("/app.bsky.graph.getFollows", func(c echo.Context) error {
···
 	})
 	xrpcGroup.GET("/app.bsky.unspecced.getTrendingTopics", func(c echo.Context) error {
 		return unspecced.HandleGetTrendingTopics(c)
+	})
+	xrpcGroup.GET("/app.bsky.unspecced.getPostThreadV2", func(c echo.Context) error {
+		return unspecced.HandleGetPostThreadV2(c, s.db, s.hydrator)
 	})
 }
 

xrpc/unspecced/getPostThreadV2.go

···
+package unspecced
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"strconv"
+
+	"github.com/bluesky-social/indigo/api/bsky"
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"github.com/whyrusleeping/konbini/views"
+	"gorm.io/gorm"
+)
+
+// HandleGetPostThreadV2 implements app.bsky.unspecced.getPostThreadV2
+func HandleGetPostThreadV2(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	ctx := c.Request().Context()
+
+	// Parse parameters
+	anchorRaw := c.QueryParam("anchor")
+	if anchorRaw == "" {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "InvalidRequest",
+			"message": "anchor parameter is required",
+		})
+	}
+
+	anchorUri, err := hydrator.NormalizeUri(ctx, anchorRaw)
+	if err != nil {
+		return err
+	}
+
+	// Parse optional parameters with defaults
+	above := c.QueryParam("above") != "false" // default true
+
+	below := int64(6) // default
+	if belowParam := c.QueryParam("below"); belowParam != "" {
+		if b, err := strconv.ParseInt(belowParam, 10, 64); err == nil && b >= 0 && b <= 20 {
+			below = b
+		}
+	}
+
+	branchingFactor := int64(10) // default
+	if bfParam := c.QueryParam("branchingFactor"); bfParam != "" {
+		if bf, err := strconv.ParseInt(bfParam, 10, 64); err == nil && bf > 0 {
+			branchingFactor = bf
+		}
+	}
+
+	_ = c.QueryParam("prioritizeFollowedUsers") == "true" // TODO: implement prioritization
+
+	sort := c.QueryParam("sort")
+	if sort == "" {
+		sort = "newest"
+	}
+
+	viewer := getUserDID(c)
+
+	// Hydrate the anchor post
+	anchorPostInfo, err := hydrator.HydratePost(ctx, anchorUri, viewer)
+	if err != nil {
+		slog.Error("failed to hydrate post", "error", err, "anchor", anchorUri)
+		return c.JSON(http.StatusNotFound, map[string]interface{}{
+			"error":   "NotFound",
+			"message": "anchor post not found",
+		})
+	}
+
+	// Determine the root post ID for the thread
+	rootPostID := anchorPostInfo.InThread
+	if rootPostID == 0 {
+		// This post is the root - get its ID
+		var postID uint
+		db.Raw(`
+			SELECT id FROM posts
+			WHERE author = (SELECT id FROM repos WHERE did = ?)
+			AND rkey = ?
+		`, extractDIDFromURI(anchorUri), extractRkeyFromURI(anchorUri)).Scan(&postID)
+		rootPostID = postID
+	}
+
+	// Query all posts in this thread
+	type threadPostRow struct {
+		ID        uint
+		Rkey      string
+		ReplyTo   uint
+		InThread  uint
+		AuthorDid string
+	}
+	var threadPosts []threadPostRow
+	db.Raw(`
+		SELECT p.id, p.rkey, p.reply_to, p.in_thread, r.did as author_did
+		FROM posts p
+		JOIN repos r ON r.id = p.author
+		WHERE (p.id = ? OR p.in_thread = ?)
+		AND p.not_found = false
+		ORDER BY p.created ASC
+	`, rootPostID, rootPostID).Scan(&threadPosts)
+
+	// Build a map of posts by ID
+	postsByID := make(map[uint]*threadNode)
+	for _, tp := range threadPosts {
+		uri := fmt.Sprintf("at://%s/app.bsky.feed.post/%s", tp.AuthorDid, tp.Rkey)
+		postsByID[tp.ID] = &threadNode{
+			id:       tp.ID,
+			uri:      uri,
+			replyTo:  tp.ReplyTo,
+			inThread: tp.InThread,
+			children: []*threadNode{},
+		}
+	}
+
+	// Build parent-child relationships
+	for _, node := range postsByID {
+		if node.replyTo != 0 {
+			parent := postsByID[node.replyTo]
+			if parent != nil {
+				parent.children = append(parent.children, node)
+			}
+		}
+	}
+
+	// Find the anchor node
+	anchorID := uint(0)
+	for id, node := range postsByID {
+		if node.uri == anchorUri {
+			anchorID = id
+			break
+		}
+	}
+
+	if anchorID == 0 {
+		return c.JSON(http.StatusNotFound, map[string]interface{}{
+			"error":   "NotFound",
+			"message": "anchor post not found in thread",
+		})
+	}
+
+	anchorNode := postsByID[anchorID]
+
+	// Build flat thread items list
+	var threadItems []*bsky.UnspeccedGetPostThreadV2_ThreadItem
+	hasOtherReplies := false
+
+	// Add parents if requested
+	if above {
+		parents := collectParents(anchorNode, postsByID)
+		for i := len(parents) - 1; i >= 0; i-- {
+			depth := int64(-(len(parents) - i))
+			item := buildThreadItem(ctx, hydrator, parents[i], depth, viewer)
+			if item != nil {
+				threadItems = append(threadItems, item)
+			}
+		}
+	}
+
+	// Add anchor post (depth 0)
+	anchorItem := buildThreadItem(ctx, hydrator, anchorNode, 0, viewer)
+	if anchorItem != nil {
+		threadItems = append(threadItems, anchorItem)
+	}
+
+	// Add replies below anchor
+	if below > 0 {
+		replies, hasMore := collectReplies(ctx, hydrator, anchorNode, 1, below, branchingFactor, sort, viewer)
+		threadItems = append(threadItems, replies...)
+		hasOtherReplies = hasMore
+	}
+
+	return c.JSON(http.StatusOK, &bsky.UnspeccedGetPostThreadV2_Output{
+		Thread:          threadItems,
+		HasOtherReplies: hasOtherReplies,
+	})
+}
+
+type threadNode struct {
+	id       uint
+	uri      string
+	replyTo  uint
+	inThread uint
+	children []*threadNode
+}
+
+func collectParents(node *threadNode, allNodes map[uint]*threadNode) []*threadNode {
+	var parents []*threadNode
+	current := node
+	for current.replyTo != 0 {
+		parent := allNodes[current.replyTo]
+		if parent == nil {
+			break
+		}
+		parents = append(parents, parent)
+		current = parent
+	}
+	return parents
+}
+
+func collectReplies(ctx context.Context, hydrator *hydration.Hydrator, node *threadNode, currentDepth, maxDepth, branchingFactor int64, sort string, viewer string) ([]*bsky.UnspeccedGetPostThreadV2_ThreadItem, bool) {
+	var items []*bsky.UnspeccedGetPostThreadV2_ThreadItem
+	hasMore := false
+
+	if currentDepth > maxDepth {
+		return items, false
+	}
+
+	// Sort children based on sort parameter
+	children := node.children
+	// TODO: Actually sort based on the sort parameter (newest/oldest/top)
+	// For now, just use the order we have
+
+	// Limit to branchingFactor
+	limit := int(branchingFactor)
+	if len(children) > limit {
+		hasMore = true
+		children = children[:limit]
+	}
+
+	for _, child := range children {
+		item := buildThreadItem(ctx, hydrator, child, currentDepth, viewer)
+		if item != nil {
+			items = append(items, item)
+
+			// Recursively collect replies
+			if currentDepth < maxDepth {
+				childReplies, childHasMore := collectReplies(ctx, hydrator, child, currentDepth+1, maxDepth, branchingFactor, sort, viewer)
+				items = append(items, childReplies...)
+				if childHasMore {
+					hasMore = true
+				}
+			}
+		}
+	}
+
+	return items, hasMore
+}
+
+func buildThreadItem(ctx context.Context, hydrator *hydration.Hydrator, node *threadNode, depth int64, viewer string) *bsky.UnspeccedGetPostThreadV2_ThreadItem {
+	// Hydrate the post
+	postInfo, err := hydrator.HydratePost(ctx, node.uri, viewer)
+	if err != nil {
+		// Return not found item
+		return &bsky.UnspeccedGetPostThreadV2_ThreadItem{
+			Depth: depth,
+			Uri:   node.uri,
+			Value: &bsky.UnspeccedGetPostThreadV2_ThreadItem_Value{
+				UnspeccedDefs_ThreadItemNotFound: &bsky.UnspeccedDefs_ThreadItemNotFound{
+					LexiconTypeID: "app.bsky.unspecced.defs#threadItemNotFound",
+				},
+			},
+		}
+	}
+
+	// Hydrate author
+	authorInfo, err := hydrator.HydrateActor(ctx, postInfo.Author)
+	if err != nil {
+		return &bsky.UnspeccedGetPostThreadV2_ThreadItem{
+			Depth: depth,
+			Uri:   node.uri,
+			Value: &bsky.UnspeccedGetPostThreadV2_ThreadItem_Value{
+				UnspeccedDefs_ThreadItemNotFound: &bsky.UnspeccedDefs_ThreadItemNotFound{
+					LexiconTypeID: "app.bsky.unspecced.defs#threadItemNotFound",
+				},
+			},
+		}
+	}
+
+	// Build post view
+	postView := views.PostView(postInfo, authorInfo)
+
+	// Calculate moreReplies count
+	moreReplies := int64(0)
+	if len(node.children) > 0 {
+		// This is a simplified calculation - actual count would need more complex logic
+		moreReplies = int64(len(node.children))
+	}
+
+	return &bsky.UnspeccedGetPostThreadV2_ThreadItem{
+		Depth: depth,
+		Uri:   node.uri,
+		Value: &bsky.UnspeccedGetPostThreadV2_ThreadItem_Value{
+			UnspeccedDefs_ThreadItemPost: &bsky.UnspeccedDefs_ThreadItemPost{
+				LexiconTypeID:      "app.bsky.unspecced.defs#threadItemPost",
+				Post:               postView,
+				HiddenByThreadgate: false,
+				MoreParents:        false,
+				MoreReplies:        moreReplies,
+				MutedByViewer:      false,
+				OpThread:           false, // TODO: Calculate this properly
+			},
+		},
+	}
+}
+
+func getUserDID(c echo.Context) string {
+	did := c.Get("viewer")
+	if did == nil {
+		return ""
+	}
+	if s, ok := did.(string); ok {
+		return s
+	}
+	return ""
+}
+
+func extractDIDFromURI(uri string) string {
+	// URI format: at://did:plc:xxx/collection/rkey
+	if len(uri) < 5 || uri[:5] != "at://" {
+		return ""
+	}
+	parts := []rune(uri[5:])
+	for i, r := range parts {
+		if r == '/' {
+			return string(parts[:i])
+		}
+	}
+	return string(parts)
+}
+
+func extractRkeyFromURI(uri string) string {
+	// URI format: at://did:plc:xxx/collection/rkey
+	if len(uri) < 5 || uri[:5] != "at://" {
+		return ""
+	}
+	// Find last slash
+	for i := len(uri) - 1; i >= 5; i-- {
+		if uri[i] == '/' {
+			return uri[i+1:]
+		}
+	}
+	return ""
+}