WeKnora/internal/handler/shared_agent_access.go

163 lines
6.1 KiB
Go
Raw Normal View History

package handler
import (
stderrors "errors"
fix(agent): scope the @Skill and @MCP pickers to the agent that will run (#3475) * fix(agent): scope the @Skill and @MCP pickers to the agent that will run Both pickers listed the caller's own workspace, but a shared agent invokes its OWNER's skills and MCP services. The two never line up, so for every shared agent: * @Skill was always empty, in every skills mode. GET /skills resolves the sandbox config with (tenant, id), and the agent's config id does not exist in the borrower's workspace - effectiveTenantSkills short-circuits before it reads a single skill row. The response still reported skills_available: true, so the category appeared with nothing under it. * @MCP in "selected" mode was empty for the same reason: the preset holds the owner's service ids, which match nothing in the borrower's catalog. * @MCP in "all" mode was worse than empty. isMCPAllowedByAgent returns true for every enabled service, so the picker offered the BORROWER's own services; resolvePerRequestMCPScope then intersected the mention against the agent's preset, found nothing, and dropped it with only a warning. Resolve the agent when the request carries agent_id + agent_source_tenant_id and read its resources where they live. Only an explicit source workspace takes the share path, so an own-agent request is byte-for-byte unchanged; built-in agent ids exist in every workspace, and falling back to a share lookup without one would let an org member take over the caller's default agent, exactly as session.Handler.resolveAgent already documents. Both endpoints serve only what the agent can actually invoke: * skills: the sandbox config comes from the agent, never from the query, so a borrower cannot name another config in the owner's workspace and enumerate it; "selected" narrows to the configured names and a disabled picker never reaches the owner's inventory at all. * MCP: the agent's explicit preset and nothing else, because that is exactly what resolvePerRequestMCPScope accepts for a shared agent. "all" therefore offers nothing rather than offering services every mention would drop. Whether "all" should become mentionable is a separate decision about that guard, not about the picker. The cross-workspace MCP rows use a narrowed response built field by field. NewMCPServiceResponse reveals endpoint URL, headers, env vars and stdio command to an Admin, and a borrower can be an Admin of their own workspace - that shape must be narrow by construction, not by role. On the client the two lists now follow the selected agent: their cache keys carry it, and the chat input refetches on a switch behind a request token, so a slow response for the agent the user just left cannot overwrite the picker with another workspace's services. * fix(agent): check the c.Error return on the shared-agent picker paths golangci-lint judges pull requests on the lines they introduce, so the repository's older bare c.Error calls are grandfathered while these three are not. Match the _ = c.Error form already used in mcp_service.go.
2026-09-21 05:02:34 +00:00
"strings"
"github.com/Tencent/WeKnora/internal/agent/tools"
"github.com/Tencent/WeKnora/internal/application/access"
"github.com/Tencent/WeKnora/internal/application/service"
apperrors "github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/middleware"
"github.com/Tencent/WeKnora/internal/types"
"github.com/gin-gonic/gin"
)
// resolveSharedAgentForRequest is the identity/share boundary for KB listing,
// document search and batch restoration. KB-scope enforcement follows lookup.
func resolveSharedAgentForRequest(
c *gin.Context,
agentID string,
agents access.SharedAgentLookup,
) (*types.CustomAgent, error) {
ctx := c.Request.Context()
request := middleware.KBAccessRequest(c)
userID := request.Caller.UserID
if request.Caller.TenantID == 0 || userID == "" {
return nil, apperrors.NewUnauthorizedError("Unauthorized")
}
source, err := types.ParseAgentSourceTenantID(request.AgentSourceTenantID)
if err != nil {
return nil, apperrors.NewBadRequestError(err.Error())
}
if agents == nil {
return nil, apperrors.NewForbiddenError("no permission for this shared agent")
}
agent, err := agents.GetSharedAgentForTenant(ctx, request.Caller.TenantID, request.Caller.Role, agentID, source)
if err != nil {
if stderrors.Is(err, service.ErrAgentShareNotFound) || stderrors.Is(err, service.ErrAgentSharePermission) ||
stderrors.Is(err, service.ErrAgentNotFoundForShare) {
return nil, apperrors.NewForbiddenError("no permission for this shared agent")
}
logger.ErrorWithFields(ctx, err, nil)
return nil, apperrors.NewInternalServerError("Failed to verify shared agent access")
}
if agent == nil || agent.TenantID == 0 || (source != 0 && agent.TenantID != source) {
return nil, apperrors.NewForbiddenError("no permission for this shared agent")
}
return agent, nil
}
fix(agent): scope the @Skill and @MCP pickers to the agent that will run (#3475) * fix(agent): scope the @Skill and @MCP pickers to the agent that will run Both pickers listed the caller's own workspace, but a shared agent invokes its OWNER's skills and MCP services. The two never line up, so for every shared agent: * @Skill was always empty, in every skills mode. GET /skills resolves the sandbox config with (tenant, id), and the agent's config id does not exist in the borrower's workspace - effectiveTenantSkills short-circuits before it reads a single skill row. The response still reported skills_available: true, so the category appeared with nothing under it. * @MCP in "selected" mode was empty for the same reason: the preset holds the owner's service ids, which match nothing in the borrower's catalog. * @MCP in "all" mode was worse than empty. isMCPAllowedByAgent returns true for every enabled service, so the picker offered the BORROWER's own services; resolvePerRequestMCPScope then intersected the mention against the agent's preset, found nothing, and dropped it with only a warning. Resolve the agent when the request carries agent_id + agent_source_tenant_id and read its resources where they live. Only an explicit source workspace takes the share path, so an own-agent request is byte-for-byte unchanged; built-in agent ids exist in every workspace, and falling back to a share lookup without one would let an org member take over the caller's default agent, exactly as session.Handler.resolveAgent already documents. Both endpoints serve only what the agent can actually invoke: * skills: the sandbox config comes from the agent, never from the query, so a borrower cannot name another config in the owner's workspace and enumerate it; "selected" narrows to the configured names and a disabled picker never reaches the owner's inventory at all. * MCP: the agent's explicit preset and nothing else, because that is exactly what resolvePerRequestMCPScope accepts for a shared agent. "all" therefore offers nothing rather than offering services every mention would drop. Whether "all" should become mentionable is a separate decision about that guard, not about the picker. The cross-workspace MCP rows use a narrowed response built field by field. NewMCPServiceResponse reveals endpoint URL, headers, env vars and stdio command to an Admin, and a borrower can be an Admin of their own workspace - that shape must be narrow by construction, not by role. On the client the two lists now follow the selected agent: their cache keys carry it, and the chat input refetches on a switch behind a request token, so a slow response for the agent the user just left cannot overwrite the picker with another workspace's services. * fix(agent): check the c.Error return on the shared-agent picker paths golangci-lint judges pull requests on the lines they introduce, so the repository's older bare c.Error calls are grandfathered while these three are not. Match the _ = c.Error form already used in mcp_service.go.
2026-09-21 05:02:34 +00:00
// sharedAgentPickerScope resolves the shared agent a chat-input picker is
// filling for, or (nil, nil) when the request names none.
//
// The @Skill and @MCP pickers offer what the SELECTED agent can invoke, and a
// shared agent invokes its owner's skills and MCP services — its sandbox config
// and service ids do not exist in the caller's own workspace, so listing them
// there returns nothing. A request that names no source workspace is an
// ordinary own-agent request and keeps reading the caller's own resources.
//
// Only an explicit source workspace enters the share path. Built-in agent ids
// exist in every workspace, so falling back to a share lookup without one would
// let an org member take over the caller's default agent, exactly as
// session.Handler.resolveAgent documents.
func sharedAgentPickerScope(
c *gin.Context,
agents access.SharedAgentLookup,
) (*types.CustomAgent, error) {
agentID := strings.TrimSpace(c.Query("agent_id"))
source, err := types.ParseAgentSourceTenantID(c.Query(types.AgentSourceTenantIDParam))
if err != nil {
return nil, apperrors.NewBadRequestError(err.Error())
}
if agentID == "" || source == 0 {
return nil, nil
}
return resolveSharedAgentForRequest(c, agentID, agents)
}
// sharedAgentSkillScope reports which installed skills an already-authorized
// shared agent may invoke. It mirrors sessionService.configureSkillsFromAgent:
// an unknown or empty mode disables skills, so an agent whose owner turned them
// off never exposes the workspace's skill inventory to a borrower.
//
// A nil allowed set means "every installed skill"; enabled is false when no
// skill can be offered at all, which is not the same thing.
func sharedAgentSkillScope(agent *types.CustomAgent) (allowed map[string]bool, enabled bool) {
if agent == nil {
return nil, false
}
switch agent.Config.SkillsSelectionMode {
case "all":
return nil, true
case "selected":
if len(agent.Config.SelectedSkills) == 0 {
return nil, false
}
allowed = make(map[string]bool, len(agent.Config.SelectedSkills))
for _, name := range agent.Config.SelectedSkills {
if name != "" {
allowed[name] = true
}
}
return allowed, len(allowed) > 0
default:
return nil, false
}
}
// sharedAgentMCPScope returns the MCP services a borrower may @mention on an
// already-authorized shared agent.
//
// It is deliberately the agent's explicit preset and nothing else, because that
// is exactly what resolvePerRequestMCPScope accepts for a shared agent: it
// intersects the mention against Config.MCPServices, which is empty under the
// "all" and "none" modes. Offering the owner's whole inventory under "all"
// would put services in the picker that the backend silently drops.
func sharedAgentMCPScope(agent *types.CustomAgent) []string {
if agent == nil || agent.Config.MCPSelectionMode != "selected" {
return nil
}
ids := make([]string, 0, len(agent.Config.MCPServices))
for _, id := range agent.Config.MCPServices {
if strings.TrimSpace(id) != "" {
ids = append(ids, id)
}
}
return ids
}
func filterKnowledgeByAgentScope(knowledges []*types.Knowledge, scope types.SharedAgentKBScope) []*types.Knowledge {
filtered := make([]*types.Knowledge, 0, len(knowledges))
for _, knowledge := range knowledges {
if knowledge != nil && scope.Allows(knowledge.KnowledgeBaseID, knowledge.TenantID) {
filtered = append(filtered, knowledge)
}
}
return filtered
}
// Scope filtering is shared by @KB listing and @file search. Capability checks
// constrain dynamic "all" selections; explicit selections keep their existing
// behavior. This filter does not replace API-key scope checks at the endpoint.
func filterKnowledgeBasesForSharedAgent(kbs []*types.KnowledgeBase, agent *types.CustomAgent) []*types.KnowledgeBase {
scope := types.NewSharedAgentKBScope(agent)
filtered := make([]*types.KnowledgeBase, 0, len(kbs))
if scope.IsEmpty() {
return filtered
}
filter := tools.DeriveKBFilterForAgent(agent.Config.AgentMode, agent.Config.AllowedTools)
for _, kb := range kbs {
if kb == nil || !scope.Allows(kb.ID, kb.TenantID) {
continue
}
if scope.IsAll() && !filter.IsEmpty() &&
!tools.KBSatisfiesAgentRequirements(kb.Capabilities(), agent.Config.AgentMode, agent.Config.AllowedTools) {
continue
}
filtered = append(filtered, kb)
}
return filtered
}