refactor: embed compiledCondition in ServerTool

Instead of maintaining a separate compiledConditions slice indexed by
tool position, embed the *CompiledCondition directly in each ServerTool.

This eliminates the index alignment issue where filtering to a single
tool (ForMCPRequest with ToolsCall) would break the mapping between
tools and their compiled conditions.

Benefits:
- Compiled condition travels with the tool during any filtering
- No index bookkeeping needed
- Simpler code in filters.go (no toolIndex parameter)
- ForMCPRequest works correctly for single-tool lookups
- Same O(1) bitmask evaluation performance

Author: SamMorrowDrums

pkg/inventory/builder.go

@@ -166,9 +166,9 @@ func (b *Builder) Build() *Inventory {
 		}
 	}
 
-	// Compile EnableConditions for O(1) bitmask evaluation
-	// Note: compileConditions uses r.tools which is now sortedTools
-	r.conditionCompiler, r.compiledConditions = b.compileConditions(sortedTools)
+	// Compile EnableConditions for O(1) bitmask evaluation.
+	// This modifies sortedTools in place, embedding compiled conditions in each tool.
+	r.conditionCompiler = b.compileConditions(sortedTools)
 
 	return r
 }
@@ -223,21 +223,20 @@ func (b *Builder) preSortPrompts() []ServerPrompt {
 }
 
 // compileConditions compiles all EnableConditions into bitmask-based evaluators.
-// Returns the compiler (for building request masks) and compiled conditions slice.
-// Takes the sorted tools slice to ensure compiled conditions align with sorted order.
-func (b *Builder) compileConditions(sortedTools []ServerTool) (*ConditionCompiler, []*CompiledCondition) {
+// Modifies sortedTools in place, embedding compiled conditions in each tool.
+// Returns the compiler (for building request masks at runtime).
+func (b *Builder) compileConditions(sortedTools []ServerTool) *ConditionCompiler {
 	compiler := NewConditionCompiler()
-	compiled := make([]*CompiledCondition, len(sortedTools))
 
 	for i := range sortedTools {
 		if sortedTools[i].EnableCondition != nil {
-			compiled[i] = compiler.Compile(sortedTools[i].EnableCondition)
+			sortedTools[i].compiledCondition = compiler.Compile(sortedTools[i].EnableCondition)
 		}
 		// nil means no condition (always enabled from condition perspective)
 	}
 
 	compiler.Freeze()
-	return compiler, compiled
+	return compiler
 }
 
 // processToolsets processes the toolsetIDs configuration and returns:

pkg/inventory/filters.go

@@ -103,7 +103,7 @@ func (r *Inventory) buildRequestMask(ctx context.Context) *RequestMask {
 //  4. Read-only filter
 //  5. Builder filters (via WithFilter)
 //  6. Toolset/additional tools
-func (r *Inventory) isToolEnabled(ctx context.Context, tool *ServerTool, toolIndex int, rm *RequestMask) bool {
+func (r *Inventory) isToolEnabled(ctx context.Context, tool *ServerTool, rm *RequestMask) bool {
 	// 1. Check tool's legacy Enabled function first (for backward compatibility)
 	if tool.Enabled != nil {
 		enabled, err := tool.Enabled(ctx)
@@ -116,17 +116,18 @@ func (r *Inventory) isToolEnabled(ctx context.Context, tool *ServerTool, toolInd
 		}
 	}
 	// 2. Check tool's EnableCondition via compiled bitmask (O(1) evaluation)
-	if toolIndex >= 0 && toolIndex < len(r.compiledConditions) && r.compiledConditions[toolIndex] != nil {
+	// The compiled condition is embedded in the tool, so it travels with filtering.
+	if tool.compiledCondition != nil {
 		if rm != nil {
-			enabled, err := r.compiledConditions[toolIndex].Evaluate(rm)
+			enabled, err := tool.compiledCondition.Evaluate(rm)
 			if err != nil {
 				fmt.Fprintf(os.Stderr, "Tool.EnableCondition check error for %q: %v\n", tool.Tool.Name, err)
 				return false
 			}
 			if !enabled {
 				return false
 			}
-		} else if tool.EnableCondition != nil {
+		} else {
 			// Fallback to tree-based evaluation if no request mask
 			enabled, err := tool.EnableCondition.Evaluate(ctx)
 			if err != nil {
@@ -191,7 +192,7 @@ func (r *Inventory) AvailableTools(ctx context.Context) []ServerTool {
 	var result []ServerTool
 	for i := range r.tools {
 		tool := &r.tools[i]
-		if r.isToolEnabled(ctx, tool, i, rm) {
+		if r.isToolEnabled(ctx, tool, rm) {
 			result = append(result, *tool)
 		}
 	}

pkg/inventory/registry.go

@@ -41,10 +41,8 @@ type Inventory struct {
 	defaultToolsetIDs   []ToolsetID          // sorted list of default toolset IDs
 	toolsetDescriptions map[ToolsetID]string // toolset ID -> description
 
-	// Compiled conditions for O(1) EnableCondition evaluation (set during Build)
-	// Maps tool index → compiled condition (nil means always enabled)
-	compiledConditions []*CompiledCondition
-	// conditionCompiler used to compile conditions (shared across inventory)
+	// conditionCompiler used to compile conditions and build request masks.
+	// The compiled conditions themselves are embedded in each ServerTool.
 	conditionCompiler *ConditionCompiler
 
 	// Filters - these control what's returned by Available* methods
@@ -107,7 +105,9 @@ const (
 func (r *Inventory) ForMCPRequest(method string, itemName string) *Inventory {
 	// Create a shallow copy with shared filter settings
 	// Note: lazy-init maps (toolsByName, etc.) are NOT copied - the new Registry
-	// will initialize its own maps on first use if needed
+	// will initialize its own maps on first use if needed.
+	// Compiled conditions are embedded in each ServerTool, so they travel with the tool
+	// during filtering - no index alignment issues.
 	result := &Inventory{
 		tools:                r.tools,
 		resourceTemplates:    r.resourceTemplates,
@@ -117,9 +117,8 @@ func (r *Inventory) ForMCPRequest(method string, itemName string) *Inventory {
 		enabledToolsets:      r.enabledToolsets, // shared, not modified
 		additionalTools:      r.additionalTools, // shared, not modified
 		featureChecker:       r.featureChecker,
-		filters:              r.filters,            // shared, not modified
-		compiledConditions:   r.compiledConditions, // shared, not modified
-		conditionCompiler:    r.conditionCompiler,  // shared, not modified
+		filters:              r.filters, // shared, not modified
+		conditionCompiler:    r.conditionCompiler,
 		unrecognizedToolsets: r.unrecognizedToolsets,
 	}
 

pkg/inventory/registry_test.go

@@ -1904,7 +1904,6 @@ func TestCompiledConditionsIntegration(t *testing.T) {
 
 	// Verify compiler was created
 	assert.NotNil(t, reg.conditionCompiler, "Condition compiler should be created")
-	assert.NotNil(t, reg.compiledConditions, "Compiled conditions should be created")
 
 	// Test without context bools - only flag-based tools should pass
 	ctx := context.Background()
@@ -1954,9 +1953,9 @@ func TestCompiledConditionsANDBitmask(t *testing.T) {
 		WithToolsets([]string{"all"}).
 		Build()
 
-	// Verify it was compiled to bitmask AND
-	assert.NotNil(t, reg.compiledConditions[0])
-	compiled := reg.compiledConditions[0]
+	// Verify it was compiled to bitmask AND (condition embedded in tool)
+	assert.NotNil(t, reg.tools[0].compiledCondition)
+	compiled := reg.tools[0].compiledCondition
 	assert.Equal(t, evalBitmaskAnd, compiled.evalType, "AND of flags should compile to bitmaskAnd")
 
 	// Test evaluation
@@ -1985,9 +1984,9 @@ func TestCompiledConditionsORBitmask(t *testing.T) {
 		WithToolsets([]string{"all"}).
 		Build()
 
-	// Verify it was compiled to bitmask OR
-	assert.NotNil(t, reg.compiledConditions[0])
-	compiled := reg.compiledConditions[0]
+	// Verify it was compiled to bitmask OR (condition embedded in tool)
+	assert.NotNil(t, reg.tools[0].compiledCondition)
+	compiled := reg.tools[0].compiledCondition
 	assert.Equal(t, evalBitmaskOr, compiled.evalType, "OR of flags should compile to bitmaskOr")
 
 	// Test evaluation - should pass because flag_a is enabled

pkg/inventory/server_tool.go

@@ -97,6 +97,12 @@ type ServerTool struct {
 	// If both Enabled and EnableCondition are set, Enabled takes precedence for
 	// backward compatibility. Migrate to EnableCondition for new tools.
 	Enabled func(ctx context.Context) (bool, error)
+
+	// compiledCondition is the pre-compiled bitmask evaluator for EnableCondition.
+	// Set at build time by compileConditions(). nil means always enabled.
+	// This is embedded in the tool so it travels with the tool during filtering,
+	// eliminating index alignment issues when filtering to single tools.
+	compiledCondition *CompiledCondition
 }
 
 // IsReadOnly returns true if this tool is marked as read-only via annotations.