refactor(memory): introduce LLM interface for testability

Replaces concrete *provider.Router with LLM interface in Extract
and Reconcile. Adds RouterLLM adapter. Enables mock-based testing.

Author: priyanshujain

internal/cli/memory/extract.go

@@ -70,16 +70,16 @@ var extractCmd = &cobra.Command{
 			return fmt.Errorf("migrate memory: %w", err)
 		}
 
-		// Create provider router.
-		router, err := buildRouter(cfg)
+		// Create LLM client.
+		llm, err := buildLLM(cfg)
 		if err != nil {
-			return fmt.Errorf("build router: %w", err)
+			return fmt.Errorf("build LLM: %w", err)
 		}
 
 		ctx := context.Background()
 
 		// Extract candidate facts.
-		candidates, err := memory.Extract(ctx, router, messages)
+		candidates, err := memory.Extract(ctx, llm, messages)
 		if err != nil {
 			return fmt.Errorf("extract: %w", err)
 		}
@@ -90,7 +90,7 @@ var extractCmd = &cobra.Command{
 		}
 
 		// Reconcile with existing memories.
-		result, err := memory.Reconcile(ctx, memDB, router, candidates)
+		result, err := memory.Reconcile(ctx, memDB, llm, candidates)
 		if err != nil {
 			return fmt.Errorf("reconcile: %w", err)
 		}
@@ -130,12 +130,13 @@ func loadRecentMessages(db *store.DB, lastN int) ([]string, error) {
 	return messages, rows.Err()
 }
 
-func buildRouter(cfg *config.Config) (*provider.Router, error) {
+func buildLLM(cfg *config.Config) (memory.LLM, error) {
 	registry, err := provider.NewRegistry(cfg.Models)
 	if err != nil {
 		return nil, fmt.Errorf("create provider registry: %w", err)
 	}
-	return provider.NewRouter(registry, cfg.Models), nil
+	router := provider.NewRouter(registry, cfg.Models)
+	return &memory.RouterLLM{Router: router, Tier: provider.TierFast}, nil
 }
 
 func init() {

memory/extract.go

@@ -32,7 +32,7 @@ type ExtractResult struct {
 	Skipped int
 }
 
-func Extract(ctx context.Context, router *provider.Router, messages []string) ([]CandidateFact, error) {
+func Extract(ctx context.Context, llm LLM, messages []string) ([]CandidateFact, error) {
 	filtered := preFilter(messages)
 	if len(filtered) == 0 {
 		return nil, nil
@@ -48,7 +48,7 @@ func Extract(ctx context.Context, router *provider.Router, messages []string) ([
 		MaxTokens: 2048,
 	}
 
-	resp, err := router.Chat(ctx, provider.TierFast, req)
+	resp, err := llm.Chat(ctx, req)
 	if err != nil {
 		return nil, fmt.Errorf("extraction LLM call: %w", err)
 	}

memory/reconcile.go

@@ -29,7 +29,7 @@ type reconcileDecision struct {
 	Content string `json:"content"`
 }
 
-func Reconcile(ctx context.Context, db *store.DB, router *provider.Router, candidates []CandidateFact) (*ExtractResult, error) {
+func Reconcile(ctx context.Context, db *store.DB, llm LLM, candidates []CandidateFact) (*ExtractResult, error) {
 	result := &ExtractResult{}
 
 	for _, candidate := range candidates {
@@ -52,7 +52,7 @@ func Reconcile(ctx context.Context, db *store.DB, router *provider.Router, candi
 			continue
 		}
 
-		decision, err := reconcileWithLLM(ctx, router, existing, candidate)
+		decision, err := reconcileWithLLM(ctx, llm, existing, candidate)
 		if err != nil {
 			result.Skipped++
 			continue
@@ -87,7 +87,7 @@ func Reconcile(ctx context.Context, db *store.DB, router *provider.Router, candi
 	return result, nil
 }
 
-func reconcileWithLLM(ctx context.Context, router *provider.Router, existing []Memory, candidate CandidateFact) (*reconcileDecision, error) {
+func reconcileWithLLM(ctx context.Context, llm LLM, existing []Memory, candidate CandidateFact) (*reconcileDecision, error) {
 	var existingLines []string
 	for _, m := range existing {
 		existingLines = append(existingLines, fmt.Sprintf("[ID=%d] %s", m.ID, m.Content))
@@ -103,7 +103,7 @@ func reconcileWithLLM(ctx context.Context, router *provider.Router, existing []M
 		MaxTokens: 256,
 	}
 
-	resp, err := router.Chat(ctx, provider.TierFast, req)
+	resp, err := llm.Chat(ctx, req)
 	if err != nil {
 		return nil, fmt.Errorf("reconciliation LLM call: %w", err)
 	}

memory/types.go

@@ -1,6 +1,27 @@
 package memory
 
-import "time"
+import (
+	"context"
+	"time"
+
+	"github.com/priyanshujain/openbotkit/provider"
+)
+
+// LLM is the interface used by Extract and Reconcile for LLM calls.
+// Satisfied by RouterLLM adapter or any mock in tests.
+type LLM interface {
+	Chat(ctx context.Context, req provider.ChatRequest) (*provider.ChatResponse, error)
+}
+
+// RouterLLM adapts a provider.Router to the LLM interface using a fixed tier.
+type RouterLLM struct {
+	Router *provider.Router
+	Tier   provider.ModelTier
+}
+
+func (r *RouterLLM) Chat(ctx context.Context, req provider.ChatRequest) (*provider.ChatResponse, error) {
+	return r.Router.Chat(ctx, r.Tier, req)
+}
 
 type Category string