feat(agent): enhance message consolidation and context management

- Improved the message consolidation logic to preserve the current turn's user query and all subsequent assistant/tool messages, ensuring better context retention.
- Updated the CompressContext function to reflect the new consolidation strategy, maintaining the system prompt and relevant recent messages.
- Refactored the context manager to support optional message repository for improved context rebuilding from persistent storage.
- Added comprehensive tests to validate the new consolidation behavior and ensure correct message handling across various scenarios.
This commit is contained in:
wizardchen
2026-03-24 17:32:24 +08:00
committed by lyingbug
parent b980d4619d
commit a8924e301e
11 changed files with 662 additions and 535 deletions
@@ -1,258 +0,0 @@
package llmcontext
import (
"context"
"fmt"
"strings"
"unicode"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/models/chat"
"github.com/Tencent/WeKnora/internal/types/interfaces"
)
// estimateStringTokens provides a more accurate token estimation by distinguishing
// CJK characters (≈1.5 tokens each) from Latin characters (≈4 chars per token).
// This is significantly more accurate than the naive totalChars/4 approach,
// especially for mixed Chinese-English content common in WeKnora.
func estimateStringTokens(s string) int {
cjkChars := 0
otherChars := 0
for _, r := range s {
if unicode.Is(unicode.Han, r) || unicode.Is(unicode.Hangul, r) || unicode.Is(unicode.Katakana, r) || unicode.Is(unicode.Hiragana, r) {
cjkChars++
} else {
otherChars++
}
}
// CJK characters average ~1.5 tokens each; Latin ~0.25 tokens per char
return (cjkChars*3 + otherChars) / 2
}
// estimateMessageTokens estimates the token count for a list of messages.
// Accounts for per-message overhead (role markers, special tokens) and tool call metadata.
func estimateMessageTokens(messages []chat.Message) int {
totalTokens := 0
for _, msg := range messages {
totalTokens += estimateStringTokens(msg.Role) + estimateStringTokens(msg.Content)
// Per-message overhead: role markers, delimiters, special tokens
totalTokens += 4
if len(msg.ToolCalls) > 0 {
for _, tc := range msg.ToolCalls {
totalTokens += estimateStringTokens(tc.Function.Name) + estimateStringTokens(tc.Function.Arguments)
// Tool call overhead: function call structure tokens
totalTokens += 8
}
}
}
return totalTokens
}
// slidingWindowStrategy implements CompressionStrategy using sliding window
type slidingWindowStrategy struct {
recentMessageCount int
}
// NewSlidingWindowStrategy creates a new sliding window compression strategy
func NewSlidingWindowStrategy(recentMessageCount int) interfaces.CompressionStrategy {
return &slidingWindowStrategy{
recentMessageCount: recentMessageCount,
}
}
// Compress implements the sliding window compression
// Keeps system messages and the most recent N messages
func (s *slidingWindowStrategy) Compress(
ctx context.Context,
messages []chat.Message,
maxTokens int,
) ([]chat.Message, error) {
if len(messages) <= s.recentMessageCount {
return messages, nil
}
// Separate system messages from regular messages
var systemMessages []chat.Message
var regularMessages []chat.Message
for _, msg := range messages {
if msg.Role == "system" {
systemMessages = append(systemMessages, msg)
} else {
regularMessages = append(regularMessages, msg)
}
}
// Keep the most recent N regular messages
var keptMessages []chat.Message
if len(regularMessages) > s.recentMessageCount {
keptMessages = regularMessages[len(regularMessages)-s.recentMessageCount:]
} else {
keptMessages = regularMessages
}
// Combine: system messages first, then recent messages
result := make([]chat.Message, 0, len(systemMessages)+len(keptMessages))
result = append(result, systemMessages...)
result = append(result, keptMessages...)
logger.Infof(ctx, "[SlidingWindow] Compressed %d messages to %d messages (kept %d recent + %d system)",
len(messages), len(result), len(keptMessages), len(systemMessages))
return result, nil
}
// EstimateTokens estimates token count using CJK-aware heuristics.
func (s *slidingWindowStrategy) EstimateTokens(messages []chat.Message) int {
return estimateMessageTokens(messages)
}
// smartCompressionStrategy implements CompressionStrategy using LLM summarization
type smartCompressionStrategy struct {
recentMessageCount int
chatModel chat.Chat
summarizeThreshold int // Minimum messages before summarization
}
// NewSmartCompressionStrategy creates a new smart compression strategy
func NewSmartCompressionStrategy(
recentMessageCount int,
chatModel chat.Chat,
summarizeThreshold int,
) interfaces.CompressionStrategy {
return &smartCompressionStrategy{
recentMessageCount: recentMessageCount,
chatModel: chatModel,
summarizeThreshold: summarizeThreshold,
}
}
// Compress implements smart compression with LLM summarization
// Summarizes old messages and keeps recent messages intact
func (s *smartCompressionStrategy) Compress(
ctx context.Context,
messages []chat.Message,
maxTokens int,
) ([]chat.Message, error) {
if len(messages) <= s.recentMessageCount {
return messages, nil
}
// Separate system messages, old messages, and recent messages
var systemMessages []chat.Message
var oldMessages []chat.Message
var recentMessages []chat.Message
systemCount := 0
for _, msg := range messages {
if msg.Role == "system" {
systemMessages = append(systemMessages, msg)
systemCount++
}
}
// Get regular messages (non-system)
regularMessages := make([]chat.Message, 0, len(messages)-systemCount)
for _, msg := range messages {
if msg.Role != "system" {
regularMessages = append(regularMessages, msg)
}
}
// Split regular messages into old and recent
if len(regularMessages) > s.recentMessageCount {
splitPoint := len(regularMessages) - s.recentMessageCount
oldMessages = regularMessages[:splitPoint]
recentMessages = regularMessages[splitPoint:]
} else {
recentMessages = regularMessages
}
// If old messages are few, no need to summarize
if len(oldMessages) < s.summarizeThreshold {
result := make([]chat.Message, 0, len(systemMessages)+len(regularMessages))
result = append(result, systemMessages...)
result = append(result, regularMessages...)
return result, nil
}
// Summarize old messages using LLM
summary, err := s.summarizeMessages(ctx, oldMessages)
if err != nil {
logger.Warnf(ctx, "[SmartCompression] Failed to summarize messages: %v, falling back to sliding window", err)
// Fallback: use sliding window strategy to at least reduce message count
fallback := &slidingWindowStrategy{recentMessageCount: s.recentMessageCount}
return fallback.Compress(ctx, messages, maxTokens)
}
// Construct final message list: system + summary + recent
result := make([]chat.Message, 0, len(systemMessages)+1+len(recentMessages))
result = append(result, systemMessages...)
result = append(result, chat.Message{
Role: "system",
Content: fmt.Sprintf("Previous conversation summary:\n%s", summary),
})
result = append(result, recentMessages...)
logger.Infof(
ctx,
"[SmartCompression] Compressed %d messages to %d messages (summarized %d old + kept %d recent + %d system)",
len(messages),
len(result),
len(oldMessages),
len(recentMessages),
len(systemMessages),
)
return result, nil
}
// summarizeMessages uses LLM to create a summary of old messages
func (s *smartCompressionStrategy) summarizeMessages(ctx context.Context, messages []chat.Message) (string, error) {
// Build conversation text
var sb strings.Builder
for i, msg := range messages {
fmt.Fprintf(&sb, "[%s] %s\n", msg.Role, msg.Content)
if i < len(messages)-1 {
sb.WriteString("\n")
}
}
// Create summarization prompt
summaryPrompt := []chat.Message{
{
Role: "system",
Content: "You are a helpful assistant that summarizes conversations. " +
"Provide a concise summary that captures the key points, decisions, and context. " +
"Keep the summary brief but informative.",
},
{
Role: "user",
Content: fmt.Sprintf("Please summarize the following conversation:\n\n%s", sb.String()),
},
}
// Call LLM for summarization
response, err := s.chatModel.Chat(ctx, summaryPrompt, &chat.ChatOptions{
Temperature: 0.3, // Lower temperature for more consistent summaries
MaxTokens: 500, // Limit summary length
})
if err != nil {
return "", fmt.Errorf("failed to generate summary: %w", err)
}
if response == nil || response.Content == "" {
return "", fmt.Errorf("no summary generated")
}
summary := response.Content
logger.Debugf(ctx, "[SmartCompression] Generated summary (%d chars) from %d messages",
len(summary), len(messages))
return summary, nil
}
// EstimateTokens estimates token count using CJK-aware heuristics.
func (s *smartCompressionStrategy) EstimateTokens(messages []chat.Message) int {
return estimateMessageTokens(messages)
}
@@ -3,205 +3,215 @@ package llmcontext
import (
"context"
"fmt"
"regexp"
"sort"
"strings"
"time"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/models/chat"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
)
// contextManager implements the ContextManager interface
// It handles business logic (compression, token management) and delegates storage to ContextStorage
// dbFallbackFetchCount is the number of raw DB messages to fetch when
// rebuilding context from persistent storage. This should be generous
// because user+assistant messages are paired by RequestID and some
// incomplete pairs are discarded.
const dbFallbackFetchCount = 200
var regThinkTags = regexp.MustCompile(`(?s)<think>.*?</think>`)
// contextManager implements the ContextManager interface.
// It is a cache-backed storage layer: messages are persisted per session in
// a fast store (Redis / memory). When the cache is empty (e.g. TTL expired),
// it falls back to the persistent messages table via MessageService to
// rebuild context.
//
// All LLM-aware compression (summarisation, tool-boundary-aware truncation)
// is handled by the Agent Engine's Consolidator before messages are sent to
// the model.
type contextManager struct {
storage ContextStorage // Storage backend (Redis, Memory, etc.)
compressionStrategy interfaces.CompressionStrategy // Compression strategy
maxTokens int // Maximum tokens allowed in context
storage ContextStorage
messageRepo interfaces.MessageRepository // optional; enables DB fallback
}
// NewContextManager creates a new context manager with the specified storage and compression strategy
func NewContextManager(
storage ContextStorage,
compressionStrategy interfaces.CompressionStrategy,
maxTokens int,
) interfaces.ContextManager {
// NewContextManager creates a context manager.
// messageRepo is optional — when provided, GetContext will reconstruct
// history from the DB if the cache is empty.
func NewContextManager(storage ContextStorage, messageRepo interfaces.MessageRepository) interfaces.ContextManager {
return &contextManager{
storage: storage,
compressionStrategy: compressionStrategy,
maxTokens: maxTokens,
storage: storage,
messageRepo: messageRepo,
}
}
// NewContextManagerWithMemory creates a context manager with in-memory storage (for backward compatibility)
func NewContextManagerWithMemory(
compressionStrategy interfaces.CompressionStrategy,
maxTokens int,
) interfaces.ContextManager {
return &contextManager{
storage: NewMemoryStorage(),
compressionStrategy: compressionStrategy,
maxTokens: maxTokens,
}
}
// AddMessage adds a message to the session context
// This method handles the business logic: loading, appending, compression, and saving
// AddMessage appends a message to the session context and persists it.
func (cm *contextManager) AddMessage(ctx context.Context, sessionID string, message chat.Message) error {
logger.Infof(ctx, "[ContextManager][Session-%s] Adding message: role=%s, content_length=%d",
sessionID, message.Role, len(message.Content))
// Log message content preview
contentPreview := message.Content
if len(contentPreview) > 200 {
contentPreview = contentPreview[:200] + "..."
}
logger.Debugf(ctx, "[ContextManager][Session-%s] Message content preview: %s", sessionID, contentPreview)
// Load existing messages from storage
messages, err := cm.storage.Load(ctx, sessionID)
if err != nil {
logger.Errorf(ctx, "[ContextManager][Session-%s] Failed to load context: %v", sessionID, err)
return fmt.Errorf("failed to load context: %w", err)
}
// Add new message
beforeCount := len(messages)
messages = append(messages, message)
logger.Debugf(ctx, "[ContextManager][Session-%s] Messages count: %d -> %d", sessionID, beforeCount, len(messages))
// Check if compression is needed
tokenCount := cm.compressionStrategy.EstimateTokens(messages)
logger.Debugf(ctx, "[ContextManager][Session-%s] Current token count: %d (max: %d)",
sessionID, tokenCount, cm.maxTokens)
if tokenCount > cm.maxTokens {
logger.Infof(ctx, "[ContextManager][Session-%s] Context exceeds max tokens (%d > %d), applying compression",
sessionID, tokenCount, cm.maxTokens)
beforeCompressionCount := len(messages)
compressed, err := cm.compressionStrategy.Compress(ctx, messages, cm.maxTokens)
if err != nil {
logger.Errorf(ctx, "[ContextManager][Session-%s] Failed to compress context: %v", sessionID, err)
return fmt.Errorf("failed to compress context: %w", err)
}
messages = compressed
afterTokenCount := cm.compressionStrategy.EstimateTokens(messages)
logger.Infof(ctx, "[ContextManager][Session-%s] Context compressed: %d -> %d messages, %d -> %d tokens",
sessionID, beforeCompressionCount, len(compressed), tokenCount, afterTokenCount)
}
// Save updated messages to storage
if err := cm.storage.Save(ctx, sessionID, messages); err != nil {
logger.Errorf(ctx, "[ContextManager][Session-%s] Failed to save context: %v", sessionID, err)
return fmt.Errorf("failed to save context: %w", err)
}
logger.Infof(
ctx,
"[ContextManager][Session-%s] Successfully added message (total: %d messages)",
sessionID,
len(messages),
)
logger.Debugf(ctx, "[ContextManager][Session-%s] Message saved (total: %d)", sessionID, len(messages))
return nil
}
// GetContext retrieves the current context for a session from storage
// GetContext retrieves the stored context for a session.
// If the cache is empty and a MessageService is available, it rebuilds
// the context from the persistent messages table and warms the cache.
func (cm *contextManager) GetContext(ctx context.Context, sessionID string) ([]chat.Message, error) {
logger.Infof(ctx, "[ContextManager][Session-%s] Getting context", sessionID)
// Load messages from storage
messages, err := cm.storage.Load(ctx, sessionID)
if err != nil {
logger.Errorf(ctx, "[ContextManager][Session-%s] Failed to load context: %v", sessionID, err)
return nil, fmt.Errorf("failed to load context: %w", err)
}
// Calculate token estimate
tokenCount := cm.compressionStrategy.EstimateTokens(messages)
logger.Infof(ctx, "[ContextManager][Session-%s] Retrieved %d messages (~%d tokens)",
sessionID, len(messages), tokenCount)
// Log message role distribution
roleCount := make(map[string]int)
for _, msg := range messages {
roleCount[msg.Role]++
if len(messages) > 0 {
logger.Debugf(ctx, "[ContextManager][Session-%s] Cache hit: %d messages", sessionID, len(messages))
return messages, nil
}
logger.Debugf(ctx, "[ContextManager][Session-%s] Message distribution: %v", sessionID, roleCount)
return messages, nil
if cm.messageRepo == nil {
return messages, nil
}
// Cache miss — rebuild from DB
rebuilt, err := cm.rebuildFromDB(ctx, sessionID)
if err != nil {
logger.Warnf(ctx, "[ContextManager][Session-%s] Failed to rebuild context from DB: %v", sessionID, err)
return []chat.Message{}, nil
}
if len(rebuilt) > 0 {
if saveErr := cm.storage.Save(ctx, sessionID, rebuilt); saveErr != nil {
logger.Warnf(ctx, "[ContextManager][Session-%s] Failed to warm cache: %v", sessionID, saveErr)
}
logger.Infof(ctx, "[ContextManager][Session-%s] Rebuilt %d messages from DB", sessionID, len(rebuilt))
}
return rebuilt, nil
}
// ClearContext clears all context for a session from storage
func (cm *contextManager) ClearContext(ctx context.Context, sessionID string) error {
logger.Infof(ctx, "[ContextManager][Session-%s] Clearing context", sessionID)
// rebuildFromDB loads recent messages from the persistent messages table
// and converts them into chat.Message pairs (user + assistant).
func (cm *contextManager) rebuildFromDB(ctx context.Context, sessionID string) ([]chat.Message, error) {
dbMessages, err := cm.messageRepo.GetRecentMessagesBySession(ctx, sessionID, dbFallbackFetchCount)
if err != nil {
return nil, fmt.Errorf("failed to load messages from DB: %w", err)
}
if len(dbMessages) == 0 {
return nil, nil
}
// Delete from storage
// Group by RequestID into Q&A pairs, same logic as chat_pipeline/common.go
type pair struct {
query string
answer string
createdAt time.Time
}
pairMap := make(map[string]*pair)
for _, msg := range dbMessages {
p, ok := pairMap[msg.RequestID]
if !ok {
p = &pair{}
pairMap[msg.RequestID] = p
}
switch msg.Role {
case "user":
p.query = msg.Content
p.createdAt = msg.CreatedAt
if desc := extractImageCaptions(msg.Images); desc != "" {
p.query += "\n\n[用户上传图片内容]\n" + desc
}
case "assistant":
p.answer = regThinkTags.ReplaceAllString(msg.Content, "")
}
}
pairs := make([]*pair, 0, len(pairMap))
for _, p := range pairMap {
if p.query != "" && p.answer != "" {
pairs = append(pairs, p)
}
}
sort.Slice(pairs, func(i, j int) bool {
return pairs[i].createdAt.Before(pairs[j].createdAt)
})
result := make([]chat.Message, 0, len(pairs)*2)
for _, p := range pairs {
result = append(result,
chat.Message{Role: "user", Content: p.query},
chat.Message{Role: "assistant", Content: p.answer},
)
}
return result, nil
}
// extractImageCaptions concatenates non-empty Caption fields from message
// images so that previous turns' image descriptions are included in context.
func extractImageCaptions(images types.MessageImages) string {
var parts []string
for _, img := range images {
if img.Caption != "" {
parts = append(parts, img.Caption)
}
}
return strings.Join(parts, "\n")
}
// ClearContext removes all context for a session.
func (cm *contextManager) ClearContext(ctx context.Context, sessionID string) error {
if err := cm.storage.Delete(ctx, sessionID); err != nil {
logger.Errorf(ctx, "[ContextManager][Session-%s] Failed to clear context: %v", sessionID, err)
return fmt.Errorf("failed to clear context: %w", err)
}
logger.Infof(ctx, "[ContextManager][Session-%s] Context cleared successfully", sessionID)
logger.Infof(ctx, "[ContextManager][Session-%s] Context cleared", sessionID)
return nil
}
// GetContextStats returns statistics about the context
// GetContextStats returns statistics about the stored context.
func (cm *contextManager) GetContextStats(ctx context.Context, sessionID string) (*interfaces.ContextStats, error) {
// Load messages from storage
messages, err := cm.storage.Load(ctx, sessionID)
if err != nil {
logger.Errorf(ctx, "[ContextManager][Session-%s] Failed to load context for stats: %v", sessionID, err)
return nil, fmt.Errorf("failed to load context: %w", err)
}
tokenCount := cm.compressionStrategy.EstimateTokens(messages)
stats := &interfaces.ContextStats{
return &interfaces.ContextStats{
MessageCount: len(messages),
TokenCount: tokenCount,
IsCompressed: false, // We'd need to track this explicitly for accurate reporting
OriginalMessageCount: len(messages),
}
logger.Debugf(ctx, "[ContextManager][Session-%s] Context stats: %d messages, ~%d tokens",
sessionID, stats.MessageCount, stats.TokenCount)
return stats, nil
}, nil
}
// SetSystemPrompt sets or updates the system prompt for a session
// If a system message exists, it will be replaced; otherwise, a new one will be added at the beginning
// SetSystemPrompt sets or updates the system prompt for a session.
func (cm *contextManager) SetSystemPrompt(ctx context.Context, sessionID string, systemPrompt string) error {
logger.Infof(ctx, "[ContextManager][Session-%s] Setting system prompt, length=%d", sessionID, len(systemPrompt))
// Load existing messages from storage
messages, err := cm.storage.Load(ctx, sessionID)
if err != nil {
logger.Errorf(ctx, "[ContextManager][Session-%s] Failed to load context: %v", sessionID, err)
return fmt.Errorf("failed to load context: %w", err)
}
// Create new system message
systemMessage := chat.Message{
Role: "system",
Content: systemPrompt,
}
// Check if first message is a system message
if len(messages) > 0 && messages[0].Role == "system" {
// Replace existing system message
logger.Debugf(ctx, "[ContextManager][Session-%s] Replacing existing system prompt", sessionID)
messages[0] = systemMessage
} else {
// Insert system message at the beginning
logger.Debugf(ctx, "[ContextManager][Session-%s] Inserting new system prompt at beginning", sessionID)
messages = append([]chat.Message{systemMessage}, messages...)
}
// Save updated messages to storage
if err := cm.storage.Save(ctx, sessionID, messages); err != nil {
logger.Errorf(ctx, "[ContextManager][Session-%s] Failed to save context: %v", sessionID, err)
return fmt.Errorf("failed to save context: %w", err)
}
logger.Infof(ctx, "[ContextManager][Session-%s] System prompt set successfully", sessionID)
logger.Debugf(ctx, "[ContextManager][Session-%s] System prompt set (length=%d)", sessionID, len(systemPrompt))
return nil
}
@@ -1,78 +1,18 @@
package llmcontext
import (
"context"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/models/chat"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
)
const (
// Context manager types
ContextManagerTypeMemory = "memory"
ContextManagerTypeRedis = "redis"
// Default values
DefaultMaxTokens = 128 * 1024 // 128K tokens
DefaultRecentMessageCount = 20
DefaultSummarizeThreshold = 5
DefaultCompressionStrategy = "sliding_window"
)
// NewContextManagerFromConfig creates a ContextManager based on configuration
// NewContextManagerFromConfig creates a ContextManager.
// messageRepo is optional — when provided, context will be rebuilt from
// the persistent messages table if the cache (Redis/memory) is empty.
func NewContextManagerFromConfig(
contextCfg *types.ContextConfig,
storage ContextStorage,
chatModel chat.Chat,
messageRepo interfaces.MessageRepository,
) interfaces.ContextManager {
// Use default values if config is nil
if contextCfg == nil {
logger.Info(context.TODO(), "ContextManager config not found, using default memory-based context manager")
strategy := NewSlidingWindowStrategy(DefaultRecentMessageCount)
storage := NewMemoryStorage()
return NewContextManager(storage, strategy, DefaultMaxTokens)
if storage == nil {
storage = NewMemoryStorage()
}
// Set default values if not specified
maxTokens := contextCfg.MaxTokens
if maxTokens == 0 {
maxTokens = DefaultMaxTokens
}
recentMessageCount := contextCfg.RecentMessageCount
if recentMessageCount == 0 {
recentMessageCount = DefaultRecentMessageCount
}
summarizeThreshold := contextCfg.SummarizeThreshold
if summarizeThreshold == 0 {
summarizeThreshold = DefaultSummarizeThreshold
}
compressionStrategy := contextCfg.CompressionStrategy
if compressionStrategy == "" {
compressionStrategy = DefaultCompressionStrategy
}
// Create compression strategy
var strategy interfaces.CompressionStrategy
switch compressionStrategy {
case "sliding_window":
strategy = NewSlidingWindowStrategy(recentMessageCount)
case "smart":
if chatModel != nil {
strategy = NewSmartCompressionStrategy(recentMessageCount, chatModel, summarizeThreshold)
} else {
logger.Warn(context.TODO(), "Smart compression requested but no chat model provided, falling back to sliding window")
strategy = NewSlidingWindowStrategy(recentMessageCount)
}
default:
logger.Warnf(context.TODO(), "Unknown compression strategy '%s', using sliding window", compressionStrategy)
strategy = NewSlidingWindowStrategy(recentMessageCount)
}
// Create context manager with storage and strategy
return NewContextManager(storage, strategy, maxTokens)
return NewContextManager(storage, messageRepo)
}
@@ -111,7 +111,7 @@ func (s *sessionService) AgentQA(
}
// Get or create contextManager for this session
contextManager := s.getContextManagerForSession(ctx, req.Session, summaryModel)
contextManager := s.getContextManagerForSession()
// Set system prompt for the current agent in context manager
// This ensures the context uses the correct system prompt when switching agents
@@ -265,6 +265,10 @@ func (s *sessionService) buildAgentConfig(
agentConfig.SearchTargets = searchTargets
logger.Infof(ctx, "Agent search targets built: %d targets", len(searchTargets))
if agentConfig.MaxContextTokens <= 0 {
agentConfig.MaxContextTokens = types.DefaultMaxContextTokens
}
return agentConfig, nil
}
@@ -322,32 +326,9 @@ func (s *sessionService) configureSkillsFromAgent(
}
// getContextManagerForSession creates a context manager for the session based on configuration
// Returns the configured context manager (tenant-level or session-level) or default
func (s *sessionService) getContextManagerForSession(
ctx context.Context,
session *types.Session,
chatModel chat.Chat,
) interfaces.ContextManager {
// Get tenant to access global context configuration
tenant, _ := types.TenantInfoFromContext(ctx)
// Determine which context config to use: tenant-level or default
var contextConfig *types.ContextConfig
if tenant != nil && tenant.ContextConfig != nil {
// Use tenant-level configuration
contextConfig = tenant.ContextConfig
logger.Infof(ctx, "Using tenant-level context config for session %s", session.ID)
} else {
// Use service's default context manager
logger.Debugf(ctx, "Using default context manager for session %s", session.ID)
contextConfig = &types.ContextConfig{
MaxTokens: llmcontext.DefaultMaxTokens,
CompressionStrategy: llmcontext.DefaultCompressionStrategy,
RecentMessageCount: llmcontext.DefaultRecentMessageCount,
SummarizeThreshold: llmcontext.DefaultSummarizeThreshold,
}
}
return llmcontext.NewContextManagerFromConfig(contextConfig, s.sessionStorage, chatModel)
// getContextManagerForSession creates a context manager for the session.
func (s *sessionService) getContextManagerForSession() interfaces.ContextManager {
return llmcontext.NewContextManagerFromConfig(s.sessionStorage, s.messageRepo)
}
// getContextForSession retrieves LLM context for a session