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

package/src/service/Service.test.ts

@@ -1,23 +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) {}
-  },
-  Response: jest.fn().mockImplementation((status, data) => ({
-    status,
-    data,
-    bodyJSON: data,
-    bodyAsU8Array: new Uint8Array()
-  }))
-}));
+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) {}
+    }
+  };
+
+  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>;
@@ -351,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));
 
@@ -359,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)
@@ -372,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');
       });
     });
 
@@ -469,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));
 
@@ -481,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', () => {
@@ -522,15 +679,25 @@ describe('ToolsService', () => {
 
     describe('edge cases', () => {
       it('should handle request with null bodyJSON', async () => {
+        // Create a tool without required parameters
+        const toolWithoutRequiredParams = {
+          name: 'no_required_params_tool',
+          description: 'Tool without required parameters',
+          handler: jest.fn().mockResolvedValue({ result: 'success' }),
+          parameters: [], // No parameters defined
+          endpoint: '/no-required-params-tool'
+        };
+
         toolsService.registerTool(
-          mockTool.name,
-          mockTool.description,
-          mockTool.handler,
-          mockTool.parameters,
-          mockTool.endpoint
+          toolWithoutRequiredParams.name,
+          toolWithoutRequiredParams.description,
+          toolWithoutRequiredParams.handler,
+          toolWithoutRequiredParams.parameters,
+          toolWithoutRequiredParams.endpoint
         );
 
         const requestWithNullBody = createMockRequest({
+          path: '/no-required-params-tool',
           bodyJSON: null,
           body: null
         });
@@ -538,19 +705,29 @@ describe('ToolsService', () => {
         const response = await toolsService.processRequest(requestWithNullBody, mockToolFunction);
 
         expect(response.status).toBe(200);
-        expect(mockTool.handler).toHaveBeenCalledWith(mockToolFunction, null, undefined);
+        expect(toolWithoutRequiredParams.handler).toHaveBeenCalledWith(mockToolFunction, null, undefined);
       });
 
       it('should handle request with undefined bodyJSON', async () => {
+        // Create a tool without required parameters
+        const toolWithoutRequiredParams = {
+          name: 'no_required_params_tool_2',
+          description: 'Tool without required parameters',
+          handler: jest.fn().mockResolvedValue({ result: 'success' }),
+          parameters: [], // No parameters defined
+          endpoint: '/no-required-params-tool-2'
+        };
+
         toolsService.registerTool(
-          mockTool.name,
-          mockTool.description,
-          mockTool.handler,
-          mockTool.parameters,
-          mockTool.endpoint
+          toolWithoutRequiredParams.name,
+          toolWithoutRequiredParams.description,
+          toolWithoutRequiredParams.handler,
+          toolWithoutRequiredParams.parameters,
+          toolWithoutRequiredParams.endpoint
         );
 
         const requestWithUndefinedBody = createMockRequest({
+          path: '/no-required-params-tool-2',
           bodyJSON: undefined,
           body: undefined
         });
@@ -558,7 +735,7 @@ describe('ToolsService', () => {
         const response = await toolsService.processRequest(requestWithUndefinedBody, mockToolFunction);
 
         expect(response.status).toBe(200);
-        expect(mockTool.handler).toHaveBeenCalledWith(mockToolFunction, undefined, undefined);
+        expect(toolWithoutRequiredParams.handler).toHaveBeenCalledWith(mockToolFunction, undefined, undefined);
       });
 
       it('should extract auth data from bodyJSON when body exists', async () => {
@@ -657,5 +834,512 @@ describe('ToolsService', () => {
         );
       });
     });
+
+    describe('parameter validation', () => {
+      beforeEach(() => {
+        jest.clearAllMocks();
+      });
+
+      it('should validate parameters and return 400 for invalid types', async () => {
+        // Register a tool with specific parameter types
+        const toolWithTypedParams = {
+          name: 'typed_tool',
+          description: 'Tool with typed parameters',
+          handler: jest.fn().mockResolvedValue({ result: 'success' }),
+          parameters: [
+            new Parameter('name', ParameterType.String, 'User name', true),
+            new Parameter('age', ParameterType.Integer, 'User age', true),
+            new Parameter('active', ParameterType.Boolean, 'Is active', false)
+          ],
+          endpoint: '/typed-tool'
+        };
+
+        toolsService.registerTool(
+          toolWithTypedParams.name,
+          toolWithTypedParams.description,
+          toolWithTypedParams.handler,
+          toolWithTypedParams.parameters,
+          toolWithTypedParams.endpoint
+        );
+
+        // Send invalid parameter types
+        const invalidRequest = createMockRequest({
+          path: '/typed-tool',
+          bodyJSON: {
+            parameters: {
+              name: 123, // should be string
+              age: '25', // should be integer
+              active: 'true' // should be boolean
+            }
+          }
+        });
+
+        const response = await toolsService.processRequest(invalidRequest, mockToolFunction);
+
+        expect(response.status).toBe(400);
+
+        // Expect RFC 9457 Problem Details format
+        expect(response.bodyJSON).toHaveProperty('title', 'One or more validation errors occurred.');
+        expect(response.bodyJSON).toHaveProperty('status', 400);
+        expect(response.bodyJSON).toHaveProperty('detail', 'See \'errors\' field for details.');
+        expect(response.bodyJSON).toHaveProperty('instance', '/typed-tool');
+        expect(response.bodyJSON).toHaveProperty('errors');
+        expect(response.bodyJSON.errors).toHaveLength(3);
+
+        // Check error structure - field and message
+        const errors = response.bodyJSON.errors;
+        expect(errors[0]).toHaveProperty('field', 'name');
+        expect(errors[0]).toHaveProperty('message', "Parameter 'name' must be a string, but received number");
+
+        // Check that the content type is set to application/problem+json for RFC 9457 compliance
+        expect(response.headers).toBeDefined();
+        expect(response.headers.get('content-type')).toBe('application/problem+json');
+
+        // Verify the handler was not called
+        expect(toolWithTypedParams.handler).not.toHaveBeenCalled();
+      });
+
+      it('should skip validation for tools with no parameter definitions', async () => {
+        const toolWithoutParams = {
+          name: 'no_params_tool',
+          description: 'Tool without parameters',
+          handler: jest.fn().mockResolvedValue({ result: 'success' }),
+          parameters: [], // No parameters defined
+          endpoint: '/no-params-tool'
+        };
+
+        toolsService.registerTool(
+          toolWithoutParams.name,
+          toolWithoutParams.description,
+          toolWithoutParams.handler,
+          toolWithoutParams.parameters,
+          toolWithoutParams.endpoint
+        );
+
+        // Send request with any data (should be ignored)
+        const request = createMockRequest({
+          path: '/no-params-tool',
+          bodyJSON: {
+            parameters: {
+              unexpected: 'value'
+            }
+          }
+        });
+
+        const response = await toolsService.processRequest(request, mockToolFunction);
+
+        expect(response.status).toBe(200);
+        expect(toolWithoutParams.handler).toHaveBeenCalledWith(
+          mockToolFunction,
+          { unexpected: 'value' },
+          undefined
+        );
+      });
+    });
+  });
+
+  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');
+      });
+    });
   });
 });