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:
@@ -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)
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user