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

package/dist/service/Service.test.js

@@ -1,27 +1,80 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unsafe-call */
 const Service_1 = require("./Service");
 const Models_1 = require("../types/Models");
+const ToolError_1 = require("../types/ToolError");
 const ToolFunction_1 = require("../function/ToolFunction");
 const app_sdk_1 = require("@zaiusinc/app-sdk");
 // Mock the logger and other app-sdk exports
-jest.mock('@zaiusinc/app-sdk', () => ({
-    logger: {
-        error: jest.fn()
-    },
-    Function: class {
-        request;
-        constructor(request) {
-            this.request = request;
+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 {
+            request;
+            constructor(request) {
+                this.request = request;
+            }
         }
-    },
-    Response: jest.fn().mockImplementation((status, data) => ({
-        status,
-        data,
-        bodyJSON: data,
-        bodyAsU8Array: new Uint8Array()
-    }))
-}));
+    };
+    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 {
+            constructor(headers = []) {
+                this.headers = {};
+                headers.forEach(([name, value]) => {
+                    this.headers[name.toLowerCase()] = value;
+                });
+            }
+            headers;
+            set(name, value) {
+                this.headers[name.toLowerCase()] = value;
+            }
+            get(name) {
+                return this.headers[name.toLowerCase()];
+            }
+            has(name) {
+                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;
     let mockInteraction;
@@ -243,12 +296,19 @@ describe('ToolsService', () => {
                 expect(mockTool.handler).toHaveBeenCalledWith(mockToolFunction, // functionContext
                 { param1: 'test-value' }, undefined);
             });
-            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));
                 const mockRequest = createMockRequest();
                 const response = await Service_1.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(app_sdk_1.logger.error).toHaveBeenCalledWith(`Error in function ${mockTool.name}:`, expect.any(Error));
             });
             it('should return 500 error with generic message when error has no message', async () => {
@@ -256,6 +316,55 @@ describe('ToolsService', () => {
                 const mockRequest = createMockRequest();
                 const response = await Service_1.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_1.ToolError('Resource not found', 404, 'The requested task does not exist');
+                jest.mocked(mockTool.handler).mockRejectedValueOnce(toolError);
+                const mockRequest = createMockRequest();
+                const response = await Service_1.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(app_sdk_1.logger.error).toHaveBeenCalledWith(`Error in function ${mockTool.name}:`, expect.any(ToolError_1.ToolError));
+            });
+            it('should return ToolError without detail field when detail is not provided', async () => {
+                const toolError = new ToolError_1.ToolError('Bad request', 400);
+                jest.mocked(mockTool.handler).mockRejectedValueOnce(toolError);
+                const mockRequest = createMockRequest();
+                const response = await Service_1.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_1.ToolError('Database error');
+                jest.mocked(mockTool.handler).mockRejectedValueOnce(toolError);
+                const mockRequest = createMockRequest();
+                const response = await Service_1.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');
             });
         });
         describe('interaction execution', () => {
@@ -321,7 +430,7 @@ describe('ToolsService', () => {
                     auth: authData
                 }, authData);
             });
-            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));
                 const interactionRequest = createMockRequest({
@@ -330,8 +439,33 @@ describe('ToolsService', () => {
                 });
                 const response = await Service_1.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(app_sdk_1.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_1.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 Service_1.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(app_sdk_1.logger.error).toHaveBeenCalledWith(`Error in function ${mockInteraction.name}:`, expect.any(ToolError_1.ToolError));
+            });
         });
         describe('error cases', () => {
             it('should return 404 when no matching tool or interaction is found', async () => {
@@ -353,24 +487,42 @@ describe('ToolsService', () => {
         });
         describe('edge cases', () => {
             it('should handle request with null bodyJSON', async () => {
-                Service_1.toolsService.registerTool(mockTool.name, mockTool.description, mockTool.handler, mockTool.parameters, mockTool.endpoint);
+                // 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'
+                };
+                Service_1.toolsService.registerTool(toolWithoutRequiredParams.name, toolWithoutRequiredParams.description, toolWithoutRequiredParams.handler, toolWithoutRequiredParams.parameters, toolWithoutRequiredParams.endpoint);
                 const requestWithNullBody = createMockRequest({
+                    path: '/no-required-params-tool',
                     bodyJSON: null,
                     body: null
                 });
                 const response = await Service_1.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 () => {
-                Service_1.toolsService.registerTool(mockTool.name, mockTool.description, mockTool.handler, mockTool.parameters, mockTool.endpoint);
+                // 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'
+                };
+                Service_1.toolsService.registerTool(toolWithoutRequiredParams.name, toolWithoutRequiredParams.description, toolWithoutRequiredParams.handler, toolWithoutRequiredParams.parameters, toolWithoutRequiredParams.endpoint);
                 const requestWithUndefinedBody = createMockRequest({
+                    path: '/no-required-params-tool-2',
                     bodyJSON: undefined,
                     body: undefined
                 });
                 const response = await Service_1.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 () => {
                 Service_1.toolsService.registerTool(mockTool.name, mockTool.description, mockTool.handler, mockTool.parameters, mockTool.endpoint);
@@ -422,6 +574,390 @@ describe('ToolsService', () => {
                 { param1: 'test-value' }, authData);
             });
         });
+        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 Models_1.Parameter('name', Models_1.ParameterType.String, 'User name', true),
+                        new Models_1.Parameter('age', Models_1.ParameterType.Integer, 'User age', true),
+                        new Models_1.Parameter('active', Models_1.ParameterType.Boolean, 'Is active', false)
+                    ],
+                    endpoint: '/typed-tool'
+                };
+                Service_1.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 Service_1.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'
+                };
+                Service_1.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 Service_1.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
+            Service_1.toolsService.registerTool('search_tool', 'Search for information', jest.fn().mockResolvedValue({ result: 'search success' }), [new Models_1.Parameter('query', Models_1.ParameterType.String, 'Search query', true)], '/search');
+            Service_1.toolsService.registerTool('calculator', 'Perform calculations', jest.fn().mockResolvedValue({ result: 'calculation success' }), [
+                new Models_1.Parameter('operation', Models_1.ParameterType.String, 'Math operation', true),
+                new Models_1.Parameter('numbers', Models_1.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 Service_1.toolsService.processRequest(request, mockToolFunction);
+                expect(response.status).toBe(200);
+                expect(mockKvStore.get).toHaveBeenCalledWith('app-v1:TestFunction:opal-tools-overrides');
+                const responseData = response.bodyJSON;
+                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 Service_1.toolsService.processRequest(request, mockToolFunction);
+                expect(response.status).toBe(200);
+                const responseData = response.bodyJSON;
+                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 Service_1.toolsService.processRequest(request, mockToolFunction);
+                expect(response.status).toBe(200);
+                // Should return original functions despite the error
+                const responseData = response.bodyJSON;
+                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 Service_1.toolsService.processRequest(request, mockToolFunction);
+                expect(response.status).toBe(200);
+                // Should return original functions despite the error
+                const responseData = response.bodyJSON;
+                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 Service_1.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 Service_1.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 Service_1.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 Service_1.toolsService.processRequest(request, mockToolFunction);
+                expect(response.status).toBe(500);
+                expect(app_sdk_1.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 Service_1.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 Service_1.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 Service_1.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 Service_1.toolsService.processRequest(request, mockToolFunction);
+                expect(response.status).toBe(500);
+                expect(app_sdk_1.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 Service_1.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 Service_1.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 Service_1.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');
+            });
+        });
     });
 });
 //# sourceMappingURL=Service.test.js.map