@optimizely-opal/opal-tool-ocp-sdk 0.0.0-OCP-1487.9 → 0.0.0-OCP-1487.10

package/src/decorator/Decorator.test.ts

@@ -9,9 +9,6 @@ jest.mock('../service/Service', () => ({
     registerInteraction: jest.fn()
   }
 }));
-
-// Mock base class for testing auto-detection
-class GlobalToolFunction {}
 describe('Decorators', () => {
   beforeEach(() => {
     jest.clearAllMocks();
@@ -39,8 +36,7 @@ describe('Decorators', () => {
         expect.any(Function),
         [],
         '/test-tool',
-        [],
-        false
+        []
       );
 
       // Ensure TestClass is considered "used" by TypeScript
@@ -82,8 +78,7 @@ describe('Decorators', () => {
           })
         ]),
         '/tool-with-params',
-        [],
-        false
+        []
       );
 
       // Ensure TestClass is considered "used" by TypeScript
@@ -124,8 +119,7 @@ describe('Decorators', () => {
             scopeBundle: 'calendar',
             required: true
           })
-        ]),
-        false
+        ])
       );
 
       // Ensure TestClass is considered "used" by TypeScript
@@ -206,8 +200,7 @@ describe('Decorators', () => {
             scopeBundle: 'drive',
             required: false
           })
-        ]),
-        false
+        ])
       );
 
       // Ensure TestClass is considered "used" by TypeScript
@@ -235,8 +228,7 @@ describe('Decorators', () => {
         expect.any(Function),
         [],
         '/empty-params',
-        [],
-        false
+        []
       );
 
       expect(TestClass).toBeDefined();
@@ -264,8 +256,7 @@ describe('Decorators', () => {
         expect.any(Function),
         [],
         '/no-auth',
-        [],
-        false
+        []
       );
 
       expect(TestClass).toBeDefined();
@@ -332,8 +323,7 @@ describe('Decorators', () => {
           expect.objectContaining({ name: 'dictParam', type: ParameterType.Dictionary })
         ]),
         '/multi-type',
-        [],
-        false
+        []
       );
     });
   });
@@ -452,8 +442,7 @@ describe('Decorators', () => {
           })
         ]),
         '/mixed-tool',
-        [],
-        false
+        []
       );
 
       expect(toolsService.registerInteraction).toHaveBeenCalledWith(
@@ -500,8 +489,7 @@ describe('Decorators', () => {
             scopeBundle: 'calendar',
             required: true // Should default to true
           })
-        ]),
-        false
+        ])
       );
     });
 
@@ -527,8 +515,7 @@ describe('Decorators', () => {
         expect.any(Function),
         [], // Should be empty array when parameters is undefined
         '/undefined-arrays',
-        [], // Should be empty array when authRequirements is undefined
-        false
+        [] // Should be empty array when authRequirements is undefined
       );
     });
   });
@@ -658,287 +645,5 @@ describe('Decorators', () => {
       expect(TestClass).toBeDefined();
     });
   });
-
-  describe('global tool registration', () => {
-    it('should auto-detect global tools when class extends GlobalToolFunction', () => {
-      const config: ToolConfig = {
-        name: 'autoGlobalTool',
-        description: 'An auto-detected global tool',
-        parameters: [],
-        endpoint: '/auto-global-tool'
-      };
-
-      class TestGlobalClass extends GlobalToolFunction {
-        @tool(config)
-        public async testTool(): Promise<{ result: string }> {
-          return { result: 'global-tool-result' };
-        }
-      }
-
-      expect(toolsService.registerTool).toHaveBeenCalledWith(
-        'autoGlobalTool',
-        'An auto-detected global tool',
-        expect.any(Function),
-        [],
-        '/auto-global-tool',
-        [],
-        true
-      );
-
-      expect(TestGlobalClass).toBeDefined();
-    });
-
-    it('should register regular tools when class does not extend GlobalToolFunction', () => {
-      const config: ToolConfig = {
-        name: 'regularTool',
-        description: 'A regular tool',
-        parameters: [],
-        endpoint: '/regular-tool'
-      };
-
-      class TestRegularClass {
-        @tool(config)
-        public async testTool(): Promise<{ result: string }> {
-          return { result: 'regular-tool-result' };
-        }
-      }
-
-      expect(toolsService.registerTool).toHaveBeenCalledWith(
-        'regularTool',
-        'A regular tool',
-        expect.any(Function),
-        [],
-        '/regular-tool',
-        [],
-        false
-      );
-
-      expect(TestRegularClass).toBeDefined();
-    });
-
-    it('should register tools as global when import context is set', () => {
-      // Set global import context
-      globalThis.__IMPORT_CONTEXT = 'global';
-
-      const config: ToolConfig = {
-        name: 'importedGlobalTool',
-        description: 'A tool imported as global',
-        parameters: [],
-        endpoint: '/imported-global-tool'
-      };
-
-      class TestImportedClass {
-        @tool(config)
-        public async testTool(): Promise<{ result: string }> {
-          return { result: 'imported-global-tool-result' };
-        }
-      }
-
-      expect(toolsService.registerTool).toHaveBeenCalledWith(
-        'importedGlobalTool',
-        'A tool imported as global',
-        expect.any(Function),
-        [],
-        '/imported-global-tool',
-        [],
-        true
-      );
-
-      // Clean up
-      globalThis.__IMPORT_CONTEXT = undefined;
-      expect(TestImportedClass).toBeDefined();
-    });
-
-    it('should register tools as regular when import context is set to regular', () => {
-      // Set regular import context
-      globalThis.__IMPORT_CONTEXT = 'regular';
-
-      const config: ToolConfig = {
-        name: 'importedRegularTool',
-        description: 'A tool imported as regular',
-        parameters: [],
-        endpoint: '/imported-regular-tool'
-      };
-
-      class TestImportedClass {
-        @tool(config)
-        public async testTool(): Promise<{ result: string }> {
-          return { result: 'imported-regular-tool-result' };
-        }
-      }
-
-      expect(toolsService.registerTool).toHaveBeenCalledWith(
-        'importedRegularTool',
-        'A tool imported as regular',
-        expect.any(Function),
-        [],
-        '/imported-regular-tool',
-        [],
-        false
-      );
-
-      // Clean up
-      globalThis.__IMPORT_CONTEXT = undefined;
-      expect(TestImportedClass).toBeDefined();
-    });
-
-    it('should handle mixed imports - both regular and global tools together', () => {
-      // Test importing regular tools first
-      globalThis.__IMPORT_CONTEXT = 'regular';
-
-      const regularConfig: ToolConfig = {
-        name: 'mixedRegularTool',
-        description: 'A regular tool in mixed scenario',
-        parameters: [],
-        endpoint: '/mixed-regular-tool'
-      };
-
-      class RegularToolClass {
-        @tool(regularConfig)
-        public async regularTool(): Promise<{ result: string }> {
-          return { result: 'mixed-regular-result' };
-        }
-      }
-
-      // Switch to global context
-      globalThis.__IMPORT_CONTEXT = 'global';
-
-      const globalConfig: ToolConfig = {
-        name: 'mixedGlobalTool',
-        description: 'A global tool in mixed scenario',
-        parameters: [],
-        endpoint: '/mixed-global-tool'
-      };
-
-      class GlobalToolClass {
-        @tool(globalConfig)
-        public async globalTool(): Promise<{ result: string }> {
-          return { result: 'mixed-global-result' };
-        }
-      }
-
-      // Clear context
-      globalThis.__IMPORT_CONTEXT = undefined;
-
-      // Verify regular tool was registered as regular
-      expect(toolsService.registerTool).toHaveBeenCalledWith(
-        'mixedRegularTool',
-        'A regular tool in mixed scenario',
-        expect.any(Function),
-        [],
-        '/mixed-regular-tool',
-        [],
-        false
-      );
-
-      // Verify global tool was registered as global
-      expect(toolsService.registerTool).toHaveBeenCalledWith(
-        'mixedGlobalTool',
-        'A global tool in mixed scenario',
-        expect.any(Function),
-        [],
-        '/mixed-global-tool',
-        [],
-        true
-      );
-
-      expect(RegularToolClass).toBeDefined();
-      expect(GlobalToolClass).toBeDefined();
-    });
-
-    it('should handle context switching correctly within same test', () => {
-      let callCount = 0;
-      const originalRegisterTool = jest.mocked(toolsService.registerTool);
-
-      // Track call order and contexts
-      originalRegisterTool.mockImplementation(() => {
-        callCount++;
-        // Store the isGlobal flag from each call for verification
-      });
-
-      // First: Import as regular
-      globalThis.__IMPORT_CONTEXT = 'regular';
-
-      class FirstClass {
-        @tool({
-          name: 'contextTest1',
-          description: 'First context test',
-          parameters: [],
-          endpoint: '/context-test-1'
-        })
-        public async tool1() {
-          return { result: 'test1' };
-        }
-      }
-
-      // Second: Switch to global
-      globalThis.__IMPORT_CONTEXT = 'global';
-
-      class SecondClass {
-        @tool({
-          name: 'contextTest2',
-          description: 'Second context test',
-          parameters: [],
-          endpoint: '/context-test-2'
-        })
-        public async tool2() {
-          return { result: 'test2' };
-        }
-      }
-
-      // Third: Clear context (should fallback to class inheritance)
-      globalThis.__IMPORT_CONTEXT = undefined;
-
-      class ThirdClass {
-        @tool({
-          name: 'contextTest3',
-          description: 'Third context test',
-          parameters: [],
-          endpoint: '/context-test-3'
-        })
-        public async tool3() {
-          return { result: 'test3' };
-        }
-      }
-
-      // Verify the sequence of calls
-      expect(toolsService.registerTool).toHaveBeenNthCalledWith(
-        callCount - 2, // First call
-        'contextTest1',
-        'First context test',
-        expect.any(Function),
-        [],
-        '/context-test-1',
-        [],
-        false // Should be regular
-      );
-
-      expect(toolsService.registerTool).toHaveBeenNthCalledWith(
-        callCount - 1, // Second call
-        'contextTest2',
-        'Second context test',
-        expect.any(Function),
-        [],
-        '/context-test-2',
-        [],
-        true // Should be global
-      );
-
-      expect(toolsService.registerTool).toHaveBeenNthCalledWith(
-        callCount, // Third call
-        'contextTest3',
-        'Third context test',
-        expect.any(Function),
-        [],
-        '/context-test-3',
-        [],
-        false // Should be regular (fallback to class check, ThirdClass doesn't extend GlobalToolFunction)
-      );
-
-      expect(FirstClass).toBeDefined();
-      expect(SecondClass).toBeDefined();
-      expect(ThirdClass).toBeDefined();
-    });
-  });
 });
 

package/src/decorator/Decorator.ts

@@ -1,44 +1,6 @@
 import { Parameter, AuthRequirement, ParameterType } from '../types/Models';
 import { toolsService } from '../service/Service';
 
-/**
- * Global context flag to track import context
- */
-declare global {
-  var __IMPORT_CONTEXT: 'global' | 'regular' | undefined;
-}
-
-/**
- * Helper function to check if a class extends GlobalToolFunction
- */
-function isGlobalToolFunction(constructor: any): boolean {
-  // Walk up the prototype chain to check for GlobalToolFunction
-  let currentConstructor = constructor;
-  while (currentConstructor) {
-    if (currentConstructor.name === 'GlobalToolFunction') {
-      return true;
-    }
-    currentConstructor = Object.getPrototypeOf(currentConstructor);
-  }
-  return false;
-}
-
-/**
- * Determine if tool should be registered as global based on definition context or import context
- */
-function shouldRegisterAsGlobal(targetConstructor: any): boolean {
-  // First check if there's an active import context
-  if (globalThis.__IMPORT_CONTEXT === 'global') {
-    return true;
-  }
-  if (globalThis.__IMPORT_CONTEXT === 'regular') {
-    return false;
-  }
-
-  // Fallback to checking where the tool is defined
-  return isGlobalToolFunction(targetConstructor);
-}
-
 /**
  * Configuration for @tool decorator
  */
@@ -107,18 +69,14 @@ export function tool(config: ToolConfig) {
       return originalMethod.call(instance, params, authData);
     };
 
-    // Determine if this tool should be registered as global based on definition or import context
-    const isGlobal = shouldRegisterAsGlobal(target.constructor);
-
-    // Register tool with global flag based on where it's defined or imported
+    // Immediately register with global ToolsService
     toolsService.registerTool(
       config.name,
       config.description,
       boundHandler,
       parameters,
       config.endpoint,
-      authRequirements,
-      isGlobal
+      authRequirements
     );
   };
 }

package/src/index.ts

@@ -3,5 +3,4 @@ export * from './function/GlobalToolFunction';
 export * from './types/Models';
 export * from './decorator/Decorator';
 export * from './auth/TokenVerifier';
-export * from './utils/ImportUtils';
 export { Tool, Interaction, InteractionResult } from './service/Service';

package/src/service/Service.test.ts

@@ -1,7 +1,6 @@
 import { toolsService, Tool, Interaction } from './Service';
 import { Parameter, ParameterType, AuthRequirement, OptiIdAuthDataCredentials, OptiIdAuthData } from '../types/Models';
 import { ToolFunction } from '../function/ToolFunction';
-import { GlobalToolFunction } from '../function/GlobalToolFunction';
 import { logger } from '@zaiusinc/app-sdk';
 
 // Mock the logger and other app-sdk exports
@@ -12,9 +11,6 @@ jest.mock('@zaiusinc/app-sdk', () => ({
   Function: class {
     public constructor(public request: any) {}
   },
-  GlobalFunction: class {
-    public constructor(public request: any) {}
-  },
   Response: jest.fn().mockImplementation((status, data) => ({
     status,
     data,
@@ -27,7 +23,6 @@ describe('ToolsService', () => {
   let mockTool: Tool<unknown>;
   let mockInteraction: Interaction<unknown>;
   let mockToolFunction: ToolFunction;
-  let mockGlobalToolFunction: GlobalToolFunction;
 
   beforeEach(() => {
     // Clear registered functions and interactions before each test
@@ -45,18 +40,6 @@ describe('ToolsService', () => {
       request: {} as any
     } as any;
 
-    // Create mock GlobalToolFunction - use actual class for instanceof check
-    class MockGlobalToolFunction extends GlobalToolFunction {
-      public ready = jest.fn().mockResolvedValue(true);
-      public perform = jest.fn();
-      public validateBearerToken = jest.fn().mockReturnValue(true);
-
-      public constructor() {
-        super({} as any);
-      }
-    }
-    mockGlobalToolFunction = new MockGlobalToolFunction();
-
     // Create mock tool handler
     const mockToolHandler = jest.fn().mockResolvedValue({ result: 'success' });
 
@@ -111,7 +94,6 @@ describe('ToolsService', () => {
   describe('processRequest', () => {
     describe('discovery endpoint', () => {
       it('should return registered functions for discovery endpoint', async () => {
-        // Register a regular (non-global) tool
         toolsService.registerTool(
           mockTool.name,
           mockTool.description,
@@ -120,17 +102,6 @@ describe('ToolsService', () => {
           mockTool.endpoint
         );
 
-        // Register a global tool (should not be included for regular ToolFunction)
-        toolsService.registerTool(
-          'globalTool',
-          'Global tool description',
-          jest.fn().mockResolvedValue({ result: 'global' }),
-          [new Parameter('param1', ParameterType.String, 'Test parameter', true)],
-          '/global-tool',
-          undefined,
-          true // global tool
-        );
-
         const discoveryRequest = createMockRequest({ path: '/discovery' });
         const response = await toolsService.processRequest(discoveryRequest, mockToolFunction);
 
@@ -142,11 +113,9 @@ describe('ToolsService', () => {
         const responseData = response.bodyJSON as { functions: unknown[] };
         expect(responseData).toHaveProperty('functions');
         expect(Array.isArray(responseData.functions)).toBe(true);
-
-        // Should only return the non-global tool (global tool should be filtered out)
         expect(responseData.functions).toHaveLength(1);
 
-        // Test the registered function structure - should be the non-global tool
+        // Test the registered function structure
         const registeredFunction = responseData.functions[0];
         expect(registeredFunction).toEqual({
           name: mockTool.name,
@@ -156,11 +125,6 @@ describe('ToolsService', () => {
           http_method: 'POST',
           auth_requirements: [{ provider: 'OptiID', scope_bundle: 'default', required: true }]
         });
-
-        // Verify the global tool is not included
-        const toolNames = responseData.functions.map((f: any) => f.name);
-        expect(toolNames).toContain(mockTool.name);
-        expect(toolNames).not.toContain('globalTool');
       });
 
       it('should return empty functions array when no tools are registered', async () => {
@@ -236,139 +200,6 @@ describe('ToolsService', () => {
       });
     });
 
-    describe('global discovery endpoint', () => {
-      it('should return only global tools when called from GlobalToolFunction', async () => {
-        // Register a regular tool (non-global)
-        toolsService.registerTool(
-          'regularTool',
-          'Regular tool description',
-          jest.fn().mockResolvedValue({ result: 'regular' }),
-          [new Parameter('param1', ParameterType.String, 'Test parameter', true)],
-          '/regular-tool',
-          undefined,
-          false // not global
-        );
-
-        // Register a global tool
-        toolsService.registerTool(
-          'globalTool',
-          'Global tool description',
-          jest.fn().mockResolvedValue({ result: 'global' }),
-          [new Parameter('param1', ParameterType.String, 'Test parameter', true)],
-          '/global-tool',
-          undefined,
-          true // global
-        );
-
-        const discoveryRequest = createMockRequest({ path: '/discovery' });
-        const response = await toolsService.processRequest(discoveryRequest, mockGlobalToolFunction);
-
-        expect(response.status).toBe(200);
-        expect(response).toHaveProperty('bodyJSON');
-
-        // Test the actual response structure
-        const responseData = response.bodyJSON as { functions: any[] };
-        expect(responseData).toHaveProperty('functions');
-        expect(Array.isArray(responseData.functions)).toBe(true);
-
-        // Should only return the global tool
-        expect(responseData.functions).toHaveLength(1);
-        expect(responseData.functions[0].name).toBe('globalTool');
-        expect(responseData.functions[0].endpoint).toBe('/global-tool');
-      });
-
-      it('should return empty array when no global tools are registered ' +
-         'and called from GlobalToolFunction', async () => {
-        // Register only regular tools (non-global)
-        toolsService.registerTool(
-          'regularTool1',
-          'Regular tool 1 description',
-          jest.fn().mockResolvedValue({ result: 'regular1' }),
-          [new Parameter('param1', ParameterType.String, 'Test parameter', true)],
-          '/regular-tool-1',
-          undefined,
-          false // not global
-        );
-
-        toolsService.registerTool(
-          'regularTool2',
-          'Regular tool 2 description',
-          jest.fn().mockResolvedValue({ result: 'regular2' }),
-          [new Parameter('param1', ParameterType.String, 'Test parameter', true)],
-          '/regular-tool-2',
-          undefined,
-          false // not global
-        );
-
-        const discoveryRequest = createMockRequest({ path: '/discovery' });
-        const response = await toolsService.processRequest(discoveryRequest, mockGlobalToolFunction);
-
-        expect(response.status).toBe(200);
-        expect(response).toHaveProperty('bodyJSON');
-
-        // Test the actual response structure
-        const responseData = response.bodyJSON as { functions: any[] };
-        expect(responseData).toHaveProperty('functions');
-        expect(Array.isArray(responseData.functions)).toBe(true);
-
-        // Should return empty array since no global tools are registered
-        expect(responseData.functions).toHaveLength(0);
-      });
-
-      it('should return multiple global tools when called from GlobalToolFunction', async () => {
-        // Register multiple global tools
-        toolsService.registerTool(
-          'globalTool1',
-          'Global tool 1 description',
-          jest.fn().mockResolvedValue({ result: 'global1' }),
-          [new Parameter('param1', ParameterType.String, 'Test parameter', true)],
-          '/global-tool-1',
-          undefined,
-          true // global
-        );
-
-        toolsService.registerTool(
-          'globalTool2',
-          'Global tool 2 description',
-          jest.fn().mockResolvedValue({ result: 'global2' }),
-          [new Parameter('param1', ParameterType.String, 'Test parameter', true)],
-          '/global-tool-2',
-          undefined,
-          true // global
-        );
-
-        // Register a regular tool (should not be included)
-        toolsService.registerTool(
-          'regularTool',
-          'Regular tool description',
-          jest.fn().mockResolvedValue({ result: 'regular' }),
-          [new Parameter('param1', ParameterType.String, 'Test parameter', true)],
-          '/regular-tool',
-          undefined,
-          false // not global
-        );
-
-        const discoveryRequest = createMockRequest({ path: '/discovery' });
-        const response = await toolsService.processRequest(discoveryRequest, mockGlobalToolFunction);
-
-        expect(response.status).toBe(200);
-        expect(response).toHaveProperty('bodyJSON');
-
-        // Test the actual response structure
-        const responseData = response.bodyJSON as { functions: any[] };
-        expect(responseData).toHaveProperty('functions');
-        expect(Array.isArray(responseData.functions)).toBe(true);
-
-        // Should return only the 2 global tools
-        expect(responseData.functions).toHaveLength(2);
-
-        const toolNames = responseData.functions.map((f) => f.name);
-        expect(toolNames).toContain('globalTool1');
-        expect(toolNames).toContain('globalTool2');
-        expect(toolNames).not.toContain('regularTool');
-      });
-    });
-
     describe('tool execution', () => {
       beforeEach(() => {
         toolsService.registerTool(