feat(chat): add @Skill/@MCP mentions with scoped agent runtime

Wire per-turn @mentions for skills, MCP services, tags, and files through
QA handlers into agent config, runtime_context/must_use user blocks, and
tool registration. Fix tag-only scopes dropping KB tools, refresh suggested
questions on mention changes, and strengthen MCP must_use so @selected
services are invoked before local KB search.
This commit is contained in:
wizardchen
2026-06-29 16:01:58 +08:00
committed by lyingbug
parent 40f217c228
commit 049f85139d
44 changed files with 1814 additions and 378 deletions
+9 -4
View File
@@ -624,9 +624,9 @@ func (r *knowledgeRepository) SearchKnowledgeInScopes(
keyword string,
offset, limit int,
fileTypes []string,
) ([]*types.Knowledge, bool, error) {
) ([]*types.Knowledge, bool, int64, error) {
if len(scopes) == 0 {
return nil, false, nil
return nil, false, 0, nil
}
type KnowledgeWithKBName struct {
@@ -709,13 +709,18 @@ func (r *knowledgeRepository) SearchKnowledgeInScopes(
}
}
var total int64
if err := query.Session(&gorm.Session{}).Count(&total).Error; err != nil {
return nil, false, 0, err
}
var results []KnowledgeWithKBName
err := query.Order("knowledges.created_at DESC").
Offset(offset).
Limit(limit + 1).
Scan(&results).Error
if err != nil {
return nil, false, err
return nil, false, 0, err
}
hasMore := len(results) > limit
@@ -729,7 +734,7 @@ func (r *knowledgeRepository) SearchKnowledgeInScopes(
k.KnowledgeBaseName = r.KnowledgeBaseName
knowledges[i] = &k
}
return knowledges, hasMore, nil
return knowledges, hasMore, total, nil
}
// ListIDsByTagIDs returns all knowledge IDs that have any of the specified tag IDs (OR semantics)
+158 -6
View File
@@ -43,6 +43,46 @@ func dedupStrings(in []string) []string {
return out
}
// agentHasKnowledgeScope reports whether the agent has any KB retrieval scope for
// this turn. Tag-only @mentions populate SearchTargets (with TagIDs) but leave
// KnowledgeBases / KnowledgeIDs empty — those must still count as in-scope.
func agentHasKnowledgeScope(config *types.AgentConfig) bool {
if config == nil {
return false
}
if len(config.KnowledgeBases) > 0 || len(config.KnowledgeIDs) > 0 {
return true
}
return len(config.SearchTargets) > 0
}
// knowledgeBaseIDsForPrompt returns KB IDs to show in runtime_context metadata.
// Prefer explicit KnowledgeBases; fall back to deduped IDs from SearchTargets.
func knowledgeBaseIDsForPrompt(config *types.AgentConfig) []string {
if config == nil {
return nil
}
if len(config.KnowledgeBases) > 0 {
return config.KnowledgeBases
}
if len(config.SearchTargets) == 0 {
return nil
}
seen := make(map[string]struct{}, len(config.SearchTargets))
out := make([]string, 0, len(config.SearchTargets))
for _, target := range config.SearchTargets {
if target == nil || target.KnowledgeBaseID == "" {
continue
}
if _, ok := seen[target.KnowledgeBaseID]; ok {
continue
}
seen[target.KnowledgeBaseID] = struct{}{}
out = append(out, target.KnowledgeBaseID)
}
return out
}
// agentService implements agent-related business logic
type agentService struct {
cfg *config.Config
@@ -149,6 +189,12 @@ func (s *agentService) CreateAgentEngine(
systemPromptTemplate,
)
engine.SetAppConfig(s.cfg)
pinnedMCP := s.resolvePinnedMCPServiceInfos(ctx, config)
s.attachPinnedMCPToolNames(toolRegistry, pinnedMCP)
engine.SetPinnedMentions(
pinnedMCP,
s.resolvePinnedSkillInfos(config),
)
// Set VLM image describer for MCP tool result image analysis.
// When an MCP tool returns images, the engine uses VLM to generate text descriptions
@@ -206,7 +252,11 @@ func (s *agentService) registerMCPTools(
var mcpServices []*types.MCPService
var err error
if mcpMode == "selected" && len(config.MCPServices) > 0 {
if mcpMode == "selected" {
if len(config.MCPServices) == 0 {
logger.Infof(ctx, "MCP services disabled by agent config (mode: selected, no services)")
return
}
mcpServices, err = s.mcpServiceService.ListMCPServicesByIDs(ctx, tenantID, config.MCPServices)
if err != nil {
logger.Warnf(ctx, "Failed to list selected MCP services: %v", err)
@@ -241,11 +291,12 @@ func (s *agentService) resolveKBAndDocInfos(
ctx context.Context,
config *types.AgentConfig,
) ([]*agent.KnowledgeBaseInfo, []*agent.SelectedDocumentInfo) {
kbInfos, err := s.getKnowledgeBaseInfos(ctx, config.KnowledgeBases)
kbIDs := knowledgeBaseIDsForPrompt(config)
kbInfos, err := s.getKnowledgeBaseInfos(ctx, kbIDs)
if err != nil {
logger.Warnf(ctx, "Failed to get knowledge base details, using IDs only: %v", err)
kbInfos = make([]*agent.KnowledgeBaseInfo, 0, len(config.KnowledgeBases))
for _, kbID := range config.KnowledgeBases {
kbInfos = make([]*agent.KnowledgeBaseInfo, 0, len(kbIDs))
for _, kbID := range kbIDs {
kbInfos = append(kbInfos, &agent.KnowledgeBaseInfo{
ID: kbID,
Name: kbID,
@@ -393,8 +444,8 @@ func (s *agentService) registerTools(
}
}
// Filter out knowledge base tools if no knowledge bases or knowledge IDs are configured
hasKnowledge := len(config.KnowledgeBases) > 0 || len(config.KnowledgeIDs) > 0
// Filter out knowledge base tools if no knowledge scope is configured for this turn.
hasKnowledge := agentHasKnowledgeScope(config)
if !hasKnowledge {
filteredTools := make([]string, 0)
kbTools := map[string]bool{
@@ -799,3 +850,104 @@ func (s *agentService) getSelectedDocumentInfos(ctx context.Context, knowledgeID
logger.Infof(ctx, "Loaded %d selected documents metadata for prompt", len(selectedDocs))
return selectedDocs, nil
}
func (s *agentService) resolvePinnedMCPServiceInfos(
ctx context.Context,
config *types.AgentConfig,
) []*agent.PinnedMCPServiceInfo {
if len(config.PinnedMCPServiceIDs) == 0 || s.mcpServiceService == nil {
return nil
}
tenantID := uint64(0)
if tid, ok := types.TenantIDFromContext(ctx); ok {
tenantID = tid
}
if tenantID == 0 {
return fallbackPinnedMCPInfos(config.PinnedMCPServiceIDs)
}
services, err := s.mcpServiceService.ListMCPServicesByIDs(ctx, tenantID, config.PinnedMCPServiceIDs)
if err != nil {
logger.Warnf(ctx, "Failed to resolve pinned MCP services: %v", err)
return fallbackPinnedMCPInfos(config.PinnedMCPServiceIDs)
}
byID := make(map[string]*types.MCPService, len(services))
for _, svc := range services {
if svc != nil {
byID[svc.ID] = svc
}
}
result := make([]*agent.PinnedMCPServiceInfo, 0, len(config.PinnedMCPServiceIDs))
for _, id := range config.PinnedMCPServiceIDs {
if id == "" {
continue
}
if svc, ok := byID[id]; ok {
result = append(result, &agent.PinnedMCPServiceInfo{
ID: svc.ID,
Name: svc.Name,
Description: svc.Description,
})
continue
}
result = append(result, &agent.PinnedMCPServiceInfo{ID: id, Name: id})
}
return result
}
func (s *agentService) attachPinnedMCPToolNames(
registry *tools.ToolRegistry,
pinned []*agent.PinnedMCPServiceInfo,
) {
if registry == nil || len(pinned) == 0 {
return
}
byService := tools.MCPToolNamesByServiceID(registry)
for _, info := range pinned {
if info == nil || info.ID == "" {
continue
}
info.ToolNames = append([]string(nil), byService[info.ID]...)
}
}
func fallbackPinnedMCPInfos(ids []string) []*agent.PinnedMCPServiceInfo {
result := make([]*agent.PinnedMCPServiceInfo, 0, len(ids))
for _, id := range ids {
if id == "" {
continue
}
result = append(result, &agent.PinnedMCPServiceInfo{ID: id, Name: id})
}
return result
}
func (s *agentService) resolvePinnedSkillInfos(config *types.AgentConfig) []*agent.PinnedSkillInfo {
if len(config.PinnedSkillNames) == 0 {
return nil
}
descByName := make(map[string]string)
if len(config.SkillDirs) > 0 {
loader := skills.NewLoader(config.SkillDirs)
if metadata, err := loader.DiscoverSkills(); err == nil {
for _, meta := range metadata {
if meta != nil {
descByName[meta.Name] = meta.Description
}
}
}
}
result := make([]*agent.PinnedSkillInfo, 0, len(config.PinnedSkillNames))
for _, name := range config.PinnedSkillNames {
if name == "" {
continue
}
result = append(result, &agent.PinnedSkillInfo{
Name: name,
Description: descByName[name],
})
}
return result
}
@@ -0,0 +1,37 @@
package service
import (
"testing"
"github.com/Tencent/WeKnora/internal/types"
"github.com/stretchr/testify/assert"
)
func TestAgentHasKnowledgeScope_TagOnlySearchTargets(t *testing.T) {
cfg := &types.AgentConfig{
SearchTargets: types.SearchTargets{
{
Type: types.SearchTargetTypeKnowledgeBase,
KnowledgeBaseID: "kb-1",
TagIDs: []string{"tag-a"},
},
},
}
assert.True(t, agentHasKnowledgeScope(cfg))
}
func TestAgentHasKnowledgeScope_Empty(t *testing.T) {
assert.False(t, agentHasKnowledgeScope(&types.AgentConfig{}))
assert.False(t, agentHasKnowledgeScope(nil))
}
func TestKnowledgeBaseIDsForPrompt_FromSearchTargets(t *testing.T) {
cfg := &types.AgentConfig{
SearchTargets: types.SearchTargets{
{KnowledgeBaseID: "kb-1", TagIDs: []string{"tag-a"}},
{KnowledgeBaseID: "kb-1", TagIDs: []string{"tag-b"}},
{KnowledgeBaseID: "kb-2", TagIDs: []string{"tag-c"}},
},
}
assert.Equal(t, []string{"kb-1", "kb-2"}, knowledgeBaseIDsForPrompt(cfg))
}
@@ -57,6 +57,7 @@ func (p *PluginSearch) runQueryExpansion(ctx context.Context, chatManage *types.
VectorThreshold: chatManage.VectorThreshold,
KeywordThreshold: expKwTh,
MatchCount: expTopK,
TagIDs: t.TagIDs,
DisableVectorMatch: false,
DisableKeywordsMatch: false,
SkipContextEnrichment: true, // Pipeline handles context assembly in merge stage
@@ -386,7 +386,7 @@ func (p *PluginSearch) searchByTargets(
var fullKBIDs []string
var knowledgeTargets []*types.SearchTarget
for _, t := range targets {
if t.Type == types.SearchTargetTypeKnowledgeBase {
if t.Type == types.SearchTargetTypeKnowledgeBase && len(t.TagIDs) == 0 {
fullKBIDs = append(fullKBIDs, t.KnowledgeBaseID)
} else {
knowledgeTargets = append(knowledgeTargets, t)
@@ -502,6 +502,7 @@ func (p *PluginSearch) searchSingleTarget(
VectorThreshold: chatManage.VectorThreshold,
KeywordThreshold: chatManage.KeywordThreshold,
MatchCount: chatManage.EmbeddingTopK,
TagIDs: t.TagIDs,
SkipContextEnrichment: true,
}
if t.Type == types.SearchTargetTypeKnowledge {
@@ -30,6 +30,8 @@ type customAgentService struct {
kbService interfaces.KnowledgeBaseService
kbShareService interfaces.KBShareService
wikiPageRepo interfaces.WikiPageRepository
tagRepo interfaces.KnowledgeTagRepository
knowledgeRepo interfaces.KnowledgeRepository
}
// NewCustomAgentService creates a new custom agent service
@@ -39,6 +41,8 @@ func NewCustomAgentService(
kbService interfaces.KnowledgeBaseService,
kbShareService interfaces.KBShareService,
wikiPageRepo interfaces.WikiPageRepository,
tagRepo interfaces.KnowledgeTagRepository,
knowledgeRepo interfaces.KnowledgeRepository,
) interfaces.CustomAgentService {
return &customAgentService{
repo: repo,
@@ -46,6 +50,8 @@ func NewCustomAgentService(
kbService: kbService,
kbShareService: kbShareService,
wikiPageRepo: wikiPageRepo,
tagRepo: tagRepo,
knowledgeRepo: knowledgeRepo,
}
}
@@ -449,6 +455,7 @@ func (s *customAgentService) GetSuggestedQuestions(
agentID string,
kbIDs []string,
knowledgeIDs []string,
tagIDs []string,
limit int,
) ([]types.SuggestedQuestion, error) {
if limit <= 0 {
@@ -482,6 +489,21 @@ func (s *customAgentService) GetSuggestedQuestions(
}
}
if len(tagIDs) > 0 {
resolved, err := s.resolveKnowledgeIDsFromTags(ctx, tenantID, tagIDs)
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"agent_id": agentID,
"tag_ids": tagIDs,
})
return s.truncateQuestions(result, limit), nil
}
knowledgeIDs = mergeUniqueStrings(knowledgeIDs, resolved)
if len(knowledgeIDs) == 0 {
return s.truncateQuestions(result, limit), nil
}
}
// 2. Determine knowledge base scope
effectiveKBIDs := kbIDs
if len(effectiveKBIDs) == 0 && len(knowledgeIDs) == 0 {
@@ -693,6 +715,74 @@ func (s *customAgentService) GetSuggestedQuestions(
return s.truncateQuestions(result, limit), nil
}
func (s *customAgentService) resolveKnowledgeIDsFromTags(
ctx context.Context,
tenantID uint64,
tagIDs []string,
) ([]string, error) {
if len(tagIDs) == 0 || s.tagRepo == nil || s.knowledgeRepo == nil {
return nil, nil
}
tags, err := s.tagRepo.GetByIDs(ctx, tenantID, tagIDs)
if err != nil {
return nil, err
}
if len(tags) == 0 {
return nil, nil
}
byKB := make(map[string][]string)
for _, tag := range tags {
byKB[tag.KnowledgeBaseID] = append(byKB[tag.KnowledgeBaseID], tag.ID)
}
return mergeKnowledgeIDsFromTagGroups(ctx, s.knowledgeRepo, tenantID, byKB)
}
func mergeKnowledgeIDsFromTagGroups(
ctx context.Context,
knowledgeRepo interfaces.KnowledgeRepository,
tenantID uint64,
byKB map[string][]string,
) ([]string, error) {
seen := make(map[string]bool)
var out []string
for kbID, ids := range byKB {
kids, err := knowledgeRepo.ListIDsByTagIDs(ctx, tenantID, kbID, ids)
if err != nil {
return nil, err
}
for _, kid := range kids {
if !seen[kid] {
seen[kid] = true
out = append(out, kid)
}
}
}
return out, nil
}
func mergeUniqueStrings(base, extra []string) []string {
if len(extra) == 0 {
return base
}
seen := make(map[string]bool, len(base)+len(extra))
out := make([]string, 0, len(base)+len(extra))
for _, s := range base {
if s == "" || seen[s] {
continue
}
seen[s] = true
out = append(out, s)
}
for _, s := range extra {
if s == "" || seen[s] {
continue
}
seen[s] = true
out = append(out, s)
}
return out
}
// truncateQuestions truncates the question list to the specified limit
func (s *customAgentService) truncateQuestions(questions []types.SuggestedQuestion, limit int) []types.SuggestedQuestion {
if len(questions) > limit {
@@ -331,7 +331,7 @@ func (s *embedChannelService) SuggestedQuestions(
limit = 6
}
kbIDs := s.resolveKnowledgeBaseIDs(ctx, ch)
return s.agentService.GetSuggestedQuestions(ctx, ch.AgentID, kbIDs, nil, limit)
return s.agentService.GetSuggestedQuestions(ctx, ch.AgentID, kbIDs, nil, nil, limit)
}
// EmbedDisplayTitle resolves the human-readable title for embed sessions and UI chrome.
+5 -5
View File
@@ -857,10 +857,10 @@ func (s *knowledgeService) UpdateKnowledgeTagBatch(ctx context.Context, authoriz
// SearchKnowledge searches knowledge items by keyword across the tenant and shared knowledge bases.
// fileTypes: optional list of file extensions to filter by (e.g., ["csv", "xlsx"])
func (s *knowledgeService) SearchKnowledge(ctx context.Context, keyword string, offset, limit int, fileTypes []string) ([]*types.Knowledge, bool, error) {
func (s *knowledgeService) SearchKnowledge(ctx context.Context, keyword string, offset, limit int, fileTypes []string) ([]*types.Knowledge, bool, int64, error) {
tenantID, ok := ctx.Value(types.TenantIDContextKey).(uint64)
if !ok {
return nil, false, werrors.NewUnauthorizedError("Tenant ID not found in context")
return nil, false, 0, werrors.NewUnauthorizedError("Tenant ID not found in context")
}
scopes := make([]types.KnowledgeSearchScope, 0)
@@ -896,15 +896,15 @@ func (s *knowledgeService) SearchKnowledge(ctx context.Context, keyword string,
}
if len(scopes) == 0 {
return nil, false, nil
return nil, false, 0, nil
}
return s.repo.SearchKnowledgeInScopes(ctx, scopes, keyword, offset, limit, fileTypes)
}
// SearchKnowledgeForScopes searches knowledge within the given scopes (e.g. for shared agent context).
func (s *knowledgeService) SearchKnowledgeForScopes(ctx context.Context, scopes []types.KnowledgeSearchScope, keyword string, offset, limit int, fileTypes []string) ([]*types.Knowledge, bool, error) {
func (s *knowledgeService) SearchKnowledgeForScopes(ctx context.Context, scopes []types.KnowledgeSearchScope, keyword string, offset, limit int, fileTypes []string) ([]*types.Knowledge, bool, int64, error) {
if len(scopes) == 0 {
return nil, false, nil
return nil, false, 0, nil
}
return s.repo.SearchKnowledgeInScopes(ctx, scopes, keyword, offset, limit, fileTypes)
}
@@ -245,6 +245,37 @@ func (s *sessionService) buildAgentConfig(
} else {
agentConfig.AllowedTools = tools.DefaultAllowedTools()
}
if len(req.SkillNames) > 0 && agentConfig.SkillsEnabled && customAgent != nil {
switch customAgent.Config.SkillsSelectionMode {
case "selected":
agentConfig.AllowedSkills = intersectPreservingRequestOrder(req.SkillNames, agentConfig.AllowedSkills)
if len(agentConfig.AllowedSkills) == 0 {
agentConfig.SkillsEnabled = false
}
case "all":
agentConfig.AllowedSkills = dedupPreservingOrder(req.SkillNames)
}
logger.Infof(ctx, "Applied per-request @skill scope: requested=%v effective=%v", req.SkillNames, agentConfig.AllowedSkills)
}
if len(req.MCPServiceIDs) > 0 {
mentioned := dedupPreservingOrder(req.MCPServiceIDs)
switch agentConfig.MCPSelectionMode {
case "selected":
narrowed := intersectPreservingRequestOrder(mentioned, customAgent.Config.MCPServices)
if len(narrowed) > 0 {
agentConfig.MCPServices = narrowed
} else {
// Explicit @mention outside agent preset — still honor user intent.
agentConfig.MCPServices = mentioned
}
default:
// "all", "none", or unset: per-request @mention narrows registration.
agentConfig.MCPSelectionMode = "selected"
agentConfig.MCPServices = mentioned
}
logger.Infof(ctx, "Applied per-request @MCP scope: requested=%v mode=%s effective=%v",
req.MCPServiceIDs, agentConfig.MCPSelectionMode, agentConfig.MCPServices)
}
// Use custom agent's system prompt if specified
if customAgent.Config.SystemPrompt != "" {
@@ -273,15 +304,19 @@ func (s *sessionService) buildAgentConfig(
logger.Infof(ctx, "Merged agent config from tenant %d and session %s", tenantInfo.ID, req.Session.ID)
// Log knowledge bases if present
if len(agentConfig.KnowledgeBases) > 0 {
logger.Infof(ctx, "Agent configured with %d knowledge base(s): %v",
len(agentConfig.KnowledgeBases), agentConfig.KnowledgeBases)
if len(agentConfig.KnowledgeBases) > 0 || len(req.TagScopes) > 0 {
if len(agentConfig.KnowledgeBases) > 0 {
logger.Infof(ctx, "Agent configured with %d knowledge base(s): %v",
len(agentConfig.KnowledgeBases), agentConfig.KnowledgeBases)
} else {
logger.Infof(ctx, "Agent configured with %d tag-scoped search target(s)", len(req.TagScopes))
}
} else {
logger.Infof(ctx, "No knowledge bases specified for agent, running in pure agent mode")
}
// Build search targets using agent's tenant (handler has validated access for shared agent)
searchTargets, err := s.buildSearchTargets(ctx, agentTenantID, agentConfig.KnowledgeBases, agentConfig.KnowledgeIDs)
searchTargets, err := s.buildSearchTargets(ctx, agentTenantID, agentConfig.KnowledgeBases, agentConfig.KnowledgeIDs, req.TagScopes)
if err != nil {
logger.Warnf(ctx, "Failed to build search targets for agent: %v", err)
}
@@ -292,9 +327,48 @@ func (s *sessionService) buildAgentConfig(
agentConfig.MaxContextTokens = types.DefaultMaxContextTokens
}
if len(req.MCPServiceIDs) > 0 {
agentConfig.PinnedMCPServiceIDs = dedupPreservingOrder(req.MCPServiceIDs)
}
if len(req.SkillNames) > 0 {
agentConfig.PinnedSkillNames = dedupPreservingOrder(req.SkillNames)
}
return agentConfig, nil
}
func intersectPreservingRequestOrder(requested []string, allowed []string) []string {
allowedSet := make(map[string]bool, len(allowed))
for _, value := range allowed {
if value != "" {
allowedSet[value] = true
}
}
result := make([]string, 0, len(requested))
seen := make(map[string]bool, len(requested))
for _, value := range requested {
if value == "" || seen[value] || !allowedSet[value] {
continue
}
seen[value] = true
result = append(result, value)
}
return result
}
func dedupPreservingOrder(values []string) []string {
result := make([]string, 0, len(values))
seen := make(map[string]bool, len(values))
for _, value := range values {
if value == "" || seen[value] {
continue
}
seen[value] = true
result = append(result, value)
}
return result
}
// configureSkillsFromAgent configures skills settings in AgentConfig based on CustomAgentConfig
// Returns the skill directories and allowed skills based on the selection mode:
// - "all": uses all preloaded skills
@@ -84,7 +84,7 @@ func (s *sessionService) KnowledgeQA(
retrievalTenantID := s.resolveRetrievalTenantID(ctx, req)
// Build unified search targets (computed once, used throughout pipeline)
searchTargets, err := s.buildSearchTargets(ctx, retrievalTenantID, knowledgeBaseIDs, knowledgeIDs)
searchTargets, err := s.buildSearchTargets(ctx, retrievalTenantID, knowledgeBaseIDs, knowledgeIDs, req.TagScopes)
if err != nil {
logger.Warnf(ctx, "Failed to build search targets: %v", err)
}
@@ -431,6 +431,7 @@ func (s *sessionService) buildSearchTargets(
tenantID uint64,
knowledgeBaseIDs []string,
knowledgeIDs []string,
tagScopes []types.TagScope,
) (types.SearchTargets, error) {
var targets types.SearchTargets
@@ -517,7 +518,55 @@ func (s *sessionService) buildSearchTargets(
}
}
logger.Infof(ctx, "Built %d search targets: %d full KB, %d partial KB, kbTenantMap=%v",
if len(tagScopes) > 0 {
tagKBIDs := make([]string, 0, len(tagScopes))
for _, scope := range tagScopes {
if scope.KnowledgeBaseID != "" && !fullKBSet[scope.KnowledgeBaseID] {
tagKBIDs = append(tagKBIDs, scope.KnowledgeBaseID)
}
}
kbByID := make(map[string]*types.KnowledgeBase, len(tagKBIDs))
if len(tagKBIDs) > 0 {
if kbs, err := s.knowledgeBaseService.GetKnowledgeBasesByIDsOnly(ctx, tagKBIDs); err == nil {
for _, kb := range kbs {
if kb != nil {
kbByID[kb.ID] = kb
}
}
}
}
userID, _ := types.UserIDFromContext(ctx)
for _, scope := range tagScopes {
if scope.KnowledgeBaseID == "" || len(scope.TagIDs) == 0 || fullKBSet[scope.KnowledgeBaseID] {
continue
}
kbTenant := kbTenantMap[scope.KnowledgeBaseID]
if kbTenant == 0 {
kb := kbByID[scope.KnowledgeBaseID]
if kb == nil || kb.TenantID == tenantID {
kbTenant = tenantID
} else if s.kbShareService != nil && userID != "" {
hasAccess, _ := s.kbShareService.HasTenantKBPermission(ctx, scope.KnowledgeBaseID, tenantID, callerTenantRole, types.OrgRoleViewer)
if hasAccess {
kbTenant = kb.TenantID
} else {
kbTenant = tenantID
}
} else {
kbTenant = tenantID
}
kbTenantMap[scope.KnowledgeBaseID] = kbTenant
}
targets = append(targets, &types.SearchTarget{
Type: types.SearchTargetTypeKnowledgeBase,
KnowledgeBaseID: scope.KnowledgeBaseID,
TenantID: kbTenant,
TagIDs: append([]string(nil), scope.TagIDs...),
})
}
}
logger.Infof(ctx, "Built %d search targets: %d full KB, %d partial/tag KB, kbTenantMap=%v",
len(targets), len(knowledgeBaseIDs), len(targets)-len(knowledgeBaseIDs), kbTenantMap)
return targets, nil
@@ -674,7 +723,7 @@ func (s *sessionService) SearchKnowledge(ctx context.Context,
}
// Build unified search targets (computed once, used throughout pipeline)
searchTargets, err := s.buildSearchTargets(ctx, tenantID, knowledgeBaseIDs, knowledgeIDs)
searchTargets, err := s.buildSearchTargets(ctx, tenantID, knowledgeBaseIDs, knowledgeIDs, nil)
if err != nil {
logger.Warnf(ctx, "Failed to build search targets: %v", err)
}
@@ -26,7 +26,7 @@ func (s *sessionService) resolveKnowledgeBases(
knowledgeIDs = req.KnowledgeIDs
customAgent := req.CustomAgent
hasExplicitMention := len(kbIDs) > 0 || len(knowledgeIDs) > 0
hasExplicitMention := len(kbIDs) > 0 || len(knowledgeIDs) > 0 || len(req.TagScopes) > 0
if customAgent != nil {
logger.Infof(ctx, "KB resolution: hasExplicitMention=%v, RetrieveKBOnlyWhenMentioned=%v, KBSelectionMode=%s",
hasExplicitMention, customAgent.Config.RetrieveKBOnlyWhenMentioned, customAgent.Config.KBSelectionMode)
@@ -38,6 +38,7 @@ func (s *sessionService) resolveKnowledgeBases(
// to prevent users from injecting KB/knowledge IDs outside the agent's configured range.
if customAgent != nil && req.Session != nil && req.Session.TenantID != customAgent.TenantID {
kbIDs, knowledgeIDs = s.restrictMentionsToAgentScope(ctx, customAgent, req.Session.TenantID, kbIDs, knowledgeIDs)
req.TagScopes = s.restrictTagScopesToAgentScope(ctx, customAgent, req.Session.TenantID, req.TagScopes)
}
} else if customAgent != nil && customAgent.Config.RetrieveKBOnlyWhenMentioned {
kbIDs = nil
@@ -49,6 +50,31 @@ func (s *sessionService) resolveKnowledgeBases(
return kbIDs, knowledgeIDs
}
func (s *sessionService) restrictTagScopesToAgentScope(
ctx context.Context,
agent *types.CustomAgent,
sessionTenantID uint64,
tagScopes []types.TagScope,
) []types.TagScope {
if len(tagScopes) == 0 {
return nil
}
allowedKBIDs := s.resolveKnowledgeBasesFromAgent(ctx, agent, sessionTenantID)
allowedSet := make(map[string]bool, len(allowedKBIDs))
for _, id := range allowedKBIDs {
allowedSet[id] = true
}
filtered := make([]types.TagScope, 0, len(tagScopes))
for _, scope := range tagScopes {
if allowedSet[scope.KnowledgeBaseID] {
filtered = append(filtered, scope)
continue
}
logger.Warnf(ctx, "Blocking @mentioned tag scope for KB %s: not in shared agent's allowed scope", scope.KnowledgeBaseID)
}
return filtered
}
// resolveChatModelID resolves the effective chat model ID for a QA request.
//
// When an agent is selected, its model configuration must be complete and