@optimizely-opal/opal-tool-ocp-sdk 1.0.0 → 1.1.0-beta.2

package/dist/service/Service.test.js

@@ -72,6 +72,10 @@ jest.mock('@zaiusinc/app-sdk', () => {
         }))
     };
 });
+// Mock the authenticateInternalRequest function
+jest.mock('../auth/AuthUtils', () => ({
+    authenticateInternalRequest: jest.fn().mockResolvedValue(undefined)
+}));
 // Get the mocked kvStore for use in tests
 const { storage } = jest.requireMock('@zaiusinc/app-sdk');
 const mockKvStore = storage.kvStore;
@@ -110,11 +114,20 @@ describe('ToolsService', () => {
             });
             return map;
         };
+        const defaultAuth = {
+            provider: 'OptiID',
+            credentials: {
+                customer_id: 'test-customer',
+                instance_id: 'test-instance',
+                access_token: 'test-token',
+                product_sku: 'test-sku'
+            }
+        };
         const baseRequest = {
             path: '/test-tool',
             method: 'POST',
-            bodyJSON: { parameters: { param1: 'test-value' } },
-            body: JSON.stringify({ parameters: { param1: 'test-value' } }),
+            bodyJSON: { parameters: { param1: 'test-value' }, auth: defaultAuth },
+            body: JSON.stringify({ parameters: { param1: 'test-value' }, auth: defaultAuth }),
             bodyData: Buffer.from(''),
             headers: createHeadersMap(),
             params: {},
@@ -194,8 +207,7 @@ describe('ToolsService', () => {
                     endpoint: '/second-tool',
                     http_method: 'POST',
                     auth_requirements: [
-                        { provider: 'oauth2', scope_bundle: 'calendar', required: true },
-                        { provider: 'OptiID', scope_bundle: 'default', required: true }
+                        { provider: 'oauth2', scope_bundle: 'calendar', required: true }
                     ]
                 });
             });
@@ -209,7 +221,7 @@ describe('ToolsService', () => {
                 const response = await Service_1.toolsService.processRequest(mockRequest, mockToolFunction);
                 expect(response.status).toBe(200);
                 expect(mockTool.handler).toHaveBeenCalledWith(mockToolFunction, // functionContext
-                { param1: 'test-value' }, undefined);
+                { param1: 'test-value' }, expect.objectContaining({ provider: 'OptiID' }));
             });
             it('should execute tool with existing ToolFunction instance context', async () => {
                 // Create a mock ToolFunction instance
@@ -225,7 +237,7 @@ describe('ToolsService', () => {
                 const response = await Service_1.toolsService.processRequest(mockRequest, mockToolFunctionInstance);
                 expect(response.status).toBe(200);
                 expect(mockTool.handler).toHaveBeenCalledWith(mockToolFunctionInstance, // functionContext - existing instance
-                { param1: 'test-value' }, undefined);
+                { param1: 'test-value' }, expect.objectContaining({ provider: 'OptiID' }));
             });
             it('should allow handler in ToolFunction subclass to access request object', async () => {
                 // Create a mock class that extends ToolFunction
@@ -255,9 +267,18 @@ describe('ToolsService', () => {
                 });
                 // Register a tool with our custom handler
                 Service_1.toolsService.registerTool('test-toolfunction-access', 'Test handler access to ToolFunction instance', handlerThatAccessesRequest, [], '/test-toolfunction-access');
+                const authData = {
+                    provider: 'OptiID',
+                    credentials: {
+                        customer_id: 'test-customer',
+                        instance_id: 'test-instance',
+                        access_token: 'test-token',
+                        product_sku: 'test-sku'
+                    }
+                };
                 const testRequest = createMockRequest({
                     path: '/test-toolfunction-access',
-                    bodyJSON: { action: 'test' }
+                    bodyJSON: { action: 'test', auth: authData }
                 });
                 const response = await Service_1.toolsService.processRequest(testRequest, mockToolFunctionInstance);
                 expect(response.status).toBe(200);
@@ -265,12 +286,20 @@ describe('ToolsService', () => {
                 expect(response.data.success).toBe(true);
                 expect(response.data.requestPath).toBe('/test-path');
                 expect(response.data.testMethodResult).toBe('path: /test-path');
-                expect(response.data.receivedParams).toEqual({ action: 'test' });
+                expect(response.data.receivedParams).toEqual({ action: 'test', auth: authData });
                 expect(handlerThatAccessesRequest).toHaveBeenCalledWith(mockToolFunctionInstance, // functionContext is the ToolFunction instance
-                { action: 'test' }, undefined);
+                { action: 'test', auth: authData }, authData);
             });
             it('should execute tool with OptiID auth data when provided', async () => {
-                const authData = new Models_1.OptiIdAuthData('optiId', new Models_1.OptiIdAuthDataCredentials('customer123', 'instance123', 'token123', 'sku123'));
+                const authData = {
+                    provider: 'OptiID',
+                    credentials: {
+                        customer_id: 'customer123',
+                        instance_id: 'instance123',
+                        access_token: 'token123',
+                        product_sku: 'sku123'
+                    }
+                };
                 const requestWithAuth = createMockRequest({
                     bodyJSON: {
                         parameters: { param1: 'test-value' },
@@ -287,84 +316,59 @@ describe('ToolsService', () => {
                 { param1: 'test-value' }, authData);
             });
             it('should handle request body without parameters wrapper', async () => {
+                const authData = {
+                    provider: 'OptiID',
+                    credentials: {
+                        customer_id: 'test-customer',
+                        instance_id: 'test-instance',
+                        access_token: 'test-token',
+                        product_sku: 'test-sku'
+                    }
+                };
                 const requestWithoutWrapper = createMockRequest({
-                    bodyJSON: { param1: 'test-value' },
-                    body: JSON.stringify({ param1: 'test-value' })
+                    bodyJSON: { param1: 'test-value', auth: authData },
+                    body: JSON.stringify({ param1: 'test-value', auth: authData })
                 });
                 const response = await Service_1.toolsService.processRequest(requestWithoutWrapper, mockToolFunction);
                 expect(response.status).toBe(200);
                 expect(mockTool.handler).toHaveBeenCalledWith(mockToolFunction, // functionContext
-                { param1: 'test-value' }, undefined);
+                { param1: 'test-value', auth: authData }, authData);
             });
-            it('should return 500 error in RFC 9457 format when tool handler throws a regular error', async () => {
+            it('should throw error 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));
+                await expect(Service_1.toolsService.processRequest(mockRequest, mockToolFunction))
+                    .rejects.toThrow(errorMessage);
             });
-            it('should return 500 error with generic message when error has no message', async () => {
+            it('should throw when tool handler throws object without message', async () => {
                 jest.mocked(mockTool.handler).mockRejectedValueOnce({});
                 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');
+                await expect(Service_1.toolsService.processRequest(mockRequest, mockToolFunction))
+                    .rejects.toEqual({});
             });
-            it('should return custom status code when tool handler throws ToolError', async () => {
+            it('should throw ToolError 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));
+                await expect(Service_1.toolsService.processRequest(mockRequest, mockToolFunction))
+                    .rejects.toThrow(toolError);
             });
-            it('should return ToolError without detail field when detail is not provided', async () => {
+            it('should throw ToolError without detail 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');
+                await expect(Service_1.toolsService.processRequest(mockRequest, mockToolFunction))
+                    .rejects.toThrow(toolError);
+                expect(toolError.status).toBe(400);
             });
-            it('should default to 500 when ToolError is created without status', async () => {
+            it('should throw ToolError with default 500 status when 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');
+                await expect(Service_1.toolsService.processRequest(mockRequest, mockToolFunction))
+                    .rejects.toThrow(toolError);
+                expect(toolError.status).toBe(500);
             });
         });
         describe('interaction execution', () => {
@@ -372,27 +376,54 @@ describe('ToolsService', () => {
                 Service_1.toolsService.registerInteraction(mockInteraction.name, mockInteraction.handler, mockInteraction.endpoint);
             });
             it('should execute interaction successfully with data', async () => {
+                const authData = {
+                    provider: 'OptiID',
+                    credentials: {
+                        customer_id: 'test-customer',
+                        instance_id: 'test-instance',
+                        access_token: 'test-token',
+                        product_sku: 'test-sku'
+                    }
+                };
                 const interactionRequest = createMockRequest({
                     path: '/test-interaction',
-                    bodyJSON: { data: { param1: 'test-value' } },
-                    body: JSON.stringify({ data: { param1: 'test-value' } })
+                    bodyJSON: { data: { param1: 'test-value' }, auth: authData },
+                    body: JSON.stringify({ data: { param1: 'test-value' }, auth: authData })
                 });
                 const response = await Service_1.toolsService.processRequest(interactionRequest, mockToolFunction);
                 expect(response.status).toBe(200);
-                expect(mockInteraction.handler).toHaveBeenCalledWith(mockToolFunction, { param1: 'test-value' }, undefined);
+                expect(mockInteraction.handler).toHaveBeenCalledWith(mockToolFunction, { param1: 'test-value' }, authData);
             });
             it('should handle interaction request body without data wrapper', async () => {
+                const authData = {
+                    provider: 'OptiID',
+                    credentials: {
+                        customer_id: 'test-customer',
+                        instance_id: 'test-instance',
+                        access_token: 'test-token',
+                        product_sku: 'test-sku'
+                    }
+                };
                 const interactionRequest = createMockRequest({
                     path: '/test-interaction',
-                    bodyJSON: { param1: 'test-value' },
-                    body: JSON.stringify({ param1: 'test-value' })
+                    bodyJSON: { param1: 'test-value', auth: authData },
+                    body: JSON.stringify({ param1: 'test-value', auth: authData })
                 });
                 const response = await Service_1.toolsService.processRequest(interactionRequest, mockToolFunction);
                 expect(response.status).toBe(200);
-                expect(mockInteraction.handler).toHaveBeenCalledWith(mockToolFunction, { param1: 'test-value' }, undefined);
+                expect(mockInteraction.handler)
+                    .toHaveBeenCalledWith(mockToolFunction, { param1: 'test-value', auth: authData }, authData);
             });
             it('should execute interaction with OptiID auth data when provided', async () => {
-                const authData = new Models_1.OptiIdAuthData('optiId', new Models_1.OptiIdAuthDataCredentials('customer123', 'instance123', 'token123', 'sku123'));
+                const authData = {
+                    provider: 'OptiID',
+                    credentials: {
+                        customer_id: 'customer123',
+                        instance_id: 'instance123',
+                        access_token: 'token123',
+                        product_sku: 'sku123'
+                    }
+                };
                 const interactionRequest = createMockRequest({
                     path: '/test-interaction',
                     bodyJSON: {
@@ -410,7 +441,15 @@ describe('ToolsService', () => {
                 { param1: 'test-value' }, authData);
             });
             it('should handle interaction request without data wrapper but with auth data', async () => {
-                const authData = new Models_1.OptiIdAuthData('optiId', new Models_1.OptiIdAuthDataCredentials('customer123', 'instance123', 'token123', 'sku123'));
+                const authData = {
+                    provider: 'OptiID',
+                    credentials: {
+                        customer_id: 'customer123',
+                        instance_id: 'instance123',
+                        access_token: 'token123',
+                        product_sku: 'sku123'
+                    }
+                };
                 const interactionRequest = createMockRequest({
                     path: '/test-interaction',
                     bodyJSON: {
@@ -430,48 +469,59 @@ describe('ToolsService', () => {
                     auth: authData
                 }, authData);
             });
-            it('should return 500 error in RFC 9457 format when interaction handler throws a regular error', async () => {
+            it('should throw error when interaction handler throws a regular error', async () => {
+                const authData = {
+                    provider: 'OptiID',
+                    credentials: {
+                        customer_id: 'test-customer',
+                        instance_id: 'test-instance',
+                        access_token: 'test-token',
+                        product_sku: 'test-sku'
+                    }
+                };
                 const errorMessage = 'Interaction execution failed';
                 jest.mocked(mockInteraction.handler).mockRejectedValueOnce(new Error(errorMessage));
                 const interactionRequest = createMockRequest({
                     path: '/test-interaction',
-                    bodyJSON: { data: { param1: 'test-value' } }
+                    bodyJSON: { data: { param1: 'test-value' }, auth: authData }
                 });
-                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));
+                await expect(Service_1.toolsService.processRequest(interactionRequest, mockToolFunction))
+                    .rejects.toThrow(errorMessage);
             });
-            it('should return custom status code when interaction handler throws ToolError', async () => {
+            it('should throw ToolError when interaction handler throws ToolError', async () => {
+                const authData = {
+                    provider: 'OptiID',
+                    credentials: {
+                        customer_id: 'test-customer',
+                        instance_id: 'test-instance',
+                        access_token: 'test-token',
+                        product_sku: 'test-sku'
+                    }
+                };
                 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
+                    bodyJSON: { data: { param1: 'test-value' }, auth: authData }
                 });
-                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));
+                await expect(Service_1.toolsService.processRequest(interactionRequest, mockToolFunction))
+                    .rejects.toThrow(toolError);
             });
         });
         describe('error cases', () => {
-            it('should return 404 when no matching tool or interaction is found', async () => {
+            it('should throw ToolError with 404 when no matching tool or interaction is found', async () => {
                 const unknownRequest = createMockRequest({ path: '/unknown-endpoint' });
-                const response = await Service_1.toolsService.processRequest(unknownRequest, mockToolFunction);
-                expect(response.status).toBe(404);
+                await expect(Service_1.toolsService.processRequest(unknownRequest, mockToolFunction))
+                    .rejects.toThrow(ToolError_1.ToolError);
+                try {
+                    await Service_1.toolsService.processRequest(unknownRequest, mockToolFunction);
+                }
+                catch (error) {
+                    expect(error).toBeInstanceOf(ToolError_1.ToolError);
+                    expect(error.status).toBe(404);
+                    // ToolError prepends status to message
+                    expect(error.message).toContain('Function not found');
+                }
             });
             it('should handle tool with OptiID auth requirements', async () => {
                 const authRequirements = [
@@ -486,7 +536,7 @@ describe('ToolsService', () => {
             });
         });
         describe('edge cases', () => {
-            it('should handle request with null bodyJSON', async () => {
+            it('should throw 403 when request has null bodyJSON (no auth data)', async () => {
                 // Create a tool without required parameters
                 const toolWithoutRequiredParams = {
                     name: 'no_required_params_tool',
@@ -501,11 +551,17 @@ describe('ToolsService', () => {
                     bodyJSON: null,
                     body: null
                 });
-                const response = await Service_1.toolsService.processRequest(requestWithNullBody, mockToolFunction);
-                expect(response.status).toBe(200);
-                expect(toolWithoutRequiredParams.handler).toHaveBeenCalledWith(mockToolFunction, null, undefined);
+                await expect(Service_1.toolsService.processRequest(requestWithNullBody, mockToolFunction))
+                    .rejects.toThrow(ToolError_1.ToolError);
+                try {
+                    await Service_1.toolsService.processRequest(requestWithNullBody, mockToolFunction);
+                }
+                catch (error) {
+                    expect(error.status).toBe(403);
+                    expect(error.message).toContain('Authentication data is required');
+                }
             });
-            it('should handle request with undefined bodyJSON', async () => {
+            it('should throw 403 when request has undefined bodyJSON (no auth data)', async () => {
                 // Create a tool without required parameters
                 const toolWithoutRequiredParams = {
                     name: 'no_required_params_tool_2',
@@ -520,13 +576,27 @@ describe('ToolsService', () => {
                     bodyJSON: undefined,
                     body: undefined
                 });
-                const response = await Service_1.toolsService.processRequest(requestWithUndefinedBody, mockToolFunction);
-                expect(response.status).toBe(200);
-                expect(toolWithoutRequiredParams.handler).toHaveBeenCalledWith(mockToolFunction, undefined, undefined);
+                await expect(Service_1.toolsService.processRequest(requestWithUndefinedBody, mockToolFunction))
+                    .rejects.toThrow(ToolError_1.ToolError);
+                try {
+                    await Service_1.toolsService.processRequest(requestWithUndefinedBody, mockToolFunction);
+                }
+                catch (error) {
+                    expect(error.status).toBe(403);
+                    expect(error.message).toContain('Authentication data is required');
+                }
             });
             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);
-                const authData = new Models_1.OptiIdAuthData('optiId', new Models_1.OptiIdAuthDataCredentials('customer123', 'instance123', 'token123', 'sku123'));
+                const authData = {
+                    provider: 'OptiID',
+                    credentials: {
+                        customer_id: 'customer123',
+                        instance_id: 'instance123',
+                        access_token: 'token123',
+                        product_sku: 'sku123'
+                    }
+                };
                 const requestWithAuth = createMockRequest({
                     bodyJSON: {
                         parameters: { param1: 'test-value' },
@@ -542,7 +612,7 @@ describe('ToolsService', () => {
                 expect(mockTool.handler).toHaveBeenCalledWith(mockToolFunction, // functionContext
                 { param1: 'test-value' }, authData);
             });
-            it('should handle missing auth data gracefully', async () => {
+            it('should throw 403 when auth data is missing for tool with auth requirements', async () => {
                 Service_1.toolsService.registerTool(mockTool.name, mockTool.description, mockTool.handler, mockTool.parameters, mockTool.endpoint);
                 const requestWithoutAuth = createMockRequest({
                     bodyJSON: {
@@ -553,14 +623,27 @@ describe('ToolsService', () => {
                         parameters: { param1: 'test-value' }
                     })
                 });
-                const response = await Service_1.toolsService.processRequest(requestWithoutAuth, mockToolFunction);
-                expect(response.status).toBe(200);
-                expect(mockTool.handler).toHaveBeenCalledWith(mockToolFunction, // functionContext
-                { param1: 'test-value' }, undefined);
+                await expect(Service_1.toolsService.processRequest(requestWithoutAuth, mockToolFunction))
+                    .rejects.toThrow(ToolError_1.ToolError);
+                try {
+                    await Service_1.toolsService.processRequest(requestWithoutAuth, mockToolFunction);
+                }
+                catch (error) {
+                    expect(error.status).toBe(403);
+                    expect(error.message).toContain('Authentication data is required');
+                }
             });
             it('should handle auth extraction when body is falsy but bodyJSON has auth', async () => {
                 Service_1.toolsService.registerTool(mockTool.name, mockTool.description, mockTool.handler, mockTool.parameters, mockTool.endpoint);
-                const authData = new Models_1.OptiIdAuthData('optiId', new Models_1.OptiIdAuthDataCredentials('customer123', 'instance123', 'token123', 'sku123'));
+                const authData = {
+                    provider: 'OptiID',
+                    credentials: {
+                        customer_id: 'customer123',
+                        instance_id: 'instance123',
+                        access_token: 'token123',
+                        product_sku: 'sku123'
+                    }
+                };
                 const requestWithAuthButNoBody = createMockRequest({
                     bodyJSON: {
                         parameters: { param1: 'test-value' },
@@ -578,7 +661,7 @@ describe('ToolsService', () => {
             beforeEach(() => {
                 jest.clearAllMocks();
             });
-            it('should validate parameters and return 400 for invalid types', async () => {
+            it('should throw ToolError with 400 for invalid parameter types', async () => {
                 // Register a tool with specific parameter types
                 const toolWithTypedParams = {
                     name: 'typed_tool',
@@ -603,22 +686,25 @@ describe('ToolsService', () => {
                         }
                     }
                 });
-                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');
+                await expect(Service_1.toolsService.processRequest(invalidRequest, mockToolFunction))
+                    .rejects.toThrow(ToolError_1.ToolError);
+                try {
+                    await Service_1.toolsService.processRequest(invalidRequest, mockToolFunction);
+                }
+                catch (error) {
+                    expect(error).toBeInstanceOf(ToolError_1.ToolError);
+                    const toolError = error;
+                    expect(toolError.status).toBe(400);
+                    // The ToolError has title property, message includes more details
+                    expect(toolError.toProblemDetails('/typed-tool')).toMatchObject({
+                        title: 'One or more validation errors occurred.',
+                        status: 400
+                    });
+                    expect(toolError.errors).toHaveLength(3);
+                    expect(toolError.errors[0]).toHaveProperty('field', 'name');
+                    expect(toolError.errors[0].message)
+                        .toBe("Parameter 'name' must be a string, but received number");
+                }
                 // Verify the handler was not called
                 expect(toolWithTypedParams.handler).not.toHaveBeenCalled();
             });
@@ -631,18 +717,28 @@ describe('ToolsService', () => {
                     endpoint: '/no-params-tool'
                 };
                 Service_1.toolsService.registerTool(toolWithoutParams.name, toolWithoutParams.description, toolWithoutParams.handler, toolWithoutParams.parameters, toolWithoutParams.endpoint);
+                const authData = {
+                    provider: 'OptiID',
+                    credentials: {
+                        customer_id: 'test-customer',
+                        instance_id: 'test-instance',
+                        access_token: 'test-token',
+                        product_sku: 'test-sku'
+                    }
+                };
                 // Send request with any data (should be ignored)
                 const request = createMockRequest({
                     path: '/no-params-tool',
                     bodyJSON: {
                         parameters: {
                             unexpected: 'value'
-                        }
+                        },
+                        auth: authData
                     }
                 });
                 const response = await Service_1.toolsService.processRequest(request, mockToolFunction);
                 expect(response.status).toBe(200);
-                expect(toolWithoutParams.handler).toHaveBeenCalledWith(mockToolFunction, { unexpected: 'value' }, undefined);
+                expect(toolWithoutParams.handler).toHaveBeenCalledWith(mockToolFunction, { unexpected: 'value' }, authData);
             });
         });
     });