mcp-rubber-duck 1.7.0 → 1.9.0

package/src/providers/provider.ts

@@ -2,18 +2,22 @@ import OpenAI from 'openai';
 import { ChatOptions, ChatResponse, ProviderOptions, ModelInfo, OpenAIChatParams, OpenAIChatResponse, OpenAIMessage } from './types.js';
 import { ConversationMessage } from '../config/types.js';
 import { logger } from '../utils/logger.js';
+import { GuardrailsService } from '../guardrails/service.js';
+import { GuardrailBlockError } from '../guardrails/errors.js';
 
 export class DuckProvider {
   protected client: OpenAI;
   protected options: ProviderOptions;
+  protected guardrailsService?: GuardrailsService;
   public name: string;
   public nickname: string;
 
-  constructor(name: string, nickname: string, options: ProviderOptions) {
+  constructor(name: string, nickname: string, options: ProviderOptions, guardrailsService?: GuardrailsService) {
     this.name = name;
     this.nickname = nickname;
     this.options = options;
-    
+    this.guardrailsService = guardrailsService;
+
     this.client = new OpenAI({
       apiKey: options.apiKey || 'not-needed',
       baseURL: options.baseURL,
@@ -34,9 +38,35 @@ export class DuckProvider {
 
   async chat(options: ChatOptions): Promise<ChatResponse> {
     try {
-      const messages = this.prepareMessages(options.messages, options.systemPrompt);
       const modelToUse = options.model || this.options.model;
-      
+
+      // Create guardrail context if service is enabled
+      const guardrailContext = this.guardrailsService?.isEnabled()
+        ? this.guardrailsService.createContext({
+            provider: this.name,
+            model: modelToUse,
+            messages: options.messages,
+            prompt: options.messages[options.messages.length - 1]?.content,
+          })
+        : undefined;
+
+      // Execute pre_request guardrails
+      if (guardrailContext && this.guardrailsService?.isEnabled()) {
+        const preResult = await this.guardrailsService.execute('pre_request', guardrailContext);
+        if (preResult.action === 'block') {
+          throw new GuardrailBlockError(
+            preResult.blockedBy || 'unknown',
+            preResult.blockReason || 'Request blocked by guardrails'
+          );
+        }
+        // Update messages if modified by guardrails (e.g., PII redaction)
+        if (preResult.action === 'modify' && guardrailContext.messages.length > 0) {
+          options = { ...options, messages: guardrailContext.messages };
+        }
+      }
+
+      const messages = this.prepareMessages(options.messages, options.systemPrompt);
+
       const baseParams: Partial<OpenAIChatParams> = {
         model: modelToUse,
         messages: messages as OpenAIMessage[],
@@ -50,9 +80,26 @@ export class DuckProvider {
 
       const response = await this.createChatCompletion(baseParams);
       const choice = response.choices[0];
-      
+      let content = choice.message?.content || '';
+
+      // Execute post_response guardrails
+      if (guardrailContext && this.guardrailsService?.isEnabled()) {
+        guardrailContext.response = content;
+        const postResult = await this.guardrailsService.execute('post_response', guardrailContext);
+        if (postResult.action === 'block') {
+          throw new GuardrailBlockError(
+            postResult.blockedBy || 'unknown',
+            postResult.blockReason || 'Response blocked by guardrails'
+          );
+        }
+        // Use potentially modified response (e.g., PII restoration)
+        if (postResult.action === 'modify' && guardrailContext.response) {
+          content = guardrailContext.response;
+        }
+      }
+
       return {
-        content: choice.message?.content || '',
+        content,
         usage: response.usage ? {
           promptTokens: response.usage.prompt_tokens,
           completionTokens: response.usage.completion_tokens,
@@ -62,6 +109,10 @@ export class DuckProvider {
         finishReason: choice.finish_reason || undefined,
       };
     } catch (error: unknown) {
+      // Re-throw GuardrailBlockError as-is
+      if (error instanceof GuardrailBlockError) {
+        throw error;
+      }
       logger.error(`Provider ${this.name} chat error:`, error);
       const errorMessage = error instanceof Error ? error.message : String(error);
       throw new Error(`Duck ${this.nickname} couldn't respond: ${errorMessage}`);

package/src/server.ts

@@ -3,6 +3,8 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema,
   Tool,
 } from '@modelcontextprotocol/sdk/types.js';
 
@@ -18,6 +20,7 @@ import { UsageService } from './services/usage.js';
 import { DuckResponse } from './config/types.js';
 import { ApprovalService } from './services/approval.js';
 import { FunctionBridge } from './services/function-bridge.js';
+import { GuardrailsService } from './guardrails/service.js';
 import { logger } from './utils/logger.js';
 import { duckArt, getRandomDuckMessage } from './utils/ascii-art.js';
 
@@ -42,11 +45,15 @@ import { mcpStatusTool } from './tools/mcp-status.js';
 // Import usage stats tool
 import { getUsageStatsTool } from './tools/get-usage-stats.js';
 
+// Import prompts
+import { getPrompts, getPrompt } from './prompts/index.js';
+
 export class RubberDuckServer {
   private server: Server;
   private configManager: ConfigManager;
   private pricingService: PricingService;
   private usageService: UsageService;
+  private guardrailsService?: GuardrailsService;
   private providerManager: ProviderManager;
   private enhancedProviderManager?: EnhancedProviderManager;
   private conversationManager: ConversationManager;
@@ -68,6 +75,7 @@ export class RubberDuckServer {
       {
         capabilities: {
           tools: {},
+          prompts: {},
         },
       }
     );
@@ -80,8 +88,13 @@ export class RubberDuckServer {
     this.pricingService = new PricingService(config.pricing);
     this.usageService = new UsageService(this.pricingService);
 
-    // Initialize provider manager with usage tracking
-    this.providerManager = new ProviderManager(this.configManager, this.usageService);
+    // Initialize guardrails service if configured
+    if (config.guardrails?.enabled) {
+      this.guardrailsService = new GuardrailsService(config.guardrails);
+    }
+
+    // Initialize provider manager with usage tracking and guardrails
+    this.providerManager = new ProviderManager(this.configManager, this.usageService, this.guardrailsService);
     this.conversationManager = new ConversationManager();
     this.cache = new ResponseCache(config.cache_ttl);
     this.healthMonitor = new HealthMonitor(this.providerManager);
@@ -110,20 +123,22 @@ export class RubberDuckServer {
       // Initialize approval service
       this.approvalService = new ApprovalService(mcpConfig.approval_timeout);
 
-      // Initialize function bridge
+      // Initialize function bridge with guardrails
       this.functionBridge = new FunctionBridge(
         this.mcpClientManager,
         this.approvalService,
         mcpConfig.trusted_tools,
         mcpConfig.approval_mode,
-        mcpConfig.trusted_tools_by_server || {}
+        mcpConfig.trusted_tools_by_server || {},
+        this.guardrailsService
       );
 
-      // Initialize enhanced provider manager with usage tracking
+      // Initialize enhanced provider manager with usage tracking and guardrails
       this.enhancedProviderManager = new EnhancedProviderManager(
         this.configManager,
         this.functionBridge,
-        this.usageService
+        this.usageService,
+        this.guardrailsService
       );
 
       this.mcpEnabled = true;
@@ -142,6 +157,23 @@ export class RubberDuckServer {
       return { tools: this.getTools() };
     });
 
+    // List available prompts
+    this.server.setRequestHandler(ListPromptsRequestSchema, () => {
+      return { prompts: getPrompts() };
+    });
+
+    // Get specific prompt
+    this.server.setRequestHandler(GetPromptRequestSchema, (request) => {
+      const { name, arguments: args } = request.params;
+      try {
+        return getPrompt(name, args || {});
+      } catch (error: unknown) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`Prompt error for ${name}:`, errorMessage);
+        throw error;
+      }
+    });
+
     // Handle tool calls
     this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
       const { name, arguments: args } = request.params;
@@ -801,6 +833,18 @@ export class RubberDuckServer {
       console.log('\n' + getRandomDuckMessage('startup'));
     }
 
+    // Initialize guardrails service if configured
+    if (this.guardrailsService) {
+      try {
+        await this.guardrailsService.initialize();
+        logger.info('Guardrails service initialized successfully');
+      } catch (error: unknown) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error('Failed to initialize guardrails:', errorMessage);
+        logger.warn('Guardrails functionality may not be available');
+      }
+    }
+
     // Initialize MCP connections if enabled
     if (this.mcpEnabled && this.mcpClientManager) {
       try {
@@ -830,6 +874,11 @@ export class RubberDuckServer {
     // Cleanup usage service (flush pending writes)
     this.usageService.shutdown();
 
+    // Cleanup guardrails service
+    if (this.guardrailsService) {
+      await this.guardrailsService.shutdown();
+    }
+
     // Cleanup MCP resources
     if (this.approvalService) {
       this.approvalService.shutdown();

package/src/services/function-bridge.ts

@@ -2,6 +2,9 @@ import { MCPClientManager, MCPTool } from './mcp-client-manager.js';
 import { ApprovalService } from './approval.js';
 import { logger } from '../utils/logger.js';
 import Ajv, { ValidateFunction } from 'ajv';
+import { GuardrailsService } from '../guardrails/service.js';
+import { GuardrailContext } from '../guardrails/types.js';
+import { GuardrailBlockError } from '../guardrails/errors.js';
 
 export interface FunctionDefinition {
   name: string;
@@ -26,13 +29,15 @@ export class FunctionBridge {
   private ajv: unknown;
   private toolSchemas: Map<string, Record<string, unknown>> = new Map();
   private approvalMode: 'always' | 'trusted' | 'never';
+  private guardrailsService?: GuardrailsService;
 
   constructor(
     mcpManager: MCPClientManager,
     approvalService: ApprovalService,
     trustedTools: string[] = [],
     approvalMode: 'always' | 'trusted' | 'never' = 'always',
-    trustedToolsByServer: Record<string, string[]> = {}
+    trustedToolsByServer: Record<string, string[]> = {},
+    guardrailsService?: GuardrailsService
   ) {
     this.mcpManager = mcpManager;
     this.approvalService = approvalService;
@@ -40,7 +45,8 @@ export class FunctionBridge {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
     this.ajv = new (Ajv as unknown as new (options: unknown) => unknown)({ allErrors: true, removeAdditional: 'all' });
     this.approvalMode = approvalMode;
-    
+    this.guardrailsService = guardrailsService;
+
     // Initialize per-server trusted tools
     Object.entries(trustedToolsByServer).forEach(([serverName, tools]) => {
       this.trustedToolsByServer.set(serverName, new Set(tools));
@@ -236,16 +242,61 @@ export class FunctionBridge {
         }
       }
 
+      // Create guardrail context if service is enabled
+      let guardrailContext: GuardrailContext | undefined;
+      if (this.guardrailsService?.isEnabled()) {
+        guardrailContext = this.guardrailsService.createContext({
+          toolName: `${mcpServer}:${mcpTool}`,
+          toolArgs: cleanArgs,
+        });
+
+        // Execute pre_tool_input guardrails
+        const preResult = await this.guardrailsService.execute('pre_tool_input', guardrailContext);
+        if (preResult.action === 'block') {
+          throw new GuardrailBlockError(
+            preResult.blockedBy || 'unknown',
+            preResult.blockReason || 'Tool input blocked by guardrails'
+          );
+        }
+        // Use potentially modified args (e.g., PII redaction)
+        if (preResult.action === 'modify' && guardrailContext.toolArgs) {
+          Object.assign(cleanArgs, guardrailContext.toolArgs);
+        }
+      }
+
       // Execute the MCP tool
       logger.info(`Executing MCP tool ${mcpServer}:${mcpTool} for ${duckName}`);
       const result = await this.mcpManager.callTool(mcpServer, mcpTool, cleanArgs);
 
+      // Execute post_tool_output guardrails
+      if (guardrailContext && this.guardrailsService?.isEnabled()) {
+        guardrailContext.toolResult = result;
+        const postResult = await this.guardrailsService.execute('post_tool_output', guardrailContext);
+        if (postResult.action === 'block') {
+          throw new GuardrailBlockError(
+            postResult.blockedBy || 'unknown',
+            postResult.blockReason || 'Tool output blocked by guardrails'
+          );
+        }
+        // Return potentially modified result
+        if (postResult.action === 'modify') {
+          return {
+            success: true,
+            data: guardrailContext.toolResult,
+          };
+        }
+      }
+
       return {
         success: true,
         data: result,
       };
 
     } catch (error: unknown) {
+      // Re-throw GuardrailBlockError as-is
+      if (error instanceof GuardrailBlockError) {
+        throw error;
+      }
       const errorMessage = error instanceof Error ? error.message : String(error);
       logger.error(`Function call failed for ${functionName}:`, errorMessage);
       return {

package/tests/guardrails/config.test.ts

@@ -0,0 +1,267 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { ConfigManager } from '../../src/config/config';
+
+// Mock logger to avoid console noise during tests
+jest.mock('../../src/utils/logger');
+
+describe('ConfigManager - Guardrails Config', () => {
+  let originalEnv: NodeJS.ProcessEnv;
+
+  beforeEach(() => {
+    originalEnv = { ...process.env };
+    // Clear guardrails env vars
+    Object.keys(process.env).forEach((key) => {
+      if (key.startsWith('GUARDRAILS_')) delete process.env[key];
+    });
+    // Ensure at least one provider exists
+    process.env.OPENAI_API_KEY = 'test-key';
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe('basic guardrails config', () => {
+    it('should not have guardrails by default', () => {
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().guardrails).toBeUndefined();
+    });
+
+    it('should enable guardrails when GUARDRAILS_ENABLED=true', () => {
+      process.env.GUARDRAILS_ENABLED = 'true';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().guardrails?.enabled).toBe(true);
+    });
+
+    it('should disable guardrails when GUARDRAILS_ENABLED=false', () => {
+      process.env.GUARDRAILS_ENABLED = 'false';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().guardrails).toBeUndefined();
+    });
+
+    it('should set log_violations from environment', () => {
+      process.env.GUARDRAILS_ENABLED = 'true';
+      process.env.GUARDRAILS_LOG_VIOLATIONS = 'false';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().guardrails?.log_violations).toBe(false);
+    });
+
+    it('should set log_modifications from environment', () => {
+      process.env.GUARDRAILS_ENABLED = 'true';
+      process.env.GUARDRAILS_LOG_MODIFICATIONS = 'true';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().guardrails?.log_modifications).toBe(true);
+    });
+
+    it('should set fail_open from environment', () => {
+      process.env.GUARDRAILS_ENABLED = 'true';
+      process.env.GUARDRAILS_FAIL_OPEN = 'true';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().guardrails?.fail_open).toBe(true);
+    });
+  });
+
+  describe('rate limiter config', () => {
+    it('should configure rate limiter from environment', () => {
+      process.env.GUARDRAILS_RATE_LIMITER_ENABLED = 'true';
+      process.env.GUARDRAILS_RATE_LIMITER_REQUESTS_PER_MINUTE = '30';
+      process.env.GUARDRAILS_RATE_LIMITER_REQUESTS_PER_HOUR = '500';
+
+      const configManager = new ConfigManager();
+      const config = configManager.getConfig();
+
+      expect(config.guardrails?.enabled).toBe(true);
+      expect(config.guardrails?.plugins?.rate_limiter?.enabled).toBe(true);
+      expect(config.guardrails?.plugins?.rate_limiter?.requests_per_minute).toBe(30);
+      expect(config.guardrails?.plugins?.rate_limiter?.requests_per_hour).toBe(500);
+    });
+
+    it('should configure per_provider setting', () => {
+      process.env.GUARDRAILS_RATE_LIMITER_ENABLED = 'true';
+      process.env.GUARDRAILS_RATE_LIMITER_PER_PROVIDER = 'true';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().guardrails?.plugins?.rate_limiter?.per_provider).toBe(true);
+    });
+
+    it('should configure burst_allowance setting', () => {
+      process.env.GUARDRAILS_RATE_LIMITER_ENABLED = 'true';
+      process.env.GUARDRAILS_RATE_LIMITER_BURST_ALLOWANCE = '10';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().guardrails?.plugins?.rate_limiter?.burst_allowance).toBe(10);
+    });
+  });
+
+  describe('token limiter config', () => {
+    it('should configure token limiter from environment', () => {
+      process.env.GUARDRAILS_TOKEN_LIMITER_ENABLED = 'true';
+      process.env.GUARDRAILS_TOKEN_LIMITER_MAX_INPUT_TOKENS = '4096';
+
+      const configManager = new ConfigManager();
+      const config = configManager.getConfig();
+
+      expect(config.guardrails?.enabled).toBe(true);
+      expect(config.guardrails?.plugins?.token_limiter?.enabled).toBe(true);
+      expect(config.guardrails?.plugins?.token_limiter?.max_input_tokens).toBe(4096);
+    });
+
+    it('should configure max_output_tokens setting', () => {
+      process.env.GUARDRAILS_TOKEN_LIMITER_ENABLED = 'true';
+      process.env.GUARDRAILS_TOKEN_LIMITER_MAX_OUTPUT_TOKENS = '2048';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().guardrails?.plugins?.token_limiter?.max_output_tokens).toBe(2048);
+    });
+
+    it('should configure warn_at_percentage setting', () => {
+      process.env.GUARDRAILS_TOKEN_LIMITER_ENABLED = 'true';
+      process.env.GUARDRAILS_TOKEN_LIMITER_WARN_AT_PERCENTAGE = '90';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().guardrails?.plugins?.token_limiter?.warn_at_percentage).toBe(90);
+    });
+  });
+
+  describe('pattern blocker config', () => {
+    it('should configure pattern blocker from environment', () => {
+      process.env.GUARDRAILS_PATTERN_BLOCKER_ENABLED = 'true';
+      process.env.GUARDRAILS_PATTERN_BLOCKER_PATTERNS = 'password,secret,api_key';
+
+      const configManager = new ConfigManager();
+      const config = configManager.getConfig();
+
+      expect(config.guardrails?.enabled).toBe(true);
+      expect(config.guardrails?.plugins?.pattern_blocker?.enabled).toBe(true);
+      expect(config.guardrails?.plugins?.pattern_blocker?.blocked_patterns).toEqual([
+        'password',
+        'secret',
+        'api_key',
+      ]);
+    });
+
+    it('should configure regex patterns', () => {
+      process.env.GUARDRAILS_PATTERN_BLOCKER_ENABLED = 'true';
+      process.env.GUARDRAILS_PATTERN_BLOCKER_PATTERNS_REGEX = 'pass.*word,secret\\d+';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().guardrails?.plugins?.pattern_blocker?.blocked_patterns_regex).toEqual([
+        'pass.*word',
+        'secret\\d+',
+      ]);
+    });
+
+    it('should configure case_sensitive setting', () => {
+      process.env.GUARDRAILS_PATTERN_BLOCKER_ENABLED = 'true';
+      process.env.GUARDRAILS_PATTERN_BLOCKER_CASE_SENSITIVE = 'true';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().guardrails?.plugins?.pattern_blocker?.case_sensitive).toBe(true);
+    });
+
+    it('should configure action_on_match setting', () => {
+      process.env.GUARDRAILS_PATTERN_BLOCKER_ENABLED = 'true';
+      process.env.GUARDRAILS_PATTERN_BLOCKER_ACTION = 'redact';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().guardrails?.plugins?.pattern_blocker?.action_on_match).toBe('redact');
+    });
+  });
+
+  describe('PII redactor config', () => {
+    it('should configure PII redactor from environment', () => {
+      process.env.GUARDRAILS_PII_REDACTOR_ENABLED = 'true';
+
+      const configManager = new ConfigManager();
+      const config = configManager.getConfig();
+
+      expect(config.guardrails?.enabled).toBe(true);
+      expect(config.guardrails?.plugins?.pii_redactor?.enabled).toBe(true);
+    });
+
+    it('should configure detection types', () => {
+      process.env.GUARDRAILS_PII_REDACTOR_ENABLED = 'true';
+      process.env.GUARDRAILS_PII_REDACTOR_DETECT_EMAILS = 'false';
+      process.env.GUARDRAILS_PII_REDACTOR_DETECT_PHONES = 'true';
+      process.env.GUARDRAILS_PII_REDACTOR_DETECT_SSN = 'false';
+      process.env.GUARDRAILS_PII_REDACTOR_DETECT_API_KEYS = 'true';
+      process.env.GUARDRAILS_PII_REDACTOR_DETECT_CREDIT_CARDS = 'false';
+      process.env.GUARDRAILS_PII_REDACTOR_DETECT_IP_ADDRESSES = 'true';
+
+      const configManager = new ConfigManager();
+      const piiConfig = configManager.getConfig().guardrails?.plugins?.pii_redactor;
+
+      expect(piiConfig?.detect_emails).toBe(false);
+      expect(piiConfig?.detect_phones).toBe(true);
+      expect(piiConfig?.detect_ssn).toBe(false);
+      expect(piiConfig?.detect_api_keys).toBe(true);
+      expect(piiConfig?.detect_credit_cards).toBe(false);
+      expect(piiConfig?.detect_ip_addresses).toBe(true);
+    });
+
+    it('should configure allowlist', () => {
+      process.env.GUARDRAILS_PII_REDACTOR_ENABLED = 'true';
+      process.env.GUARDRAILS_PII_REDACTOR_ALLOWLIST = 'test@example.com,support@company.com';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().guardrails?.plugins?.pii_redactor?.allowlist).toEqual([
+        'test@example.com',
+        'support@company.com',
+      ]);
+    });
+
+    it('should configure allowlist_domains', () => {
+      process.env.GUARDRAILS_PII_REDACTOR_ENABLED = 'true';
+      process.env.GUARDRAILS_PII_REDACTOR_ALLOWLIST_DOMAINS = 'company.com,internal.org';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().guardrails?.plugins?.pii_redactor?.allowlist_domains).toEqual([
+        'company.com',
+        'internal.org',
+      ]);
+    });
+
+    it('should configure restore_on_response', () => {
+      process.env.GUARDRAILS_PII_REDACTOR_ENABLED = 'true';
+      process.env.GUARDRAILS_PII_REDACTOR_RESTORE_ON_RESPONSE = 'true';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().guardrails?.plugins?.pii_redactor?.restore_on_response).toBe(true);
+    });
+
+    it('should configure log_detections', () => {
+      process.env.GUARDRAILS_PII_REDACTOR_ENABLED = 'true';
+      process.env.GUARDRAILS_PII_REDACTOR_LOG_DETECTIONS = 'false';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().guardrails?.plugins?.pii_redactor?.log_detections).toBe(false);
+    });
+  });
+
+  describe('auto-enable behavior', () => {
+    it('should auto-enable guardrails when a plugin is enabled', () => {
+      // Don't set GUARDRAILS_ENABLED, but enable a plugin
+      process.env.GUARDRAILS_RATE_LIMITER_ENABLED = 'true';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().guardrails?.enabled).toBe(true);
+    });
+
+    it('should auto-enable with multiple plugins', () => {
+      process.env.GUARDRAILS_RATE_LIMITER_ENABLED = 'true';
+      process.env.GUARDRAILS_PII_REDACTOR_ENABLED = 'true';
+
+      const configManager = new ConfigManager();
+      const config = configManager.getConfig();
+
+      expect(config.guardrails?.enabled).toBe(true);
+      expect(config.guardrails?.plugins?.rate_limiter?.enabled).toBe(true);
+      expect(config.guardrails?.plugins?.pii_redactor?.enabled).toBe(true);
+    });
+  });
+});