@optimizely-opal/opal-tool-ocp-sdk 1.0.0-OCP-1442.5 → 1.0.0-OCP-1449.1

package/src/service/Service.test.ts

@@ -1,42 +1,80 @@
+/* eslint-disable @typescript-eslint/no-unsafe-call */
 import { toolsService, Tool, Interaction } from './Service';
 import { Parameter, ParameterType, AuthRequirement, OptiIdAuthDataCredentials, OptiIdAuthData } from '../types/Models';
+import { ToolError } from '../types/ToolError';
 import { ToolFunction } from '../function/ToolFunction';
 import { logger } from '@zaiusinc/app-sdk';
 
 // Mock the logger and other app-sdk exports
-jest.mock('@zaiusinc/app-sdk', () => ({
-  logger: {
-    error: jest.fn()
-  },
-  Function: class {
-    public constructor(public request: any) {}
-  },
-  Headers: class {
-    public constructor(headers: string[][] = []) {
-      this.headers = {};
-      headers.forEach(([name, value]) => {
-        this.headers[name.toLowerCase()] = value;
-      });
-    }
-    public headers: { [key: string]: string };
-    public set(name: string, value: string) {
-      this.headers[name.toLowerCase()] = value;
-    }
-    public get(name: string) {
-      return this.headers[name.toLowerCase()];
-    }
-    public has(name: string) {
-      return name.toLowerCase() in this.headers;
+jest.mock('@zaiusinc/app-sdk', () => {
+  const mockKvStoreInstance = {
+    get: jest.fn(),
+    put: jest.fn(),
+    patch: jest.fn(),
+    delete: jest.fn()
+  };
+
+  const mockApp = {
+    storage: {
+      kvStore: mockKvStoreInstance
+    },
+    Response: jest.fn().mockImplementation((status, data, headers) => ({
+      status,
+      data,
+      bodyJSON: data,
+      bodyAsU8Array: new Uint8Array(),
+      headers: headers || { get: jest.fn(), has: jest.fn(), set: jest.fn() }
+    })),
+    Function: class {
+      public constructor(public request: any) {}
     }
-  },
-  Response: jest.fn().mockImplementation((status, data, headers) => ({
-    status,
-    data,
-    bodyJSON: data,
-    bodyAsU8Array: new Uint8Array(),
-    headers: headers || { get: jest.fn(), has: jest.fn(), set: jest.fn() }
-  }))
-}));
+  };
+
+  return {
+    ...mockApp,
+    default: mockApp,
+    App: mockApp,
+    getAppContext: jest.fn().mockReturnValue({
+      manifest: { meta: { version: 'app-v1' } }
+    }),
+    logger: {
+      error: jest.fn(),
+      info: jest.fn(),
+      warn: jest.fn(),
+      debug: jest.fn()
+    },
+    Headers: class {
+      public constructor(headers: string[][] = []) {
+        this.headers = {};
+        headers.forEach(([name, value]) => {
+          this.headers[name.toLowerCase()] = value;
+        });
+      }
+      public headers: { [key: string]: string };
+      public set(name: string, value: string) {
+        this.headers[name.toLowerCase()] = value;
+      }
+      public get(name: string) {
+        return this.headers[name.toLowerCase()];
+      }
+      public has(name: string) {
+        return name.toLowerCase() in this.headers;
+      }
+    },
+    Response: jest.fn().mockImplementation((status, data, headers) => ({
+      status,
+      data,
+      bodyJSON: data,
+      bodyAsU8Array: new Uint8Array(),
+      headers: headers || { get: jest.fn(), has: jest.fn(), set: jest.fn() }
+    }))
+  };
+});
+
+// Get the mocked kvStore for use in tests
+const { storage } = jest.requireMock('@zaiusinc/app-sdk');
+const mockKvStore = storage.kvStore;
+
 
 describe('ToolsService', () => {
   let mockTool: Tool<unknown>;
@@ -370,7 +408,7 @@ describe('ToolsService', () => {
         );
       });
 
-      it('should return 500 error when tool handler throws an error', async () => {
+      it('should return 500 error in RFC 9457 format when tool handler throws a regular error', async () => {
         const errorMessage = 'Tool execution failed';
         jest.mocked(mockTool.handler).mockRejectedValueOnce(new Error(errorMessage));
 
@@ -378,6 +416,13 @@ describe('ToolsService', () => {
         const response = await toolsService.processRequest(mockRequest, mockToolFunction);
 
         expect(response.status).toBe(500);
+        expect(response.bodyJSON).toEqual({
+          title: 'Internal Server Error',
+          status: 500,
+          detail: errorMessage,
+          instance: mockTool.endpoint
+        });
+        expect(response.headers.get('content-type')).toBe('application/problem+json');
         expect(logger.error).toHaveBeenCalledWith(
           `Error in function ${mockTool.name}:`,
           expect.any(Error)
@@ -391,6 +436,67 @@ describe('ToolsService', () => {
         const response = await toolsService.processRequest(mockRequest, mockToolFunction);
 
         expect(response.status).toBe(500);
+        expect(response.bodyJSON).toEqual({
+          title: 'Internal Server Error',
+          status: 500,
+          detail: 'An unexpected error occurred',
+          instance: mockTool.endpoint
+        });
+        expect(response.headers.get('content-type')).toBe('application/problem+json');
+      });
+
+      it('should return custom status code when tool handler throws ToolError', async () => {
+        const toolError = new ToolError('Resource not found', 404, 'The requested task does not exist');
+        jest.mocked(mockTool.handler).mockRejectedValueOnce(toolError);
+
+        const mockRequest = createMockRequest();
+        const response = await toolsService.processRequest(mockRequest, mockToolFunction);
+
+        expect(response.status).toBe(404);
+        expect(response.bodyJSON).toEqual({
+          title: 'Resource not found',
+          status: 404,
+          detail: 'The requested task does not exist',
+          instance: mockTool.endpoint
+        });
+        expect(response.headers.get('content-type')).toBe('application/problem+json');
+        expect(logger.error).toHaveBeenCalledWith(
+          `Error in function ${mockTool.name}:`,
+          expect.any(ToolError)
+        );
+      });
+
+      it('should return ToolError without detail field when detail is not provided', async () => {
+        const toolError = new ToolError('Bad request', 400);
+        jest.mocked(mockTool.handler).mockRejectedValueOnce(toolError);
+
+        const mockRequest = createMockRequest();
+        const response = await toolsService.processRequest(mockRequest, mockToolFunction);
+
+        expect(response.status).toBe(400);
+        expect(response.bodyJSON).toEqual({
+          title: 'Bad request',
+          status: 400,
+          instance: mockTool.endpoint
+        });
+        expect(response.bodyJSON).not.toHaveProperty('detail');
+        expect(response.headers.get('content-type')).toBe('application/problem+json');
+      });
+
+      it('should default to 500 when ToolError is created without status', async () => {
+        const toolError = new ToolError('Database error');
+        jest.mocked(mockTool.handler).mockRejectedValueOnce(toolError);
+
+        const mockRequest = createMockRequest();
+        const response = await toolsService.processRequest(mockRequest, mockToolFunction);
+
+        expect(response.status).toBe(500);
+        expect(response.bodyJSON).toEqual({
+          title: 'Database error',
+          status: 500,
+          instance: mockTool.endpoint
+        });
+        expect(response.headers.get('content-type')).toBe('application/problem+json');
       });
     });
 
@@ -488,7 +594,7 @@ describe('ToolsService', () => {
         );
       });
 
-      it('should return 500 error when interaction handler throws an error', async () => {
+      it('should return 500 error in RFC 9457 format when interaction handler throws a regular error', async () => {
         const errorMessage = 'Interaction execution failed';
         jest.mocked(mockInteraction.handler).mockRejectedValueOnce(new Error(errorMessage));
 
@@ -500,11 +606,43 @@ describe('ToolsService', () => {
         const response = await toolsService.processRequest(interactionRequest, mockToolFunction);
 
         expect(response.status).toBe(500);
+        expect(response.bodyJSON).toEqual({
+          title: 'Internal Server Error',
+          status: 500,
+          detail: errorMessage,
+          instance: mockInteraction.endpoint
+        });
+        expect(response.headers.get('content-type')).toBe('application/problem+json');
         expect(logger.error).toHaveBeenCalledWith(
           `Error in function ${mockInteraction.name}:`,
           expect.any(Error)
         );
       });
+
+      it('should return custom status code when interaction handler throws ToolError', async () => {
+        const toolError = new ToolError('Webhook validation failed', 400, 'Invalid signature');
+        jest.mocked(mockInteraction.handler).mockRejectedValueOnce(toolError);
+
+        const interactionRequest = createMockRequest({
+          path: '/test-interaction',
+          bodyJSON: { data: { param1: 'test-value' } }
+        });
+
+        const response = await toolsService.processRequest(interactionRequest, mockToolFunction);
+
+        expect(response.status).toBe(400);
+        expect(response.bodyJSON).toEqual({
+          title: 'Webhook validation failed',
+          status: 400,
+          detail: 'Invalid signature',
+          instance: mockInteraction.endpoint
+        });
+        expect(response.headers.get('content-type')).toBe('application/problem+json');
+        expect(logger.error).toHaveBeenCalledWith(
+          `Error in function ${mockInteraction.name}:`,
+          expect.any(ToolError)
+        );
+      });
     });
 
     describe('error cases', () => {
@@ -799,4 +937,409 @@ describe('ToolsService', () => {
       });
     });
   });
+
+  describe('Override functionality', () => {
+    beforeEach(() => {
+      // Reset KV store mocks
+      mockKvStore.get.mockReset();
+      mockKvStore.put.mockReset();
+      mockKvStore.patch.mockReset();
+      mockKvStore.delete.mockReset();
+
+      // Register some test tools for override testing
+      toolsService.registerTool(
+        'search_tool',
+        'Search for information',
+        jest.fn().mockResolvedValue({ result: 'search success' }),
+        [new Parameter('query', ParameterType.String, 'Search query', true)],
+        '/search'
+      );
+
+      toolsService.registerTool(
+        'calculator',
+        'Perform calculations',
+        jest.fn().mockResolvedValue({ result: 'calculation success' }),
+        [
+          new Parameter('operation', ParameterType.String, 'Math operation', true),
+          new Parameter('numbers', ParameterType.String, 'Numbers to calculate', true)
+        ],
+        '/calculate'
+      );
+
+      // Mock ToolFunction constructor name for getAppVersionId and getFunctionName
+      Object.defineProperty(mockToolFunction.constructor, 'name', {
+        value: 'TestFunction',
+        configurable: true
+      });
+    });
+
+    describe('Discovery endpoint with overrides', () => {
+      it('should return original functions when no overrides exist', async () => {
+        // Mock KV store to return no overrides
+        mockKvStore.get.mockResolvedValue(null);
+
+        const request = createMockRequest({ path: '/discovery', method: 'GET' });
+        const response = await toolsService.processRequest(request, mockToolFunction);
+
+        expect(response.status).toBe(200);
+        expect(mockKvStore.get).toHaveBeenCalledWith('app-v1:TestFunction:opal-tools-overrides');
+
+        const responseData = response.bodyJSON as { functions: any[] };
+        expect(responseData.functions).toHaveLength(2);
+
+        const searchTool = responseData.functions.find((f) => f.name === 'search_tool');
+        expect(searchTool.description).toBe('Search for information');
+
+        const calculator = responseData.functions.find((f) => f.name === 'calculator');
+        expect(calculator.description).toBe('Perform calculations');
+      });
+
+      it('should apply overrides when they exist', async () => {
+        // Mock KV store to return overrides in the new map format
+        const storedOverrides = {
+          search_tool: {
+            name: 'search_tool',
+            description: 'Enhanced search with AI capabilities',
+            parameters: [
+              {
+                name: 'query',
+                description: 'AI-powered search query'
+              }
+            ]
+          }
+        };
+
+        mockKvStore.get.mockResolvedValue(storedOverrides);
+
+        const request = createMockRequest({ path: '/discovery', method: 'GET' });
+        const response = await toolsService.processRequest(request, mockToolFunction);
+
+        expect(response.status).toBe(200);
+
+        const responseData = response.bodyJSON as { functions: any[] };
+        expect(responseData.functions).toHaveLength(2);
+
+        // Check that search_tool has overridden description and parameters
+        const searchTool = responseData.functions.find((f) => f.name === 'search_tool');
+        expect(searchTool.description).toBe('Enhanced search with AI capabilities');
+        expect(searchTool.parameters).toHaveLength(1); // Only the original 'query' parameter
+        expect(searchTool.parameters[0].description).toBe('AI-powered search query');
+
+        // Check that calculator remains unchanged
+        const calculator = responseData.functions.find((f) => f.name === 'calculator');
+        expect(calculator.description).toBe('Perform calculations');
+        expect(calculator.parameters).toHaveLength(2);
+      });
+
+      it('should handle KV store errors gracefully', async () => {
+        // Mock KV store to throw an error
+        mockKvStore.get.mockRejectedValue(new Error('KV store unavailable'));
+
+        const request = createMockRequest({ path: '/discovery', method: 'GET' });
+        const response = await toolsService.processRequest(request, mockToolFunction);
+
+        expect(response.status).toBe(200);
+
+        // Should return original functions despite the error
+        const responseData = response.bodyJSON as { functions: any[] };
+        expect(responseData.functions).toHaveLength(2);
+      });
+
+      it('should handle KV store errors gracefully when getting overrides fails', async () => {
+        // Mock KV store to throw an error when getting overrides
+        mockKvStore.get.mockRejectedValue(new Error('KV store connection failed'));
+
+        const request = createMockRequest({ path: '/discovery', method: 'GET' });
+        const response = await toolsService.processRequest(request, mockToolFunction);
+
+        expect(response.status).toBe(200);
+
+        // Should return original functions despite the error
+        const responseData = response.bodyJSON as { functions: any[] };
+        expect(responseData.functions).toHaveLength(2);
+      });
+    });
+
+    describe('PATCH /overrides endpoint', () => {
+      it('should save new overrides successfully', async () => {
+        const overrideData = {
+          functions: [
+            {
+              name: 'search_tool',
+              description: 'Enhanced search functionality',
+              parameters: [
+                {
+                  name: 'query',
+                  type: 'string',
+                  description: 'Search query',
+                  required: true
+                }
+              ]
+            }
+          ]
+        };
+
+        const request = createMockRequest({
+          path: '/overrides',
+          method: 'PATCH',
+          bodyJSON: overrideData,
+          body: JSON.stringify(overrideData)
+        });
+
+        const response = await toolsService.processRequest(request, mockToolFunction);
+
+        expect(response.status).toBe(200);
+        expect(mockKvStore.patch).toHaveBeenCalledWith(
+          'app-v1:TestFunction:opal-tools-overrides',
+          {
+            search_tool: {
+              name: 'search_tool',
+              description: 'Enhanced search functionality',
+              parameters: [
+                {
+                  name: 'query',
+                  type: 'string',
+                  description: 'Search query',
+                  required: true
+                }
+              ]
+            }
+          }
+        );
+      });
+
+      it('should merge with existing overrides', async () => {
+        const newOverrideData = {
+          functions: [
+            {
+              name: 'new_tool',
+              description: 'New tool',
+              parameters: []
+            }
+          ]
+        };
+
+        const request = createMockRequest({
+          path: '/overrides',
+          method: 'PATCH',
+          bodyJSON: newOverrideData,
+          body: JSON.stringify(newOverrideData)
+        });
+
+        const response = await toolsService.processRequest(request, mockToolFunction);
+
+        expect(response.status).toBe(200);
+
+        // Verify that the new tool is saved using patch (which handles merging automatically)
+        expect(mockKvStore.patch).toHaveBeenCalledWith(
+          'app-v1:TestFunction:opal-tools-overrides',
+          {
+            new_tool: {
+              name: 'new_tool',
+              description: 'New tool',
+              parameters: []
+            }
+          }
+        );
+      });
+
+      it('should update existing tool when saving override with same name', async () => {
+        const updatedOverrideData = {
+          functions: [
+            {
+              name: 'search_tool',
+              description: 'Updated description',
+              parameters: [
+                {
+                  name: 'query',
+                  type: 'string',
+                  description: 'Search query',
+                  required: true
+                }
+              ]
+            }
+          ]
+        };
+
+        const request = createMockRequest({
+          path: '/overrides',
+          method: 'PATCH',
+          bodyJSON: updatedOverrideData,
+          body: JSON.stringify(updatedOverrideData)
+        });
+
+        const response = await toolsService.processRequest(request, mockToolFunction);
+
+        expect(response.status).toBe(200);
+
+        // Verify that the existing tool was updated using patch
+        expect(mockKvStore.patch).toHaveBeenCalledWith(
+          'app-v1:TestFunction:opal-tools-overrides',
+          {
+            search_tool: {
+              name: 'search_tool',
+              description: 'Updated description',
+              parameters: [
+                {
+                  name: 'query',
+                  type: 'string',
+                  description: 'Search query',
+                  required: true
+                }
+              ]
+            }
+          }
+        );
+      });
+
+      it('should handle KV store errors during save', async () => {
+        mockKvStore.patch.mockRejectedValue(new Error('KV store write error'));
+
+        const request = createMockRequest({
+          path: '/overrides',
+          method: 'PATCH',
+          bodyJSON: { functions: [] }
+        });
+
+        const response = await toolsService.processRequest(request, mockToolFunction);
+
+        expect(response.status).toBe(500);
+        expect(logger.error).toHaveBeenCalledWith('Error saving tool overrides:', expect.any(Error));
+      });
+
+      it('should return 400 for invalid request body format', async () => {
+        const invalidRequest = createMockRequest({
+          path: '/overrides',
+          method: 'PATCH',
+          bodyJSON: { tools: [] } // Wrong property name, should be 'functions'
+        });
+
+        const response = await toolsService.processRequest(invalidRequest, mockToolFunction);
+
+        expect(response.status).toBe(400);
+        expect(response.bodyJSON).toEqual({ error: 'Invalid request body. Expected functions array.' });
+      });
+
+      it('should return 400 when functions is not an array', async () => {
+        const invalidRequest = createMockRequest({
+          path: '/overrides',
+          method: 'PATCH',
+          bodyJSON: { functions: {} } // Should be array, not object
+        });
+
+        const response = await toolsService.processRequest(invalidRequest, mockToolFunction);
+
+        expect(response.status).toBe(400);
+        expect(response.bodyJSON).toEqual({ error: 'Invalid request body. Expected functions array.' });
+      });
+    });
+
+    describe('DELETE /overrides endpoint', () => {
+      it('should delete overrides successfully', async () => {
+        const request = createMockRequest({
+          path: '/overrides',
+          method: 'DELETE'
+        });
+
+        const response = await toolsService.processRequest(request, mockToolFunction);
+
+        expect(response.status).toBe(200);
+        expect(mockKvStore.delete).toHaveBeenCalledWith('app-v1:TestFunction:opal-tools-overrides');
+        expect(response.bodyJSON).toEqual({ success: true });
+      });
+
+      it('should handle KV store errors during delete', async () => {
+        mockKvStore.delete.mockRejectedValue(new Error('KV store delete error'));
+
+        const request = createMockRequest({
+          path: '/overrides',
+          method: 'DELETE'
+        });
+
+        const response = await toolsService.processRequest(request, mockToolFunction);
+
+        expect(response.status).toBe(500);
+        expect(logger.error).toHaveBeenCalledWith('Error deleting tool overrides:', expect.any(Error));
+      });
+    });
+
+    describe('Data format transformation', () => {
+      it('should transform API format (array) to storage format (map)', async () => {
+        const apiFormatData = {
+          functions: [
+            {
+              name: 'search_tool',
+              description: 'Search functionality',
+              parameters: [
+                {
+                  name: 'query',
+                  type: 'string',
+                  description: 'Search query',
+                  required: true
+                }
+              ]
+            }
+          ]
+        };
+
+        const request = createMockRequest({
+          path: '/overrides',
+          method: 'PATCH',
+          bodyJSON: apiFormatData
+        });
+
+        await toolsService.processRequest(request, mockToolFunction);
+
+        // Verify that data was transformed to storage format (map instead of array)
+        const expectedStorageFormat = {
+          search_tool: {
+            name: 'search_tool',
+            description: 'Search functionality',
+            parameters: [
+              {
+                name: 'query',
+                type: 'string',
+                description: 'Search query',
+                required: true
+              }
+            ]
+          }
+        };
+
+        expect(mockKvStore.patch).toHaveBeenCalledWith(
+          'app-v1:TestFunction:opal-tools-overrides',
+          expectedStorageFormat
+        );
+      });
+    });
+
+    describe('getToolsWithOverrides method', () => {
+      it('should return tools with overrides applied', async () => {
+        const storedOverrides = {
+          search_tool: {
+            name: 'search_tool',
+            description: 'Enhanced search functionality'
+          }
+        };
+
+        mockKvStore.get.mockResolvedValue(storedOverrides);
+
+        const toolsWithOverrides = await toolsService.getToolsWithOverrides('app-v1', 'TestFunction');
+
+        expect(toolsWithOverrides).toHaveLength(2);
+        const searchTool = toolsWithOverrides.find((t) => t.name === 'search_tool');
+        expect(searchTool?.description).toBe('Enhanced search functionality');
+      });
+
+      it('should return original tools when no overrides exist', async () => {
+        mockKvStore.get.mockResolvedValue(null);
+
+        const toolsWithOverrides = await toolsService.getToolsWithOverrides('app-v1', 'TestFunction');
+
+        expect(toolsWithOverrides).toHaveLength(2);
+        const searchTool = toolsWithOverrides.find((t) => t.name === 'search_tool');
+        expect(searchTool?.description).toBe('Search for information');
+      });
+    });
+  });
 });