@optimizely-opal/opal-tool-ocp-sdk 1.0.0-OCP-1449.1 → 1.0.0-beta.10

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();

package/src/function/ToolFunction.ts

@@ -3,6 +3,7 @@ import { authenticateRegularRequest, authenticateInternalRequest } from '../auth
 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 | boolean> {
+    return Promise.resolve({ ready: true });
   }
 
   /**
@@ -67,8 +68,11 @@ export abstract class ToolFunction extends Function {
     }
 
     if (this.request.path === '/ready') {
-      const isReady = await this.ready();
-      return new Response(200, { ready: isReady });
+      const readyResult = await this.ready();
+      const readyResponse = typeof readyResult === 'boolean'
+        ? { ready: readyResult }
+        : readyResult;
+      return new Response(200, readyResponse);
     }
 
     // Pass 'this' as context so decorated methods can use the existing instance

package/src/index.ts

@@ -4,4 +4,4 @@ export * from './types/Models';
 export * from './types/ToolError';
 export * from './decorator/Decorator';
 export * from './auth/TokenVerifier';
-export { Tool, Interaction, InteractionResult } from './service/Service';
+export { Tool, Interaction, InteractionResult, NestedInteractions } from './service/Service';

package/src/logging/ToolLogger.test.ts

@@ -88,6 +88,30 @@ describe('ToolLogger', () => {
     return response;
   };
 
+  const createMockResponseWithBody = (
+    status: number,
+    bodyData: Uint8Array | undefined,
+    contentType: string
+  ): App.Response => {
+    const mockHeaders = {
+      get: jest.fn().mockReturnValue(contentType)
+    };
+
+    const response = {
+      status,
+      headers: mockHeaders
+    } as any;
+
+    Object.defineProperty(response, 'bodyAsU8Array', {
+      get() {
+        return bodyData;
+      },
+      enumerable: true
+    });
+
+    return response;
+  };
+
   describe('logRequest', () => {
     it('should log request with parameters', () => {
       const req = createMockRequest();
@@ -240,7 +264,7 @@ describe('ToolLogger', () => {
         path: '/test-tool',
         method: 'POST',
         parameters: {
-          description: `${'a'.repeat(100)}... (truncated, 150 chars total)`,
+          description: `${'a'.repeat(118)}...[22 truncated]...${'a'.repeat(10)}`,
           short_field: 'normal'
         }
       });
@@ -265,8 +289,8 @@ describe('ToolLogger', () => {
         method: 'POST',
         parameters: {
           items: [
-            ...largeArray.slice(0, 10),
-            '... (5 more items truncated)'
+            ...largeArray.slice(0, 2),
+            '... (13 more items truncated)'
           ],
           small_array: ['a', 'b']
         }
@@ -420,6 +444,21 @@ describe('ToolLogger', () => {
       // Should not throw error or cause infinite recursion
       expect(() => ToolLogger.logRequest(req)).not.toThrow();
       expect(mockLogger.info).toHaveBeenCalled();
+
+      // Verify that deeply nested parts are replaced with placeholder
+      const logCall = mockLogger.info.mock.calls[0];
+      const loggedData = JSON.parse(logCall[1]);
+
+      // Navigate to a deeply nested level that should be truncated
+      // At maxDepth=5, objects beyond depth 5 should be replaced
+      const nested1 = loggedData.parameters.deep.nested;
+      expect(nested1).toBeDefined(); // depth 2
+      const nested2 = nested1.nested;
+      expect(nested2).toBeDefined(); // depth 3
+      const nested3 = nested2.nested;
+      expect(nested3).toBeDefined(); // depth 4
+      const nested4 = nested3.nested;
+      expect(nested4).toBe('[MAX_DEPTH_EXCEEDED]'); // depth 5, should be truncated
     });
 
     it('should replace deeply nested objects with MAX_DEPTH_EXCEEDED placeholder', () => {
@@ -465,6 +504,7 @@ describe('ToolLogger', () => {
         level1: {
           items: [
             {
+              shallow: 'data',
               level2: {
                 level3: {
                   level4: {
@@ -504,9 +544,12 @@ describe('ToolLogger', () => {
       const loggedData = JSON.parse(logCall[1]);
 
       const items = loggedData.parameters.level1.items;
+      expect(items.length).toBe(3);
 
       // First item: deeply nested object with inner parts replaced by placeholder
+      // shallow object should be processed normally
       expect(items[0]).toEqual({
+        shallow: 'data',
         level2: {
           level3: {
             level4: '[MAX_DEPTH_EXCEEDED]'
@@ -516,18 +559,6 @@ describe('ToolLogger', () => {
 
       // Second item: simple string should remain unchanged
       expect(items[1]).toBe('simple-item');
-
-      // Third item: shallow object should be processed normally
-      expect(items[2]).toEqual({ shallow: 'data' });
-
-      // Fourth item: another deeply nested object with inner parts replaced by placeholder
-      expect(items[3]).toEqual({
-        level2: {
-          level3: {
-            level4: '[MAX_DEPTH_EXCEEDED]'
-          }
-        }
-      });
     });
   });
 
@@ -545,7 +576,8 @@ describe('ToolLogger', () => {
         status: 200,
         contentType: 'application/json',
         contentLength: 34, // JSON.stringify({ result: 'success', data: 'test' }).length
-        success: true
+        success: true,
+        responseBody: { result: 'success', data: 'test' }
       };
 
       expect(mockLogger.info).toHaveBeenCalledWith(
@@ -567,14 +599,14 @@ describe('ToolLogger', () => {
         status: 400,
         contentType: 'application/json',
         contentLength: 23,
-        success: false
+        success: false,
+        responseBody: { error: 'Bad request' }
       });
     });
 
-    it('should handle response without bodyJSON', () => {
+    it('should handle response without body data', () => {
       const req = createMockRequest();
-      const response = createMockResponse(204);
-      response.bodyJSON = undefined;
+      const response = createMockResponseWithBody(204, undefined, 'application/json');
 
       ToolLogger.logResponse(req, response);
 
@@ -600,11 +632,12 @@ describe('ToolLogger', () => {
         status: 200,
         contentType: 'application/json',
         contentLength: 15,
-        success: true
+        success: true,
+        responseBody: { data: 'test' }
       });
     });
 
-    it('should handle unknown content type', () => {
+    it('should handle unknown content type - response body not logged', () => {
       const req = createMockRequest();
       const response = createMockResponse(200, { data: 'test' });
       response.headers.get = jest.fn().mockReturnValue(null);
@@ -623,21 +656,35 @@ describe('ToolLogger', () => {
 
     it('should handle content length calculation error', () => {
       const req = createMockRequest();
-      const circularObj: any = { name: 'test' };
-      circularObj.self = circularObj; // Create circular reference
 
-      const response = createMockResponse(200, circularObj);
-
-      ToolLogger.logResponse(req, response);
+      // Simulate a response that will cause errors when trying to calculate content length
+      // by providing a Uint8Array but the underlying data causes issues
+      const mockHeaders = {
+        get: jest.fn().mockReturnValue('application/json')
+      };
 
-      expectJsonLog({
-        event: 'opal_tool_response',
-        path: '/test-tool',
+      const response = {
         status: 200,
-        contentType: 'application/json',
-        contentLength: 'unknown',
-        success: true
+        headers: mockHeaders
+      } as any;
+
+      // Create a getter that throws when accessed (simulating serialization error)
+      Object.defineProperty(response, 'bodyAsU8Array', {
+        get() {
+          throw new Error('Circular structure');
+        },
+        enumerable: true
       });
+
+      ToolLogger.logResponse(req, response);
+
+      // The error causes both contentLength and responseBody to fail gracefully
+      const logCall = mockLogger.info.mock.calls[0];
+      const loggedData = JSON.parse(logCall[1]);
+
+      expect(loggedData.event).toBe('opal_tool_response');
+      expect(loggedData.contentLength).toBe('unknown');
+      expect(loggedData.responseBody).toBeUndefined();
     });
 
     it('should correctly identify success status codes', () => {
@@ -659,14 +706,16 @@ describe('ToolLogger', () => {
         const response = createMockResponse(status);
         ToolLogger.logResponse(req, response);
 
-        expectJsonLog({
-          event: 'opal_tool_response',
-          path: '/test-tool',
-          status,
-          contentType: 'application/json',
-          contentLength: 2,
-          success: expected
-        });
+        const logCall = mockLogger.info.mock.calls[0];
+        const loggedData = JSON.parse(logCall[1]);
+
+        expect(loggedData.event).toBe('opal_tool_response');
+        expect(loggedData.path).toBe('/test-tool');
+        expect(loggedData.status).toBe(status);
+        expect(loggedData.contentType).toBe('application/json');
+        expect(loggedData.contentLength).toBe(2);
+        expect(loggedData.success).toBe(expected);
+        expect(loggedData.responseBody).toEqual({});
       });
     });
 
@@ -674,29 +723,148 @@ describe('ToolLogger', () => {
       const req = createMockRequest();
 
       const testCases = [
-        'application/json',
-        'text/plain',
-        'application/xml',
-        'text/html'
+        { contentType: 'application/json', expectedBody: { data: 'test' } },
+        { contentType: 'text/plain', expectedBody: '{"data":"test"}' },
+        { contentType: 'text/html', expectedBody: '{"data":"test"}' }
       ];
 
-      testCases.forEach((contentType) => {
+      testCases.forEach(({ contentType, expectedBody }) => {
         mockLogger.info.mockClear();
         const response = createMockResponse(200, { data: 'test' });
         response.headers.get = jest.fn().mockReturnValue(contentType);
 
         ToolLogger.logResponse(req, response);
 
-        expectJsonLog({
-          event: 'opal_tool_response',
-          path: '/test-tool',
-          status: 200,
-          contentType,
-          contentLength: 15,
-          success: true
-        });
+        const logCall = mockLogger.info.mock.calls[0];
+        const loggedData = JSON.parse(logCall[1]);
+
+        expect(loggedData.event).toBe('opal_tool_response');
+        expect(loggedData.path).toBe('/test-tool');
+        expect(loggedData.status).toBe(200);
+        expect(loggedData.contentType).toBe(contentType);
+        expect(loggedData.contentLength).toBe(15);
+        expect(loggedData.success).toBe(true);
+        expect(loggedData.responseBody).toEqual(expectedBody);
+      });
+    });
+
+    it('should log short successful response body', () => {
+      const req = createMockRequest();
+      const response = createMockResponse(200, { result: 'success', data: 'test' });
+
+      ToolLogger.logResponse(req, response);
+
+      const logCall = mockLogger.info.mock.calls[0];
+      const loggedData = JSON.parse(logCall[1]);
+
+      expect(loggedData.responseBody).toEqual({ result: 'success', data: 'test' });
+      expect(loggedData.success).toBe(true);
+    });
+
+    it('should truncate long successful response body to 256 chars', () => {
+      const req = createMockRequest();
+      const longData = 'a'.repeat(300);
+      const response = createMockResponse(200, { message: longData });
+
+      ToolLogger.logResponse(req, response);
+
+      const logCall = mockLogger.info.mock.calls[0];
+      const loggedData = JSON.parse(logCall[1]);
+
+      // The response body should be truncated when stringified
+      expect(loggedData.responseBody.message).toContain(' truncated]...');
+    });
+
+    it('truncates long properties of failed responses', () => {
+      const req = createMockRequest();
+      const longData = 'a'.repeat(150);
+      const response = createMockResponse(400, { error: 'Bad request', details: longData });
+
+      ToolLogger.logResponse(req, response);
+
+      const logCall = mockLogger.info.mock.calls[0];
+      const loggedData = JSON.parse(logCall[1]);
+
+      // Failed responses should include full body, not truncated
+      expect(loggedData.responseBody.error).toEqual('Bad request');
+      expect(loggedData.responseBody.details).toContain(' truncated]...');
+      expect(loggedData.success).toBe(false);
+    });
+
+    it('should redact sensitive data in response body', () => {
+      const req = createMockRequest();
+      const response = createMockResponse(200, {
+        user: 'john',
+        password: 'secret123',
+        api_key: 'key456',
+        data: 'public'
+      });
+
+      ToolLogger.logResponse(req, response);
+
+      const logCall = mockLogger.info.mock.calls[0];
+      const loggedData = JSON.parse(logCall[1]);
+
+      expect(loggedData.responseBody).toEqual({
+        user: 'john',
+        password: '[REDACTED]',
+        api_key: '[REDACTED]',
+        data: 'public'
       });
     });
+
+    it('should handle response with no body', () => {
+      const req = createMockRequest();
+      const response = createMockResponseWithBody(204, undefined, 'application/json');
+
+      ToolLogger.logResponse(req, response);
+
+      const logCall = mockLogger.info.mock.calls[0];
+      const loggedData = JSON.parse(logCall[1]);
+
+      expect(loggedData.responseBody).toBeUndefined();
+      expect(loggedData.success).toBe(true);
+    });
+
+    it('should handle plain text response body', () => {
+      const req = createMockRequest();
+      const plainText = 'This is a plain text response';
+      const response = createMockResponseWithBody(200, new Uint8Array(Buffer.from(plainText)), 'text/plain');
+
+      ToolLogger.logResponse(req, response);
+
+      const logCall = mockLogger.info.mock.calls[0];
+      const loggedData = JSON.parse(logCall[1]);
+
+      expect(loggedData.responseBody).toBe(plainText);
+    });
+
+    it('should truncate long plain text successful responses', () => {
+      const req = createMockRequest();
+      const longText = 'a'.repeat(300);
+      const response = createMockResponseWithBody(200, new Uint8Array(Buffer.from(longText)), 'text/plain');
+
+      ToolLogger.logResponse(req, response);
+
+      const logCall = mockLogger.info.mock.calls[0];
+      const loggedData = JSON.parse(logCall[1]);
+
+      expect(loggedData.responseBody).toBe(`${'a'.repeat(256)}... (truncated)`);
+    });
+
+    it('should not truncate long plain text failed responses', () => {
+      const req = createMockRequest();
+      const longText = 'a'.repeat(150);
+      const response = createMockResponseWithBody(500, new Uint8Array(Buffer.from(longText)), 'text/plain');
+
+      ToolLogger.logResponse(req, response);
+
+      const logCall = mockLogger.info.mock.calls[0];
+      const loggedData = JSON.parse(logCall[1]);
+
+      expect(loggedData.responseBody).toBe(longText);
+      expect(loggedData.success).toBe(false);
+    });
   });
 
   describe('edge cases', () => {
@@ -743,7 +911,7 @@ describe('ToolLogger', () => {
             string: 'text',
             number: 42,
             boolean: true,
-            array: [1, 2, 3],
+            array: [1, 2],
             object: { nested: 'value' },
             nullValue: null,
             password: 'secret'
@@ -761,7 +929,7 @@ describe('ToolLogger', () => {
           string: 'text',
           number: 42,
           boolean: true,
-          array: [1, 2, 3],
+          array: [1, 2],
           object: { nested: 'value' },
           nullValue: null,
           password: '[REDACTED]'
@@ -841,24 +1009,7 @@ describe('ToolLogger', () => {
                   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
-                }
+                '... (3 more items truncated)'
               ]
             }
           ]