@kya-os/mcp-i-core 1.3.12 → 1.3.14

package/src/__tests__/services/tool-protection.service.test.ts

@@ -1,1373 +0,0 @@
-/**
- * Tool Protection Service Tests
- *
- * Tests for fetching and caching tool protection configurations from AgentShield API
- */
-
-import { describe, test, expect, beforeEach, vi, afterEach } from 'vitest';
-import { ToolProtectionService } from '../../services/tool-protection.service';
-import {
-  InMemoryToolProtectionCache,
-  NoOpToolProtectionCache,
-  type ToolProtectionCache,
-} from '../../cache/tool-protection-cache';
-import type {
-  ToolProtectionServiceConfig,
-  ToolProtectionConfig,
-  DelegationRequiredError,
-} from '../../types/tool-protection';
-
-// Mock global fetch
-global.fetch = vi.fn();
-
-describe('ToolProtectionService', () => {
-  let service: ToolProtectionService;
-  let cache: ToolProtectionCache;
-  let config: ToolProtectionServiceConfig;
-  const mockAgentDid = 'did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK';
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    cache = new InMemoryToolProtectionCache();
-    config = {
-      apiUrl: 'https://kya.vouched.id',
-      apiKey: 'test-api-key-12345',
-      cacheTtl: 300000, // 5 minutes
-      debug: false,
-    };
-    service = new ToolProtectionService(config, cache);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('constructor', () => {
-    test('should initialize with config and cache', () => {
-      expect(service).toBeDefined();
-      expect((service as any).config).toEqual(config);
-      expect((service as any).cache).toBe(cache);
-    });
-  });
-
-  describe('getToolProtectionConfig', () => {
-    describe('cache hit', () => {
-      test('should return cached config if available', async () => {
-        const cachedConfig: ToolProtectionConfig = {
-          toolProtections: {
-            greet: {
-              requiresDelegation: false,
-              requiredScopes: [],
-            },
-          },
-        };
-
-        await cache.set('agent:test-did', cachedConfig, 300000);
-
-        const config = await service.getToolProtectionConfig('test-did');
-
-        expect(config).toEqual(cachedConfig);
-        expect(global.fetch).not.toHaveBeenCalled();
-      });
-
-      test('should use project-scoped cache key when projectId is set', async () => {
-        const projectId = 'test-project-123';
-        config.projectId = projectId;
-        service = new ToolProtectionService(config, cache);
-
-        const cachedConfig: ToolProtectionConfig = {
-          toolProtections: {
-            greet: {
-              requiresDelegation: false,
-              requiredScopes: [],
-            },
-          },
-        };
-
-        const cacheKey = `config:tool-protections:${projectId}`;
-        await cache.set(cacheKey, cachedConfig, 300000);
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(result).toEqual(cachedConfig);
-        expect(global.fetch).not.toHaveBeenCalled();
-      });
-
-      test('should use agent-scoped cache key when projectId is not set', async () => {
-        const cachedConfig: ToolProtectionConfig = {
-          toolProtections: {
-            greet: {
-              requiresDelegation: false,
-              requiredScopes: [],
-            },
-          },
-        };
-
-        const cacheKey = `agent:${mockAgentDid}`;
-        await cache.set(cacheKey, cachedConfig, 300000);
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(result).toEqual(cachedConfig);
-        expect(global.fetch).not.toHaveBeenCalled();
-      });
-    });
-
-    describe('API fetch - merged config format', () => {
-      test('should fetch from project-scoped /config endpoint when projectId is available', async () => {
-        const projectId = 'test-project-123';
-        config.projectId = projectId;
-        service = new ToolProtectionService(config, cache);
-
-        // Merged config format - tools embedded at config.toolProtection.tools
-        const apiResponse = {
-          success: true,
-          data: {
-            config: {
-              toolProtection: {
-                source: 'agentshield',
-                tools: {
-                  checkout: {
-                    requiresDelegation: true,
-                    requiredScopes: ['cart:write'],
-                  },
-                  search: {
-                    requiresDelegation: false,
-                    requiredScopes: [],
-                  },
-                },
-              },
-            },
-          },
-          metadata: {
-            timestamp: new Date().toISOString(),
-            cachedUntil: new Date(Date.now() + 300000).toISOString(),
-          },
-        };
-
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: true,
-          json: async () => apiResponse,
-        });
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        // Now calls /config endpoint (not /tool-protections)
-        expect(global.fetch).toHaveBeenCalledWith(
-          `https://kya.vouched.id/api/v1/bouncer/projects/${encodeURIComponent(projectId)}/config`,
-          expect.objectContaining({
-            method: 'GET',
-            headers: expect.objectContaining({
-              'Content-Type': 'application/json',
-              'X-API-Key': 'test-api-key-12345',
-              'X-Project-Id': projectId,
-            }),
-          })
-        );
-
-        expect(result.toolProtections.checkout).toBeDefined();
-        expect(result.toolProtections.checkout.requiresDelegation).toBe(true);
-        expect(result.toolProtections.checkout.requiredScopes).toEqual(['cart:write']);
-      });
-
-      test('should handle new endpoint format with toolProtections object', async () => {
-        const projectId = 'test-project-123';
-        config.projectId = projectId;
-        service = new ToolProtectionService(config, cache);
-
-        const apiResponse = {
-          success: true,
-          data: {
-            toolProtections: {
-              protected_tool: {
-                requires_delegation: true,
-                required_scopes: ['scope1', 'scope2'],
-              },
-              unprotected_tool: {
-                requires_delegation: false,
-                scopes: [],
-              },
-            },
-          },
-          metadata: {},
-        };
-
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: true,
-          json: async () => apiResponse,
-        });
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(result.toolProtections.protected_tool.requiresDelegation).toBe(true);
-        expect(result.toolProtections.protected_tool.requiredScopes).toEqual(['scope1', 'scope2']);
-        expect(result.toolProtections.unprotected_tool.requiresDelegation).toBe(false);
-      });
-
-      test('should parse oauthProvider from new endpoint format (Phase 2)', async () => {
-        const projectId = 'test-project-123';
-        config.projectId = projectId;
-        service = new ToolProtectionService(config, cache);
-
-        const apiResponse = {
-          success: true,
-          data: {
-            toolProtections: {
-              read_repos: {
-                requiresDelegation: true,
-                requiredScopes: ['repo:read'],
-                oauthProvider: 'github',
-              },
-              send_email: {
-                requiresDelegation: true,
-                requiredScopes: ['gmail:send'],
-                oauthProvider: 'google',
-              },
-            },
-          },
-          metadata: {},
-        };
-
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: true,
-          json: async () => apiResponse,
-        });
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(result.toolProtections.read_repos.oauthProvider).toBe('github');
-        expect(result.toolProtections.send_email.oauthProvider).toBe('google');
-      });
-
-      test('should preserve oauthProvider through cache operations', async () => {
-        const projectId = 'test-project-123';
-        config.projectId = projectId;
-        service = new ToolProtectionService(config, cache);
-
-        const apiResponse = {
-          success: true,
-          data: {
-            toolProtections: {
-              read_repos: {
-                requiresDelegation: true,
-                requiredScopes: ['repo:read'],
-                oauthProvider: 'github',
-              },
-            },
-          },
-          metadata: {},
-        };
-
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: true,
-          json: async () => apiResponse,
-        });
-
-        // First call - should fetch and cache
-        const result1 = await service.getToolProtectionConfig(mockAgentDid);
-        expect(result1.toolProtections.read_repos.oauthProvider).toBe('github');
-
-        // Second call - should use cache
-        const result2 = await service.getToolProtectionConfig(mockAgentDid);
-        expect(result2.toolProtections.read_repos.oauthProvider).toBe('github');
-        expect(global.fetch).toHaveBeenCalledTimes(1); // Still 1, not 2
-      });
-    });
-
-    describe('API fetch - old endpoint format', () => {
-      test('should fetch from agent-scoped endpoint when projectId is not available', async () => {
-        const apiResponse = {
-          success: true,
-          data: {
-            tools: [
-              {
-                name: 'checkout',
-                requiresDelegation: true,
-                scopes: ['cart:write'],
-              },
-              {
-                name: 'search',
-                requiresDelegation: false,
-                scopes: [],
-              },
-            ],
-          },
-          metadata: {},
-        };
-
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: true,
-          json: async () => apiResponse,
-        });
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(global.fetch).toHaveBeenCalledWith(
-          `https://kya.vouched.id/api/v1/bouncer/config?agent_did=${encodeURIComponent(mockAgentDid)}`,
-          expect.objectContaining({
-            method: 'GET',
-            headers: expect.objectContaining({
-              'Content-Type': 'application/json',
-              Authorization: 'Bearer test-api-key-12345',
-            }),
-          })
-        );
-
-        expect(result.toolProtections.checkout).toBeDefined();
-        expect(result.toolProtections.checkout.requiresDelegation).toBe(true);
-        expect(result.toolProtections.checkout.requiredScopes).toEqual(['cart:write']);
-      });
-
-      test('should handle old endpoint format with tools array', async () => {
-        const apiResponse = {
-          success: true,
-          data: {
-            tools: [
-              {
-                name: 'tool1',
-                requires_delegation: true,
-                required_scopes: ['scope1'],
-              },
-              {
-                name: 'tool2',
-                requiresDelegation: false,
-                scopes: [],
-              },
-            ],
-          },
-          metadata: {},
-        };
-
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: true,
-          json: async () => apiResponse,
-        });
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(result.toolProtections.tool1.requiresDelegation).toBe(true);
-        expect(result.toolProtections.tool1.requiredScopes).toEqual(['scope1']);
-        expect(result.toolProtections.tool2.requiresDelegation).toBe(false);
-      });
-
-      test('should parse oauthProvider from old endpoint format (tools array)', async () => {
-        const apiResponse = {
-          success: true,
-          data: {
-            tools: [
-              {
-                name: 'read_repos',
-                requiresDelegation: true,
-                requiredScopes: ['repo:read'],
-                oauthProvider: 'github',
-              },
-              {
-                name: 'send_email',
-                requiresDelegation: true,
-                requiredScopes: ['gmail:send'],
-                oauthProvider: 'google',
-              },
-            ],
-          },
-          metadata: {},
-        };
-
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: true,
-          json: async () => apiResponse,
-        });
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(result.toolProtections.read_repos.oauthProvider).toBe('github');
-        expect(result.toolProtections.send_email.oauthProvider).toBe('google');
-      });
-
-      test('should handle old endpoint format with tools object', async () => {
-        const apiResponse = {
-          success: true,
-          data: {
-            tools: {
-              tool1: {
-                requires_delegation: true,
-                required_scopes: ['scope1'],
-              },
-              tool2: {
-                requiresDelegation: false,
-                scopes: [],
-              },
-            },
-          },
-          metadata: {},
-        };
-
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: true,
-          json: async () => apiResponse,
-        });
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(result.toolProtections.tool1.requiresDelegation).toBe(true);
-        expect(result.toolProtections.tool1.requiredScopes).toEqual(['scope1']);
-        expect(result.toolProtections.tool2.requiresDelegation).toBe(false);
-      });
-
-      test('should parse oauthProvider from old endpoint format (tools object)', async () => {
-        const apiResponse = {
-          success: true,
-          data: {
-            tools: {
-              read_repos: {
-                requiresDelegation: true,
-                requiredScopes: ['repo:read'],
-                oauthProvider: 'github',
-              },
-              send_email: {
-                requiresDelegation: true,
-                requiredScopes: ['gmail:send'],
-                oauthProvider: 'google',
-              },
-            },
-          },
-          metadata: {},
-        };
-
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: true,
-          json: async () => apiResponse,
-        });
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(result.toolProtections.read_repos.oauthProvider).toBe('github');
-        expect(result.toolProtections.send_email.oauthProvider).toBe('google');
-      });
-
-      test('should skip tools without name in array format', async () => {
-        const apiResponse = {
-          success: true,
-          data: {
-            tools: [
-              {
-                name: 'valid_tool',
-                requiresDelegation: true,
-              },
-              {
-                // Missing name - should be skipped
-                requiresDelegation: false,
-              },
-            ],
-          },
-          metadata: {},
-        };
-
-        config.debug = true;
-        service = new ToolProtectionService(config, cache);
-
-        const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: true,
-          json: async () => apiResponse,
-        });
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(result.toolProtections.valid_tool).toBeDefined();
-        expect(Object.keys(result.toolProtections)).toHaveLength(1);
-        expect(consoleSpy).toHaveBeenCalled();
-
-        consoleSpy.mockRestore();
-      });
-    });
-
-    describe('API fetch error handling', () => {
-      test('should throw error when API key is missing', async () => {
-        config.apiKey = '';
-        service = new ToolProtectionService(config, cache);
-
-        await expect(service.getToolProtectionConfig(mockAgentDid)).rejects.toThrow(
-          'ToolProtectionService: API key is missing or empty'
-        );
-      });
-
-      test('should throw error when API key is whitespace only', async () => {
-        config.apiKey = '   ';
-        service = new ToolProtectionService(config, cache);
-
-        await expect(service.getToolProtectionConfig(mockAgentDid)).rejects.toThrow(
-          'ToolProtectionService: API key is missing or empty'
-        );
-      });
-
-      test('should throw error when API returns non-OK status', async () => {
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: false,
-          status: 401,
-          statusText: 'Unauthorized',
-          text: async () => 'Invalid API key',
-        });
-
-        await expect(service.getToolProtectionConfig(mockAgentDid)).rejects.toThrow(
-          'Failed to fetch bouncer config: 401 Unauthorized - Invalid API key'
-        );
-      });
-
-      test('should throw error when API returns success: false', async () => {
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: true,
-          json: async () => ({
-            success: false,
-            error: 'Invalid request',
-          }),
-        });
-
-        await expect(service.getToolProtectionConfig(mockAgentDid)).rejects.toThrow(
-          'API returned success: false'
-        );
-      });
-
-      test('should use fallback config when API fails', async () => {
-        const fallbackConfig: ToolProtectionConfig = {
-          toolProtections: {
-            fallback_tool: {
-              requiresDelegation: true,
-              requiredScopes: ['fallback'],
-            },
-          },
-        };
-
-        config.fallbackConfig = fallbackConfig;
-
-        (global.fetch as any).mockRejectedValueOnce(new Error('Network error'));
-
-        const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(result).toEqual(fallbackConfig);
-        expect(consoleSpy).toHaveBeenCalledWith(
-          expect.stringContaining('API fetch failed, using fallback config'),
-          expect.any(Object)
-        );
-
-        consoleSpy.mockRestore();
-      });
-
-      test('should return deny-all config when API fails and no fallback (fail-safe)', async () => {
-        (global.fetch as any).mockRejectedValueOnce(new Error('Network error'));
-
-        const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(result.toolProtections['*']).toBeDefined();
-        expect(result.toolProtections['*']?.requiresDelegation).toBe(true);
-        expect(consoleSpy).toHaveBeenCalledWith(
-          expect.stringContaining('API fetch failed, no fallback, failing closed (deny-all)'),
-          expect.any(Object)
-        );
-
-        consoleSpy.mockRestore();
-      });
-
-      test('should return allow-all config when failSafeBehavior is allow-all', async () => {
-        config.failSafeBehavior = 'allow-all';
-        service = new ToolProtectionService(config, cache);
-
-        (global.fetch as any).mockRejectedValueOnce(new Error('Network error'));
-
-        const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(result).toEqual({ toolProtections: {} });
-        expect(consoleSpy).toHaveBeenCalledWith(
-          expect.stringContaining('API fetch failed, no fallback, failing open (allow-all)'),
-          expect.any(Object)
-        );
-
-        consoleSpy.mockRestore();
-      });
-
-      test('should use stale cache when API fails and stale cache is available', async () => {
-        config.allowStaleCache = true;
-        config.maxStaleCacheAge = 86400000; // 24 hours
-        service = new ToolProtectionService(config, cache);
-
-        // Create a stale cache entry (expired but within maxStaleCacheAge)
-        const staleConfig: ToolProtectionConfig = {
-          toolProtections: {
-            stale_tool: {
-              requiresDelegation: true,
-              requiredScopes: ['stale'],
-            },
-          },
-        };
-
-        const cacheKey = `agent:${mockAgentDid}`;
-        const expiresAt = Date.now() - 10000; // Expired 10 seconds ago
-        
-        // Mock cache.get() to NOT delete expired entries, so stale cache can be checked later
-        const originalGet = cache.get.bind(cache);
-        vi.spyOn(cache, 'get').mockImplementation(async (key: string) => {
-          if (key === cacheKey) {
-            // Return null (cache miss) but don't delete expired entry
-            // The expired entry will be checked by getStaleCache() later
-            return null;
-          }
-          return originalGet(key);
-        });
-
-        // Set stale entry in internal cache
-        (cache as any).cache.set(cacheKey, {
-          value: staleConfig,
-          expiresAt,
-        });
-
-        (global.fetch as any).mockRejectedValueOnce(new Error('Network error'));
-
-        const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(result).toEqual(staleConfig);
-        expect(consoleSpy).toHaveBeenCalledWith(
-          expect.stringContaining('API fetch failed, using stale cache'),
-          expect.any(Object)
-        );
-
-        consoleSpy.mockRestore();
-        vi.restoreAllMocks();
-      });
-
-      test('should not use stale cache if maxStaleCacheAge exceeded', async () => {
-        config.allowStaleCache = true;
-        config.maxStaleCacheAge = 5000; // 5 seconds
-        service = new ToolProtectionService(config, cache);
-
-        // Create a stale cache entry (expired beyond maxStaleCacheAge)
-        const staleConfig: ToolProtectionConfig = {
-          toolProtections: {
-            stale_tool: {
-              requiresDelegation: true,
-              requiredScopes: ['stale'],
-            },
-          },
-        };
-
-        const cacheKey = `agent:${mockAgentDid}`;
-        const expiresAt = Date.now() - 10000; // Expired 10 seconds ago (exceeds 5s limit)
-        (cache as any).cache.set(cacheKey, {
-          value: staleConfig,
-          expiresAt,
-        });
-
-        (global.fetch as any).mockRejectedValueOnce(new Error('Network error'));
-
-        const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        // Should use deny-all instead of stale cache
-        expect(result.toolProtections['*']).toBeDefined();
-        expect(result.toolProtections['*']?.requiresDelegation).toBe(true);
-        expect(consoleSpy).toHaveBeenCalledWith(
-          expect.stringContaining('failing closed (deny-all)'),
-          expect.any(Object)
-        );
-
-        consoleSpy.mockRestore();
-      });
-
-      test('should not use stale cache if allowStaleCache is false', async () => {
-        config.allowStaleCache = false;
-        service = new ToolProtectionService(config, cache);
-
-        // Create a stale cache entry
-        const staleConfig: ToolProtectionConfig = {
-          toolProtections: {
-            stale_tool: {
-              requiresDelegation: true,
-              requiredScopes: ['stale'],
-            },
-          },
-        };
-
-        const cacheKey = `agent:${mockAgentDid}`;
-        const expiresAt = Date.now() - 10000; // Expired 10 seconds ago
-        (cache as any).cache.set(cacheKey, {
-          value: staleConfig,
-          expiresAt,
-        });
-
-        (global.fetch as any).mockRejectedValueOnce(new Error('Network error'));
-
-        const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        // Should use deny-all instead of stale cache
-        expect(result.toolProtections['*']).toBeDefined();
-        expect(result.toolProtections['*']?.requiresDelegation).toBe(true);
-
-        consoleSpy.mockRestore();
-      });
-
-      test('should prioritize stale cache over fallback config', async () => {
-        config.allowStaleCache = true;
-        config.maxStaleCacheAge = 86400000;
-        const fallbackConfig: ToolProtectionConfig = {
-          toolProtections: {
-            fallback_tool: {
-              requiresDelegation: true,
-              requiredScopes: ['fallback'],
-            },
-          },
-        };
-        config.fallbackConfig = fallbackConfig;
-        service = new ToolProtectionService(config, cache);
-
-        // Create a stale cache entry AFTER cache.get() is called
-        // We need to do this by manually setting an expired entry in the internal cache
-        // after the cache miss but before API fetch fails
-        const staleConfig: ToolProtectionConfig = {
-          toolProtections: {
-            stale_tool: {
-              requiresDelegation: true,
-              requiredScopes: ['stale'],
-            },
-          },
-        };
-
-        const cacheKey = `agent:${mockAgentDid}`;
-        const expiresAt = Date.now() - 10000; // Expired 10 seconds ago
-        
-        // Mock cache.get() to NOT delete expired entries, so stale cache can be checked later
-        const originalGet = cache.get.bind(cache);
-        vi.spyOn(cache, 'get').mockImplementation(async (key: string) => {
-          if (key === cacheKey) {
-            // Return null (cache miss) but don't delete expired entry
-            // The expired entry will be checked by getStaleCache() later
-            return null;
-          }
-          return originalGet(key);
-        });
-
-        // Set stale entry in internal cache
-        (cache as any).cache.set(cacheKey, {
-          value: staleConfig,
-          expiresAt,
-        });
-
-        (global.fetch as any).mockRejectedValueOnce(new Error('Network error'));
-
-        const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        // Should use stale cache (higher priority than fallback)
-        expect(result).toEqual(staleConfig);
-        expect(consoleSpy).toHaveBeenCalledWith(
-          expect.stringContaining('API fetch failed, using stale cache'),
-          expect.any(Object)
-        );
-
-        consoleSpy.mockRestore();
-        vi.restoreAllMocks();
-      });
-
-      test('should handle network errors gracefully', async () => {
-        (global.fetch as any).mockRejectedValueOnce(new Error('ECONNREFUSED'));
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        // Should fail-closed (deny-all) by default
-        expect(result.toolProtections['*']).toBeDefined();
-        expect(result.toolProtections['*']?.requiresDelegation).toBe(true);
-      });
-
-      test('should handle JSON parsing errors', async () => {
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: true,
-          json: async () => {
-            throw new Error('Invalid JSON');
-          },
-        });
-
-        await expect(service.getToolProtectionConfig(mockAgentDid)).rejects.toThrow();
-      });
-    });
-
-    describe('caching behavior', () => {
-      test('should cache successful API responses', async () => {
-        const apiResponse = {
-          success: true,
-          data: {
-            toolProtections: {
-              tool1: {
-                requiresDelegation: true,
-                requiredScopes: ['scope1'],
-              },
-            },
-          },
-          metadata: {},
-        };
-
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: true,
-          json: async () => apiResponse,
-        });
-
-        await service.getToolProtectionConfig(mockAgentDid);
-
-        // Second call should use cache
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(global.fetch).toHaveBeenCalledTimes(1);
-        expect(result.toolProtections.tool1).toBeDefined();
-      });
-
-      test('should use default cache TTL when not specified', async () => {
-        delete config.cacheTtl;
-        service = new ToolProtectionService(config, cache);
-
-        const apiResponse = {
-          success: true,
-          data: {
-            toolProtections: {},
-          },
-          metadata: {},
-        };
-
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: true,
-          json: async () => apiResponse,
-        });
-
-        const setSpy = vi.spyOn(cache, 'set');
-
-        await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(setSpy).toHaveBeenCalledWith(
-          expect.any(String),
-          expect.any(Object),
-          300000 // Default 5 minutes
-        );
-      });
-
-      test('should use custom cache TTL when specified', async () => {
-        config.cacheTtl = 600000; // 10 minutes
-        service = new ToolProtectionService(config, cache);
-
-        const apiResponse = {
-          success: true,
-          data: {
-            toolProtections: {},
-          },
-          metadata: {},
-        };
-
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: true,
-          json: async () => apiResponse,
-        });
-
-        const setSpy = vi.spyOn(cache, 'set');
-
-        await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(setSpy).toHaveBeenCalledWith(
-          expect.any(String),
-          expect.any(Object),
-          600000
-        );
-      });
-    });
-
-    describe('edge cases', () => {
-      test('should handle empty toolProtections object', async () => {
-        const apiResponse = {
-          success: true,
-          data: {
-            toolProtections: {},
-          },
-          metadata: {},
-        };
-
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: true,
-          json: async () => apiResponse,
-        });
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(result.toolProtections).toEqual({});
-      });
-
-      test('should handle null requiredScopes', async () => {
-        const apiResponse = {
-          success: true,
-          data: {
-            toolProtections: {
-              tool1: {
-                requiresDelegation: true,
-                // Missing requiredScopes
-              },
-            },
-          },
-          metadata: {},
-        };
-
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: true,
-          json: async () => apiResponse,
-        });
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(result.toolProtections.tool1.requiredScopes).toEqual([]);
-      });
-
-      test('should handle mixed camelCase and snake_case in response', async () => {
-        const apiResponse = {
-          success: true,
-          data: {
-            toolProtections: {
-              tool1: {
-                requiresDelegation: true,
-                required_scopes: ['scope1'], // snake_case
-              },
-              tool2: {
-                requires_delegation: false,
-                requiredScopes: ['scope2'], // camelCase
-              },
-            },
-          },
-          metadata: {},
-        };
-
-        (global.fetch as any).mockResolvedValueOnce({
-          ok: true,
-          json: async () => apiResponse,
-        });
-
-        const result = await service.getToolProtectionConfig(mockAgentDid);
-
-        expect(result.toolProtections.tool1.requiresDelegation).toBe(true);
-        expect(result.toolProtections.tool1.requiredScopes).toEqual(['scope1']);
-        expect(result.toolProtections.tool2.requiresDelegation).toBe(false);
-        expect(result.toolProtections.tool2.requiredScopes).toEqual(['scope2']);
-      });
-    });
-  });
-
-  describe('checkToolProtection', () => {
-    test('should return null when tool has no protection', async () => {
-      const apiResponse = {
-        success: true,
-        data: {
-          toolProtections: {
-            unprotected_tool: {
-              requiresDelegation: false,
-              requiredScopes: [],
-            },
-          },
-        },
-        metadata: {},
-      };
-
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        json: async () => apiResponse,
-      });
-
-      const protection = await service.checkToolProtection('unprotected_tool', mockAgentDid);
-
-      expect(protection).toBeNull();
-    });
-
-    test('should return null when tool is not in config', async () => {
-      const apiResponse = {
-        success: true,
-        data: {
-          toolProtections: {
-            other_tool: {
-              requiresDelegation: true,
-              requiredScopes: ['scope1'],
-            },
-          },
-        },
-        metadata: {},
-      };
-
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        json: async () => apiResponse,
-      });
-
-      const protection = await service.checkToolProtection('unknown_tool', mockAgentDid);
-
-      expect(protection).toBeNull();
-    });
-
-    test('should return wildcard protection when tool not found and wildcard exists', async () => {
-      const apiResponse = {
-        success: true,
-        data: {
-          toolProtections: {
-            '*': {
-              requiresDelegation: true,
-              requiredScopes: ['wildcard:scope'],
-            },
-            specific_tool: {
-              requiresDelegation: false,
-              requiredScopes: [],
-            },
-          },
-        },
-        metadata: {},
-      };
-
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        json: async () => apiResponse,
-      });
-
-      const protection = await service.checkToolProtection('unknown_tool', mockAgentDid);
-
-      expect(protection).toBeDefined();
-      expect(protection?.requiresDelegation).toBe(true);
-      expect(protection?.requiredScopes).toEqual(['wildcard:scope']);
-    });
-
-    test('should prioritize specific tool protection over wildcard', async () => {
-      const apiResponse = {
-        success: true,
-        data: {
-          toolProtections: {
-            '*': {
-              requiresDelegation: true,
-              requiredScopes: ['wildcard:scope'],
-            },
-            specific_tool: {
-              requiresDelegation: false,
-              requiredScopes: [],
-            },
-          },
-        },
-        metadata: {},
-      };
-
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        json: async () => apiResponse,
-      });
-
-      const protection = await service.checkToolProtection('specific_tool', mockAgentDid);
-
-      // Should use specific tool (no delegation required), not wildcard
-      expect(protection).toBeNull();
-    });
-
-    test('should use wildcard protection in fail-safe deny-all mode', async () => {
-      // Simulate fail-safe mode: API fails, no fallback, returns deny-all config
-      (global.fetch as any).mockRejectedValueOnce(new Error('Network error'));
-
-      const protection = await service.checkToolProtection('any_tool', mockAgentDid);
-
-      // Should return wildcard protection from deny-all config
-      expect(protection).toBeDefined();
-      expect(protection?.requiresDelegation).toBe(true);
-      expect(protection?.requiredScopes).toEqual([]);
-    });
-
-    test('should return protection config when tool requires delegation', async () => {
-      const apiResponse = {
-        success: true,
-        data: {
-          toolProtections: {
-            protected_tool: {
-              requiresDelegation: true,
-              requiredScopes: ['scope1', 'scope2'],
-            },
-          },
-        },
-        metadata: {},
-      };
-
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        json: async () => apiResponse,
-      });
-
-      const protection = await service.checkToolProtection('protected_tool', mockAgentDid);
-
-      expect(protection).toBeDefined();
-      expect(protection?.requiresDelegation).toBe(true);
-      expect(protection?.requiredScopes).toEqual(['scope1', 'scope2']);
-    });
-
-    test('should log protection check when debug is enabled', async () => {
-      config.debug = true;
-      service = new ToolProtectionService(config, cache);
-
-      const apiResponse = {
-        success: true,
-        data: {
-          toolProtections: {
-            tool1: {
-              requiresDelegation: true,
-              requiredScopes: ['scope1'],
-            },
-          },
-        },
-        metadata: {},
-      };
-
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        json: async () => apiResponse,
-      });
-
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-      await service.checkToolProtection('tool1', mockAgentDid);
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Protection check'),
-        expect.any(Object)
-      );
-
-      consoleSpy.mockRestore();
-    });
-
-    test('should log protection check when delegation is required', async () => {
-      const apiResponse = {
-        success: true,
-        data: {
-          toolProtections: {
-            tool1: {
-              requiresDelegation: true,
-              requiredScopes: ['scope1'],
-            },
-          },
-        },
-        metadata: {},
-      };
-
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        json: async () => apiResponse,
-      });
-
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-      await service.checkToolProtection('tool1', mockAgentDid);
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Protection check'),
-        expect.any(Object)
-      );
-
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('clearCache', () => {
-    test('should clear project-scoped cache when projectId is set', async () => {
-      const projectId = 'test-project-123';
-      config.projectId = projectId;
-      service = new ToolProtectionService(config, cache);
-
-      const deleteSpy = vi.spyOn(cache, 'delete');
-
-      await service.clearCache(mockAgentDid);
-
-      expect(deleteSpy).toHaveBeenCalledWith(`config:tool-protections:${projectId}`);
-    });
-
-    test('should clear agent-scoped cache when projectId is not set', async () => {
-      const deleteSpy = vi.spyOn(cache, 'delete');
-
-      await service.clearCache(mockAgentDid);
-
-      expect(deleteSpy).toHaveBeenCalledWith(`agent:${mockAgentDid}`);
-    });
-
-    test('should log cache clear when debug is enabled', async () => {
-      config.debug = true;
-      service = new ToolProtectionService(config, cache);
-
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-      await service.clearCache(mockAgentDid);
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Clearing cache'),
-        expect.any(Object)
-      );
-
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('integration with NoOpToolProtectionCache', () => {
-    test('should work with NoOpToolProtectionCache', async () => {
-      const noOpCache = new NoOpToolProtectionCache();
-      service = new ToolProtectionService(config, noOpCache);
-
-      const apiResponse = {
-        success: true,
-        data: {
-          toolProtections: {
-            tool1: {
-              requiresDelegation: true,
-              requiredScopes: ['scope1'],
-            },
-          },
-        },
-        metadata: {},
-      };
-
-      (global.fetch as any).mockResolvedValue({
-        ok: true,
-        json: async () => apiResponse,
-      });
-
-      // First call - should fetch from API
-      const result1 = await service.getToolProtectionConfig(mockAgentDid);
-
-      // Second call - should fetch again (no cache)
-      const result2 = await service.getToolProtectionConfig(mockAgentDid);
-
-      expect(result1).toEqual(result2);
-      expect(global.fetch).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  describe('debug logging', () => {
-    test('should log cache hits when debug is enabled', async () => {
-      config.debug = true;
-      service = new ToolProtectionService(config, cache);
-
-      const cachedConfig: ToolProtectionConfig = {
-        toolProtections: {
-          tool1: {
-            requiresDelegation: false,
-            requiredScopes: [],
-          },
-        },
-      };
-
-      await cache.set(`agent:${mockAgentDid}`, cachedConfig, 300000);
-
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-      await service.getToolProtectionConfig(mockAgentDid);
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Cache hit'),
-        expect.any(Object)
-      );
-
-      consoleSpy.mockRestore();
-    });
-
-    test('should log cache misses when debug is enabled', async () => {
-      config.debug = true;
-      service = new ToolProtectionService(config, cache);
-
-      const apiResponse = {
-        success: true,
-        data: {
-          toolProtections: {},
-        },
-        metadata: {},
-      };
-
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        json: async () => apiResponse,
-      });
-
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-      await service.getToolProtectionConfig(mockAgentDid);
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Cache miss'),
-        expect.any(Object)
-      );
-
-      consoleSpy.mockRestore();
-    });
-
-    test('should log API fetch details when debug is enabled', async () => {
-      config.debug = true;
-      config.projectId = 'test-project';
-      service = new ToolProtectionService(config, cache);
-
-      const apiResponse = {
-        success: true,
-        data: {
-          toolProtections: {},
-        },
-        metadata: {},
-      };
-
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        json: async () => apiResponse,
-      });
-
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-      await service.getToolProtectionConfig(mockAgentDid);
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Fetching from API'),
-        expect.any(String),
-        expect.any(Object)
-      );
-
-      consoleSpy.mockRestore();
-    });
-
-    test('should log config loaded when API fetch succeeds', async () => {
-      const apiResponse = {
-        success: true,
-        data: {
-          toolProtections: {
-            tool1: {
-              requiresDelegation: true,
-              requiredScopes: ['scope1'],
-            },
-          },
-        },
-        metadata: {},
-      };
-
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        json: async () => apiResponse,
-      });
-
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-      await service.getToolProtectionConfig(mockAgentDid);
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Config loaded'),
-        expect.objectContaining({
-          toolCount: 1,
-          protectedTools: ['tool1'],
-        })
-      );
-
-      consoleSpy.mockRestore();
-    });
-  });
-});
-