fix(agent): harden @mention scope and simplify must_use hints

Tighten per-turn @MCP/@Skill/@tag handling after review: enforce agent
MCP/Skill whitelist, ignore mentions when selection mode is none, tag-scope
grep_chunks, and simplified English must_use lines without tool dumps.
Skip persisting scope envelopes to history rendered_content.
This commit is contained in:
wizardchen
2026-06-29 16:54:08 +08:00
committed by lyingbug
parent 049f85139d
commit b86efe3f92
14 changed files with 442 additions and 104 deletions
@@ -129,8 +129,8 @@ func buildUserHistoryMessage(m *types.Message) chat.Message {
}
// Only append fallbacks when RenderedContent is absent — when present, it
// already carries the augmented version persisted by the original turn.
// Agent-mode turns currently do not persist RenderedContent, so attachments
// and image captions would otherwise be invisible to subsequent rounds.
// Agent-mode turns do not persist RenderedContent (scope envelopes are
// injected only for the current LLM call, not replayed from history).
if m.RenderedContent == "" {
if captions := extractImageCaptionsFromMessage(m.Images); captions != "" {
content += "\n\n[用户上传图片内容]\n" + captions
@@ -183,6 +183,10 @@ func (s *sessionService) AgentQA(
logger.Infof(ctx, "Appended %d attachment(s) to agent query", len(req.Attachments))
}
// Scope envelopes (runtime_context / must_use) are injected per LLM call inside
// the agent engine only; we intentionally do not persist them on user messages
// so multi-turn history stays clean and is not skewed by stale @mention scope.
// Execute agent with streaming (asynchronously)
// Events will be emitted to EventBus and handled by the Handler layer
logger.Info(ctx, "Executing agent with streaming")
@@ -245,36 +249,45 @@ 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
if len(req.SkillNames) > 0 {
skillsMode := customAgent.Config.SkillsSelectionMode
if skillsMode == "none" || skillsMode == "" {
logger.Warnf(ctx, "Ignoring @skill mention: agent skills selection is disabled (mode=%s)", skillsMode)
} else if agentConfig.SkillsEnabled {
switch skillsMode {
case "selected":
agentConfig.AllowedSkills = intersectPreservingRequestOrder(req.SkillNames, agentConfig.AllowedSkills)
if len(agentConfig.AllowedSkills) == 0 {
agentConfig.SkillsEnabled = false
}
case "all":
agentConfig.AllowedSkills = dedupPreservingOrder(req.SkillNames)
}
case "all":
agentConfig.AllowedSkills = dedupPreservingOrder(req.SkillNames)
logger.Infof(ctx, "Applied per-request @skill scope: requested=%v effective=%v", req.SkillNames, agentConfig.AllowedSkills)
}
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
if agentConfig.MCPSelectionMode == "none" {
logger.Warnf(ctx, "Ignoring @MCP mention: agent MCP selection is disabled (mode=none)")
} else {
mentioned := dedupPreservingOrder(req.MCPServiceIDs)
isSharedAgent := req.Session != nil && req.Session.TenantID != customAgent.TenantID
effectiveMCP, mcpMode := resolvePerRequestMCPScope(
mentioned,
customAgent.Config.MCPServices,
agentConfig.MCPSelectionMode,
isSharedAgent,
)
if len(effectiveMCP) > 0 {
agentConfig.MCPSelectionMode = mcpMode
agentConfig.MCPServices = effectiveMCP
} else if len(mentioned) > 0 {
logger.Warnf(ctx, "Ignoring @MCP scope outside agent preset: requested=%v agent=%v shared=%v",
req.MCPServiceIDs, customAgent.Config.MCPServices, isSharedAgent)
}
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)
}
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
@@ -327,16 +340,53 @@ func (s *sessionService) buildAgentConfig(
agentConfig.MaxContextTokens = types.DefaultMaxContextTokens
}
if len(req.MCPServiceIDs) > 0 {
agentConfig.PinnedMCPServiceIDs = dedupPreservingOrder(req.MCPServiceIDs)
if len(agentConfig.MCPServices) > 0 && len(req.MCPServiceIDs) > 0 {
agentConfig.PinnedMCPServiceIDs = intersectPreservingRequestOrder(req.MCPServiceIDs, agentConfig.MCPServices)
}
if len(req.SkillNames) > 0 {
agentConfig.PinnedSkillNames = dedupPreservingOrder(req.SkillNames)
if len(req.SkillNames) > 0 && agentConfig.SkillsEnabled {
if len(agentConfig.AllowedSkills) > 0 {
agentConfig.PinnedSkillNames = intersectPreservingRequestOrder(req.SkillNames, agentConfig.AllowedSkills)
} else if customAgent.Config.SkillsSelectionMode == "all" {
agentConfig.PinnedSkillNames = dedupPreservingOrder(req.SkillNames)
}
}
return agentConfig, nil
}
// resolvePerRequestMCPScope narrows MCP registration for a per-turn @mention.
// selectionMode "none" rejects all mentions. Shared agents never register MCP
// services outside the agent preset.
func resolvePerRequestMCPScope(
mentioned, agentMCPs []string,
selectionMode string,
isSharedAgent bool,
) (effective []string, mode string) {
if len(mentioned) == 0 {
return nil, selectionMode
}
if isSharedAgent {
mentioned = intersectPreservingRequestOrder(mentioned, agentMCPs)
if len(mentioned) == 0 {
return nil, selectionMode
}
}
switch selectionMode {
case "none":
return nil, selectionMode
case "selected":
effective = intersectPreservingRequestOrder(mentioned, agentMCPs)
case "all", "":
effective = mentioned
default:
effective = mentioned
}
if len(effective) == 0 {
return nil, selectionMode
}
return effective, "selected"
}
func intersectPreservingRequestOrder(requested []string, allowed []string) []string {
allowedSet := make(map[string]bool, len(allowed))
for _, value := range allowed {
@@ -0,0 +1,62 @@
package service
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestResolvePerRequestMCPScope_SelectedIntersection(t *testing.T) {
effective, mode := resolvePerRequestMCPScope(
[]string{"mcp-b", "mcp-c"},
[]string{"mcp-a", "mcp-b"},
"selected",
false,
)
assert.Equal(t, "selected", mode)
assert.Equal(t, []string{"mcp-b"}, effective)
}
func TestResolvePerRequestMCPScope_SelectedRejectsOutsidePreset(t *testing.T) {
effective, mode := resolvePerRequestMCPScope(
[]string{"mcp-x"},
[]string{"mcp-a"},
"selected",
false,
)
assert.Empty(t, effective)
assert.Equal(t, "selected", mode)
}
func TestResolvePerRequestMCPScope_NoneRejectsMention(t *testing.T) {
effective, mode := resolvePerRequestMCPScope(
[]string{"mcp-iwiki"},
nil,
"none",
false,
)
assert.Empty(t, effective)
assert.Equal(t, "none", mode)
}
func TestResolvePerRequestMCPScope_SharedAgentBlocksOutsidePreset(t *testing.T) {
effective, mode := resolvePerRequestMCPScope(
[]string{"mcp-x"},
[]string{"mcp-a"},
"all",
true,
)
assert.Empty(t, effective)
assert.Equal(t, "all", mode)
}
func TestResolvePerRequestMCPScope_SharedAgentAllowsPreset(t *testing.T) {
effective, mode := resolvePerRequestMCPScope(
[]string{"mcp-a", "mcp-x"},
[]string{"mcp-a", "mcp-b"},
"all",
true,
)
assert.Equal(t, "selected", mode)
assert.Equal(t, []string{"mcp-a"}, effective)
}