@optimizely-opal/opal-tool-ocp-sdk 1.0.0-beta.6 → 1.0.0-beta.7

package/src/function/ToolFunction.test.ts

@@ -53,16 +53,16 @@ jest.mock('@zaiusinc/app-sdk', () => ({
 
 // Create a concrete implementation for testing
 class TestToolFunction extends ToolFunction {
-  private mockReady: jest.MockedFunction<() => Promise<boolean>>;
+  private mockReady: jest.MockedFunction<() => Promise<{ ready: boolean; reason?: string }>>;
 
   public constructor(request?: any) {
     super(request || {});
     (this as any).request = request;
-    this.mockReady = jest.fn().mockResolvedValue(true);
+    this.mockReady = jest.fn().mockResolvedValue({ ready: true });
   }
 
   // Override the ready method with mock implementation for testing
-  protected ready(): Promise<boolean> {
+  protected ready(): Promise<{ ready: boolean; reason?: string }> {
     return this.mockReady();
   }
 
@@ -174,7 +174,7 @@ describe('ToolFunction', () => {
       const readyRequest = createReadyRequestWithAuth();
 
       toolFunction = new TestToolFunction(readyRequest);
-      toolFunction.getMockReady().mockResolvedValue(true);
+      toolFunction.getMockReady().mockResolvedValue({ ready: true });
 
       // Act
       const result = await toolFunction.perform();
@@ -190,7 +190,7 @@ describe('ToolFunction', () => {
       const readyRequest = createReadyRequestWithAuth();
 
       toolFunction = new TestToolFunction(readyRequest);
-      toolFunction.getMockReady().mockResolvedValue(false);
+      toolFunction.getMockReady().mockResolvedValue({ ready: false });
 
       // Act
       const result = await toolFunction.perform();
@@ -201,6 +201,22 @@ describe('ToolFunction', () => {
       expect(mockProcessRequest).not.toHaveBeenCalled(); // Should not call service
     });
 
+    it('should return ready: false with reason when ready method returns false with reason', async () => {
+      // Arrange
+      const readyRequest = createReadyRequestWithAuth();
+
+      toolFunction = new TestToolFunction(readyRequest);
+      toolFunction.getMockReady().mockResolvedValue({ ready: false, reason: 'Database connection failed' });
+
+      // Act
+      const result = await toolFunction.perform();
+
+      // Assert
+      expect(toolFunction.getMockReady()).toHaveBeenCalledTimes(1);
+      expect(result).toEqual(new Response(200, { ready: false, reason: 'Database connection failed' }));
+      expect(mockProcessRequest).not.toHaveBeenCalled(); // Should not call service
+    });
+
     it('should handle ready method throwing an error', async () => {
       // Arrange
       const readyRequest = createReadyRequestWithAuth();
@@ -420,224 +436,4 @@ describe('ToolFunction', () => {
       expect(toolFunction.getRequest()).toBe(mockRequest);
     });
   });
-
-  describe('internal request authentication', () => {
-    beforeEach(() => {
-      // Reset mocks before each test
-      jest.clearAllMocks();
-      setupAuthMocks();
-    });
-
-    it('should use internal authentication for /overrides endpoint', async () => {
-      const overridesRequest = {
-        path: '/overrides',
-        method: 'DELETE',
-        bodyJSON: {},
-        headers: {
-          get: jest.fn().mockImplementation((name: string) => {
-            if (name === 'Authorization' || name === 'authorization') return 'internal-token';
-            if (name === 'x-opal-thread-id') return 'test-thread-id';
-            return null;
-          })
-        }
-      };
-
-      mockProcessRequest.mockResolvedValue(mockResponse);
-      const toolFunctionOverrides = new TestToolFunction(overridesRequest);
-      const result = await toolFunctionOverrides.perform();
-
-      expect(result).toBe(mockResponse);
-      expect(mockProcessRequest).toHaveBeenCalledWith(overridesRequest, toolFunctionOverrides);
-    });
-
-    it('should throw ToolError when internal authentication fails for /overrides endpoint', async () => {
-      const overridesRequest = {
-        path: '/overrides',
-        method: 'DELETE',
-        bodyJSON: {},
-        headers: {
-          get: jest.fn().mockImplementation((name: string) => {
-            if (name === 'x-opal-thread-id') return 'test-thread-id';
-            return null; // No Authorization header
-          })
-        }
-      };
-
-      const toolFunctionOverrides = new TestToolFunction(overridesRequest);
-      const result = await toolFunctionOverrides.perform();
-
-      expect(result.status).toBe(401);
-      expect(result.bodyJSON).toEqual({
-        title: 'Unauthorized',
-        status: 401,
-        detail: 'Internal request authentication failed',
-        instance: '/overrides'
-      });
-      expect(mockProcessRequest).not.toHaveBeenCalled();
-    });
-
-    it('should use regular authentication for non-overrides endpoints', async () => {
-      const regularRequest = {
-        ...mockRequest,
-        path: '/regular-tool',
-        headers: {
-          get: jest.fn().mockImplementation((name: string) => {
-            if (name === 'x-opal-thread-id') return 'test-thread-id';
-            return null;
-          })
-        }
-      };
-
-      mockProcessRequest.mockResolvedValue(mockResponse);
-      const toolFunctionRegular = new TestToolFunction(regularRequest);
-      const result = await toolFunctionRegular.perform();
-
-      expect(result).toBe(mockResponse);
-      expect(mockProcessRequest).toHaveBeenCalledWith(regularRequest, toolFunctionRegular);
-    });
-
-    it('should handle internal authentication with valid Authorization header', async () => {
-      const overridesRequest = {
-        path: '/overrides',
-        method: 'PATCH',
-        bodyJSON: {
-          functions: [
-            {
-              name: 'test_tool',
-              description: 'Updated description'
-            }
-          ]
-        },
-        headers: {
-          get: jest.fn().mockImplementation((name: string) => {
-            if (name === 'Authorization') return 'valid-internal-token';
-            if (name === 'x-opal-thread-id') return 'test-thread-id';
-            return null;
-          })
-        }
-      };
-
-      mockProcessRequest.mockResolvedValue(mockResponse);
-      const toolFunctionOverrides = new TestToolFunction(overridesRequest);
-      const result = await toolFunctionOverrides.perform();
-
-      expect(result).toBe(mockResponse);
-      expect(mockProcessRequest).toHaveBeenCalledWith(overridesRequest, toolFunctionOverrides);
-    });
-
-    it('should handle internal authentication with lowercase authorization header', async () => {
-      const overridesRequest = {
-        path: '/overrides',
-        method: 'PATCH',
-        bodyJSON: {
-          functions: [
-            {
-              name: 'test_tool',
-              description: 'Updated description'
-            }
-          ]
-        },
-        headers: {
-          get: jest.fn().mockImplementation((name: string) => {
-            if (name === 'authorization') return 'valid-internal-token';
-            if (name === 'x-opal-thread-id') return 'test-thread-id';
-            return null;
-          })
-        }
-      };
-
-      mockProcessRequest.mockResolvedValue(mockResponse);
-      const toolFunctionOverrides = new TestToolFunction(overridesRequest);
-      const result = await toolFunctionOverrides.perform();
-
-      expect(result).toBe(mockResponse);
-      expect(mockProcessRequest).toHaveBeenCalledWith(overridesRequest, toolFunctionOverrides);
-    });
-
-    it('should fail internal authentication when token verification fails', async () => {
-      // Mock token verifier to return false for invalid token
-      mockTokenVerifier.verify.mockResolvedValue(false);
-
-      const overridesRequest = {
-        path: '/overrides',
-        method: 'DELETE',
-        bodyJSON: {},
-        headers: {
-          get: jest.fn().mockImplementation((name: string) => {
-            if (name === 'Authorization') return 'invalid-token';
-            if (name === 'x-opal-thread-id') return 'test-thread-id';
-            return null;
-          })
-        }
-      };
-
-      const toolFunctionOverrides = new TestToolFunction(overridesRequest);
-      const result = await toolFunctionOverrides.perform();
-
-      expect(result.status).toBe(401);
-      expect(result.bodyJSON).toEqual({
-        title: 'Unauthorized',
-        status: 401,
-        detail: 'Internal request authentication failed',
-        instance: '/overrides'
-      });
-      expect(mockProcessRequest).not.toHaveBeenCalled();
-    });
-
-    it('should fail internal authentication when token verifier throws error', async () => {
-      // Mock token verifier to throw an error
-      mockTokenVerifier.verify.mockRejectedValue(new Error('Token service unavailable'));
-
-      const overridesRequest = {
-        path: '/overrides',
-        method: 'DELETE',
-        bodyJSON: {},
-        headers: {
-          get: jest.fn().mockImplementation((name: string) => {
-            if (name === 'Authorization') return 'some-token';
-            if (name === 'x-opal-thread-id') return 'test-thread-id';
-            return null;
-          })
-        }
-      };
-
-      const toolFunctionOverrides = new TestToolFunction(overridesRequest);
-      const result = await toolFunctionOverrides.perform();
-
-      expect(result.status).toBe(401);
-      expect(result.bodyJSON).toEqual({
-        title: 'Unauthorized',
-        status: 401,
-        detail: 'Internal request authentication failed',
-        instance: '/overrides'
-      });
-      expect(mockProcessRequest).not.toHaveBeenCalled();
-    });
-
-    it('should fail internal authentication when headers object is missing', async () => {
-      const overridesRequest = {
-        path: '/overrides',
-        method: 'DELETE',
-        bodyJSON: {},
-        headers: {
-          get: jest.fn().mockImplementation((name: string) => {
-            if (name === 'x-opal-thread-id') return 'test-thread-id';
-            return null;
-          })
-        }
-      };
-
-      const toolFunctionOverrides = new TestToolFunction(overridesRequest);
-      const result = await toolFunctionOverrides.perform();
-
-      expect(result.status).toBe(401);
-      expect(result.bodyJSON).toEqual({
-        title: 'Unauthorized',
-        status: 401,
-        detail: 'Internal request authentication failed',
-        instance: '/overrides'
-      });
-      expect(mockProcessRequest).not.toHaveBeenCalled();
-    });
-  });
 });

package/src/function/ToolFunction.ts

@@ -1,8 +1,9 @@
 import { Function, Response, Headers, amendLogContext } from '@zaiusinc/app-sdk';
-import { authenticateRegularRequest, authenticateInternalRequest } from '../auth/AuthUtils';
+import { authenticateRegularRequest } from '../auth/AuthUtils';
 import { toolsService } from '../service/Service';
 import { ToolLogger } from '../logging/ToolLogger';
 import { ToolError } from '../types/ToolError';
+import { ReadyResponse } from '../types/Models';
 
 /**
  * Abstract base class for tool-based function execution
@@ -14,10 +15,10 @@ export abstract class ToolFunction extends Function {
    * Override this method to implement any required credentials and/or other configuration
    * exist and are valid. Reasonable caching should be utilized to prevent excessive requests to external resources.
    * @async
-   * @returns true if the opal function is ready to use
+   * @returns ReadyResponse containing ready status and optional reason when not ready
    */
-  protected ready(): Promise<boolean> {
-    return Promise.resolve(true);
+  protected ready(): Promise<ReadyResponse> {
+    return Promise.resolve({ ready: true });
   }
 
   /**
@@ -67,8 +68,8 @@ export abstract class ToolFunction extends Function {
     }
 
     if (this.request.path === '/ready') {
-      const isReady = await this.ready();
-      return new Response(200, { ready: isReady });
+      const readyResponse = await this.ready();
+      return new Response(200, readyResponse);
     }
 
     // Pass 'this' as context so decorated methods can use the existing instance
@@ -81,12 +82,6 @@ export abstract class ToolFunction extends Function {
    * @throws {ToolError} If authentication fails
    */
   private async authorizeRequest(): Promise<void> {
-    // Use internal authentication for overrides endpoint (header-based token)
-    if (this.request.path === '/overrides') {
-      await authenticateInternalRequest(this.request);
-    } else {
-      // Use regular authentication for other endpoints (body-based token with org validation)
-      await authenticateRegularRequest(this.request);
-    }
+    await authenticateRegularRequest(this.request);
   }
 }

package/src/logging/ToolLogger.test.ts

@@ -32,7 +32,6 @@ describe('ToolLogger', () => {
   const createMockRequest = (overrides: any = {}): App.Request => {
     const defaultRequest = {
       path: '/test-tool',
-      method: 'POST',
       bodyJSON: {
         parameters: {
           name: 'test',
@@ -97,7 +96,6 @@ describe('ToolLogger', () => {
       const expectedLog = {
         event: 'opal_tool_request',
         path: '/test-tool',
-        method: 'POST',
         parameters: {
           name: 'test',
           value: 'data'
@@ -120,7 +118,6 @@ describe('ToolLogger', () => {
       expectJsonLog({
         event: 'opal_tool_request',
         path: '/test-tool',
-        method: 'POST',
         parameters: null
       });
     });
@@ -138,7 +135,6 @@ describe('ToolLogger', () => {
       expectJsonLog({
         event: 'opal_tool_request',
         path: '/test-tool',
-        method: 'POST',
         parameters: {
           name: 'direct',
           action: 'test'
@@ -171,7 +167,6 @@ describe('ToolLogger', () => {
       expectJsonLog({
         event: 'opal_tool_request',
         path: '/test-tool',
-        method: 'POST',
         parameters: {
           username: 'john',
           password: '[REDACTED]',
@@ -209,7 +204,6 @@ describe('ToolLogger', () => {
       expectJsonLog({
         event: 'opal_tool_request',
         path: '/test-tool',
-        method: 'POST',
         parameters: {
           PASSWORD: '[REDACTED]',
           API_KEY: '[REDACTED]',
@@ -238,7 +232,6 @@ describe('ToolLogger', () => {
       expectJsonLog({
         event: 'opal_tool_request',
         path: '/test-tool',
-        method: 'POST',
         parameters: {
           description: `${'a'.repeat(100)}... (truncated, 150 chars total)`,
           short_field: 'normal'
@@ -262,7 +255,6 @@ describe('ToolLogger', () => {
       expectJsonLog({
         event: 'opal_tool_request',
         path: '/test-tool',
-        method: 'POST',
         parameters: {
           items: [
             ...largeArray.slice(0, 10),
@@ -299,7 +291,6 @@ describe('ToolLogger', () => {
       expectJsonLog({
         event: 'opal_tool_request',
         path: '/test-tool',
-        method: 'POST',
         parameters: {
           user: {
             name: 'John',
@@ -337,7 +328,6 @@ describe('ToolLogger', () => {
       expectJsonLog({
         event: 'opal_tool_request',
         path: '/test-tool',
-        method: 'POST',
         parameters: {
           nullValue: null,
           emptyString: '',
@@ -363,7 +353,6 @@ describe('ToolLogger', () => {
       expectJsonLog({
         event: 'opal_tool_request',
         path: '/test-tool',
-        method: 'POST',
         parameters: {
           credentials: '[REDACTED]',
           public_list: ['item1', 'item2']
@@ -392,7 +381,6 @@ describe('ToolLogger', () => {
       expectJsonLog({
         event: 'opal_tool_request',
         path: '/test-tool',
-        method: 'POST',
         parameters: {
           auth: '[REDACTED]',
           public_config: {
@@ -508,9 +496,7 @@ describe('ToolLogger', () => {
       // First item: deeply nested object with inner parts replaced by placeholder
       expect(items[0]).toEqual({
         level2: {
-          level3: {
-            level4: '[MAX_DEPTH_EXCEEDED]'
-          }
+          level3: '[MAX_DEPTH_EXCEEDED]'
         }
       });
 
@@ -523,9 +509,7 @@ describe('ToolLogger', () => {
       // Fourth item: another deeply nested object with inner parts replaced by placeholder
       expect(items[3]).toEqual({
         level2: {
-          level3: {
-            level4: '[MAX_DEPTH_EXCEEDED]'
-          }
+          level3: '[MAX_DEPTH_EXCEEDED]'
         }
       });
     });
@@ -710,7 +694,6 @@ describe('ToolLogger', () => {
       expectJsonLog({
         event: 'opal_tool_request',
         path: '/test-tool',
-        method: 'POST',
         parameters: {}
       });
     });
@@ -729,7 +712,6 @@ describe('ToolLogger', () => {
       expectJsonLog({
         event: 'opal_tool_request',
         path: '/test-tool',
-        method: 'POST',
         parameters: {
           field: 'value'
         }
@@ -756,7 +738,6 @@ describe('ToolLogger', () => {
       expectJsonLog({
         event: 'opal_tool_request',
         path: '/test-tool',
-        method: 'POST',
         parameters: {
           string: 'text',
           number: 42,
@@ -768,102 +749,5 @@ describe('ToolLogger', () => {
         }
       });
     });
-
-    it('should handle tool override request with enhanced parameter descriptions', () => {
-      const overrideRequest = {
-        tools: [
-          {
-            name: 'calculate_experiment_runtime',
-            description: 'OVERRIDDEN: Enhanced experiment runtime calculator with advanced features',
-            parameters: [
-              {
-                name: 'BCR',
-                type: 'number',
-                description: 'OVERRIDDEN: Enhanced baseline conversion rate with validation',
-                required: true
-              },
-              {
-                name: 'MDE',
-                type: 'number',
-                description: 'OVERRIDDEN: Enhanced minimum detectable effect calculation',
-                required: true
-              },
-              {
-                name: 'sigLevel',
-                type: 'number',
-                description: 'OVERRIDDEN: Enhanced statistical significance level',
-                required: true
-              },
-              {
-                name: 'numVariations',
-                type: 'number',
-                description: 'OVERRIDDEN: Enhanced number of variations handling',
-                required: true
-              },
-              {
-                name: 'dailyVisitors',
-                type: 'number',
-                description: 'OVERRIDDEN: Enhanced daily visitor count with forecasting',
-                required: true
-              }
-            ]
-          }
-          // Note: NOT including calculate_sample_size in override
-        ]
-      };
-
-      const req = createMockRequest({
-        path: '/overrides',
-        bodyJSON: overrideRequest
-      });
-
-      ToolLogger.logRequest(req);
-
-      expectJsonLog({
-        event: 'opal_tool_request',
-        path: '/overrides',
-        method: 'POST',
-        parameters: {
-          tools: [
-            {
-              name: 'calculate_experiment_runtime',
-              description: 'OVERRIDDEN: Enhanced experiment runtime calculator with advanced features',
-              parameters: [
-                {
-                  name: 'BCR',
-                  type: 'number',
-                  description: 'OVERRIDDEN: Enhanced baseline conversion rate with validation',
-                  required: true
-                },
-                {
-                  name: 'MDE',
-                  type: 'number',
-                  description: 'OVERRIDDEN: Enhanced minimum detectable effect calculation',
-                  required: true
-                },
-                {
-                  name: 'sigLevel',
-                  type: 'number',
-                  description: 'OVERRIDDEN: Enhanced statistical significance level',
-                  required: true
-                },
-                {
-                  name: 'numVariations',
-                  type: 'number',
-                  description: 'OVERRIDDEN: Enhanced number of variations handling',
-                  required: true
-                },
-                {
-                  name: 'dailyVisitors',
-                  type: 'number',
-                  description: 'OVERRIDDEN: Enhanced daily visitor count with forecasting',
-                  required: true
-                }
-              ]
-            }
-          ]
-        }
-      });
-    });
   });
 });

package/src/logging/ToolLogger.ts

@@ -75,7 +75,7 @@ export class ToolLogger {
 
     if (Array.isArray(data)) {
       const truncated = data.slice(0, this.MAX_ARRAY_ITEMS);
-      const result = truncated.map((item) => this.redactSensitiveData(item, maxDepth));
+      const result = truncated.map((item) => this.redactSensitiveData(item, maxDepth - 1));
       if (data.length > this.MAX_ARRAY_ITEMS) {
         result.push(`... (${data.length - this.MAX_ARRAY_ITEMS} more items truncated)`);
       }
@@ -146,7 +146,6 @@ export class ToolLogger {
     const requestLog = {
       event: 'opal_tool_request',
       path: req.path,
-      method: req.method,
       parameters: this.createParameterSummary(params)
     };