Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 6 additions & 0 deletions README.md
Original file line number Diff line number Diff line change
Expand Up @@ -66,6 +66,12 @@ work; its returned files are not installed as bot rules. Existing tokens may lac
`knowledge:read`; use DuckBug's token/access flow to grant it. This MCP wiring is
currently supported on the Claude backend.

Delegated runs use the effective catalog of the current credential, including
deployment availability. If no authorized KB operations are present, ordinary
replies still work, but the agent is told that the knowledge base is unavailable
and must not promise a lookup or invent document sources. Product MCP documents
and app-admin document pickers are not substitutes for the owner's knowledge base.

Roles and prompts are behavioral preferences, not an execution sandbox. The bot
retains its configured tools. MCP capabilities enforce data access; a project
credential can also expose shared organization documents. Use an appropriate
Expand Down
10 changes: 10 additions & 0 deletions core/claude/delegated.go
Original file line number Diff line number Diff line change
Expand Up @@ -40,6 +40,12 @@ func prepareDelegated(ctx context.Context, o Options) (Options, func(), error) {
if err != nil {
return o, nil, err
}
if len(servers) == 0 {
instructions = append(instructions, []byte("\n\nCurrent run: no authorized knowledge-base tools are available. "+
"Answer ordinary requests within the owner's rules, but if an answer requires knowledge-base documents, "+
"say that this knowledge source is currently unavailable. Do not promise a lookup, fabricate sources, "+
"or claim to have read documents.\n")...)
}
dir, err := os.MkdirTemp("", "flock-secretary-")
if err != nil {
closeKnowledge()
Expand Down Expand Up @@ -131,6 +137,10 @@ func delegatedServers(ctx context.Context, path string) (map[string]MCPServer, f
if err != nil {
return nil, nil, errors.New("delegated knowledge connection unavailable")
}
if !proxy.Available {
proxy.Close()
return servers, cleanup, nil
}
servers["secretary_knowledge"] = MCPServer{URL: proxy.URL, BearerToken: proxy.Token}
return servers, proxy.Close, nil
}
7 changes: 6 additions & 1 deletion core/claude/delegated_integration_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -115,6 +115,11 @@ func TestIntegration_DelegatedCLIReadOnlyAndScopedResume(t *testing.T) {
if step == 0 {
block["input"] = map[string]any{"query": "recipient-safe fixture"}
}
} else if step == 5 {
block = map[string]any{
"type": fixtureToolUse, "id": "resumed_read", "name": "mcp__secretary_knowledge__kb_search",
"input": map[string]any{"query": "resumed recipient-safe fixture"},
}
}
writeModelFixture(t, w, block)
}))
Expand Down Expand Up @@ -167,7 +172,7 @@ func TestIntegration_DelegatedCLIReadOnlyAndScopedResume(t *testing.T) {
run("recipient-B-marker", options)
mu.Lock()
defer mu.Unlock()
if reads != 1 || deliveries != 0 || len(requests) < 7 {
if reads != 2 || deliveries != 0 || len(requests) < 8 {
t.Fatalf("read/resume requests = %d/%d", reads, len(requests))
}
assertDelegatedInventory(t, inventories)
Expand Down
44 changes: 44 additions & 0 deletions core/claude/delegated_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -4,11 +4,15 @@ package claude
import (
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"slices"
"strings"
"testing"

"github.com/modelcontextprotocol/go-sdk/mcp"
)

func TestDelegatedLaunchExcludesCredentialsAndOrdinaryWorkspace(t *testing.T) {
Expand Down Expand Up @@ -68,6 +72,11 @@ func TestDelegatedLaunchExcludesCredentialsAndOrdinaryWorkspace(t *testing.T) {
if err != nil || string(config) != `{"mcpServers":{}}` {
t.Fatal("empty scope inherited other MCP servers")
}
instructions, err := os.ReadFile(filepath.Join(prepared.Workdir, "instructions.txt"))
if err != nil || !strings.Contains(string(instructions), "no authorized knowledge-base tools are available") ||
!strings.Contains(string(instructions), "Owner disclosure rules") {
t.Fatal("unavailable knowledge or owner policy was not communicated")
}
cleanup()
if _, err := os.Stat(prepared.Workdir); !os.IsNotExist(err) {
t.Fatal("temporary run files retained")
Expand All @@ -87,3 +96,38 @@ func TestDelegatedLaunchFailsClosedWithoutExplicitAuthentication(t *testing.T) {
t.Fatal("conflicting execution policies were permitted")
}
}

func TestDelegatedLaunchExplainsEmptyAuthorizedKnowledgeCatalog(t *testing.T) {
server := mcp.NewServer(&mcp.Implementation{Name: "fixture", Version: "1"}, nil)
server.AddTool(&mcp.Tool{Name: "discover_tools", InputSchema: json.RawMessage(`{"type":"object"}`)},
func(context.Context, *mcp.CallToolRequest) (*mcp.CallToolResult, error) {
return &mcp.CallToolResult{StructuredContent: map[string]any{"tools": []any{}}}, nil
})
upstream := httptest.NewServer(mcp.NewStreamableHTTPHandler(func(*http.Request) *mcp.Server { return server },
&mcp.StreamableHTTPOptions{Stateless: true, JSONResponse: true}))
t.Cleanup(upstream.Close)
owner := t.TempDir()
if err := os.WriteFile(filepath.Join(owner, "CLAUDE.md"), []byte("Owner disclosure rules"), 0o600); err != nil {
t.Fatal(err)
}
config := filepath.Join(owner, "mcp.json")
if _, err := WriteMCPConfig(config, map[string]MCPServer{"duckbug": {URL: upstream.URL, BearerToken: "fixture"}}); err != nil {
t.Fatal(err)
}
prepared, cleanup, err := prepareDelegated(t.Context(), Options{
Workdir: owner, MCPConfig: config,
Env: []string{"ANTHROPIC_API_KEY=synthetic-provider"},
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(cleanup)
instructions, err := os.ReadFile(filepath.Join(prepared.Workdir, "instructions.txt"))
if err != nil || !strings.Contains(string(instructions), "no authorized knowledge-base tools are available") {
t.Fatal("empty discovery was hidden from the delegated agent")
}
data, err := os.ReadFile(prepared.MCPConfig)
if err != nil || string(data) != `{"mcpServers":{}}` {
t.Fatal("empty discovery inherited other MCP access")
}
}
31 changes: 17 additions & 14 deletions core/knowledge/proxy.go
Original file line number Diff line number Diff line change
Expand Up @@ -29,9 +29,10 @@ var leaves = [...]string{"kb_search", "kb_get", "kb_list"}

// Proxy keeps the upstream credential inside the trusted host process.
type Proxy struct {
URL string
Token string
close func()
URL string
Token string
Available bool
close func()
}

// Close releases the local listener and its upstream session.
Expand Down Expand Up @@ -104,7 +105,7 @@ func Start(ctx context.Context, endpoint, authorization string) (*Proxy, error)
}
discoveryCtx, cancel := context.WithTimeout(ctx, operationTimeout)
defer cancel()
server, err := readServer(discoveryCtx, session)
server, available, err := readServer(discoveryCtx, session)
if err != nil {
_ = session.Close()
return nil, err
Expand Down Expand Up @@ -133,7 +134,7 @@ func Start(ctx context.Context, endpoint, authorization string) (*Proxy, error)
}
go func() { _ = host.Serve(listener) }()
var once sync.Once
return &Proxy{URL: "http://" + listener.Addr().String() + "/mcp", Token: token, close: func() {
return &Proxy{URL: "http://" + listener.Addr().String() + "/mcp", Token: token, Available: available, close: func() {
once.Do(func() {
_ = host.Close()
_ = session.Close()
Expand All @@ -150,40 +151,41 @@ type catalogTool struct {
InputSchema json.RawMessage `json:"inputSchema"`
}

func readServer(ctx context.Context, session *mcp.ClientSession) (*mcp.Server, error) {
func readServer(ctx context.Context, session *mcp.ClientSession) (*mcp.Server, bool, error) {
server := mcp.NewServer(&mcp.Implementation{Name: "flock-secretary-knowledge", Version: "1"}, nil)
available := false
for _, leaf := range leaves {
response, err := session.CallTool(ctx, &mcp.CallToolParams{
Name: "discover_tools",
Arguments: map[string]any{"name": leaf, "includeSchema": true},
})
if err != nil {
return nil, errors.New("knowledge discovery failed")
return nil, false, errors.New("knowledge discovery failed")
}
var discovery struct {
Tools []catalogTool `json:"tools"`
}
if err := resultJSON(response, &discovery); err != nil {
return nil, err
return nil, false, err
}
if len(discovery.Tools) == 0 {
continue // The bot token does not authorize this operation.
continue // This operation is absent from the effective catalog.
}
if len(discovery.Tools) != 1 {
return nil, errors.New("ambiguous knowledge tool")
return nil, false, errors.New("ambiguous knowledge tool")
}
tool := discovery.Tools[0]
if tool.Name != leaf || tool.Mutates == nil || *tool.Mutates || tool.Execution != "read" ||
tool.Surface != "catalog" || tool.DirectOnly {
return nil, errors.New("knowledge tool is not an authorized catalog read")
return nil, false, errors.New("knowledge tool is not an authorized catalog read")
}
var schema jsonschema.Schema
if err := json.Unmarshal(tool.InputSchema, &schema); err != nil || schema.Type != "object" {
return nil, errors.New("invalid knowledge tool schema")
return nil, false, errors.New("invalid knowledge tool schema")
}
resolved, err := schema.Resolve(&jsonschema.ResolveOptions{ValidateDefaults: true})
if err != nil {
return nil, errors.New("unsupported knowledge tool schema")
return nil, false, errors.New("unsupported knowledge tool schema")
}
// Low-level registration deliberately uses the pre-resolved schema so a
// malformed upstream schema cannot panic or fetch external references.
Expand Down Expand Up @@ -215,8 +217,9 @@ func readServer(ctx context.Context, session *mcp.ClientSession) (*mcp.Server, e
}
return &mcp.CallToolResult{Content: []mcp.Content{&mcp.TextContent{Text: string(envelope.Result)}}}, nil
})
available = true
}
return server, nil
return server, available, nil
}

func resultJSON(result *mcp.CallToolResult, target any) error {
Expand Down
22 changes: 21 additions & 1 deletion core/knowledge/proxy_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -73,6 +73,26 @@ func proxyClient(t *testing.T, proxy *Proxy) *mcp.ClientSession {
return session
}

func TestProxyReportsEmptyAuthorizedCatalog(t *testing.T) {
server := mcp.NewServer(&mcp.Implementation{Name: "fixture", Version: "1"}, nil)
server.AddTool(&mcp.Tool{Name: "discover_tools", InputSchema: json.RawMessage(`{"type":"object"}`)},
func(context.Context, *mcp.CallToolRequest) (*mcp.CallToolResult, error) {
return &mcp.CallToolResult{StructuredContent: map[string]any{"tools": []any{}}}, nil
})
upstream := httptest.NewServer(mcp.NewStreamableHTTPHandler(func(*http.Request) *mcp.Server { return server },
&mcp.StreamableHTTPOptions{Stateless: true, JSONResponse: true}))
t.Cleanup(upstream.Close)
proxy, err := Start(t.Context(), upstream.URL, "Bearer fixture")
if err != nil {
t.Fatal(err)
}
t.Cleanup(proxy.Close)
listed, err := proxyClient(t, proxy).ListTools(t.Context(), nil)
if err != nil || len(listed.Tools) != 0 || proxy.Available {
t.Fatal("empty knowledge catalog reported as available")
}
}

func TestProxyOnlyReadsKnowledgeAndPreservesBotScope(t *testing.T) {
endpoint, calls, mu := fakeKnowledge(t, false)
proxy, err := Start(t.Context(), endpoint, "Bearer upstream-fixture")
Expand All @@ -82,7 +102,7 @@ func TestProxyOnlyReadsKnowledgeAndPreservesBotScope(t *testing.T) {
t.Cleanup(proxy.Close)
client := proxyClient(t, proxy)
listed, err := client.ListTools(t.Context(), nil)
if err != nil || len(listed.Tools) != 3 {
if err != nil || len(listed.Tools) != 3 || !proxy.Available {
t.Fatalf("tools = %v, error %v", listed, err)
}
for _, tool := range listed.Tools {
Expand Down
Loading