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

package/src/service/Service.test.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 import { toolsService, Tool, Interaction } from './Service';
-import { Parameter, ParameterType, AuthRequirement, OptiIdAuthDataCredentials, OptiIdAuthData } from '../types/Models';
+import { Parameter, ParameterType, AuthRequirement, AuthData } from '../types/Models';
 import { ToolError } from '../types/ToolError';
 import { ToolFunction } from '../function/ToolFunction';
 import { logger } from '@zaiusinc/app-sdk';
@@ -71,14 +71,19 @@ 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;
 
 
 describe('ToolsService', () => {
-  let mockTool: Tool<unknown>;
-  let mockInteraction: Interaction<unknown>;
+  let mockTool: Tool;
+  let mockInteraction: Interaction;
   let mockToolFunction: ToolFunction;
 
   beforeEach(() => {
@@ -130,11 +135,21 @@ 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: {},
@@ -250,8 +265,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 }
           ]
         });
       });
@@ -276,7 +290,7 @@ describe('ToolsService', () => {
         expect(mockTool.handler).toHaveBeenCalledWith(
           mockToolFunction, // functionContext
           { param1: 'test-value' },
-          undefined
+          expect.objectContaining({ provider: 'OptiID' })
         );
       });
 
@@ -298,7 +312,7 @@ describe('ToolsService', () => {
         expect(mockTool.handler).toHaveBeenCalledWith(
           mockToolFunctionInstance, // functionContext - existing instance
           { param1: 'test-value' },
-          undefined
+          expect.objectContaining({ provider: 'OptiID' })
         );
       });
 
@@ -345,9 +359,19 @@ describe('ToolsService', () => {
           '/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 toolsService.processRequest(testRequest, mockToolFunctionInstance);
@@ -357,19 +381,24 @@ describe('ToolsService', () => {
         expect((response as any).data.success).toBe(true);
         expect((response as any).data.requestPath).toBe('/test-path');
         expect((response as any).data.testMethodResult).toBe('path: /test-path');
-        expect((response as any).data.receivedParams).toEqual({ action: 'test' });
+        expect((response as any).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 OptiIdAuthData(
-          'optiId',
-          new OptiIdAuthDataCredentials('customer123', 'instance123', 'token123', 'sku123')
-        );
+        const authData: AuthData = {
+          provider: 'OptiID',
+          credentials: {
+            customer_id: 'customer123',
+            instance_id: 'instance123',
+            access_token: 'token123',
+            product_sku: 'sku123'
+          }
+        };
 
         const requestWithAuth = createMockRequest({
           bodyJSON: {
@@ -393,9 +422,19 @@ describe('ToolsService', () => {
       });
 
       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 toolsService.processRequest(requestWithoutWrapper, mockToolFunction);
@@ -403,100 +442,60 @@ describe('ToolsService', () => {
         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 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)
-        );
+        await expect(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 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(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('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)
-        );
+        await expect(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('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');
+        await expect(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('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');
+        await expect(toolsService.processRequest(mockRequest, mockToolFunction))
+          .rejects.toThrow(toolError);
+        expect(toolError.status).toBe(500);
       });
     });
 
@@ -510,36 +509,62 @@ describe('ToolsService', () => {
       });
 
       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 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 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 OptiIdAuthData(
-          'optiId',
-          new 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',
@@ -564,10 +589,15 @@ describe('ToolsService', () => {
       });
 
       it('should handle interaction request without data wrapper but with auth data', async () => {
-        const authData = new OptiIdAuthData(
-          'optiId',
-          new 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',
@@ -594,63 +624,66 @@ describe('ToolsService', () => {
         );
       });
 
-      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 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)
-        );
+        await expect(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('Webhook validation failed', 400, 'Invalid signature');
         jest.mocked(mockInteraction.handler).mockRejectedValueOnce(toolError);
 
         const interactionRequest = createMockRequest({
           path: '/test-interaction',
-          bodyJSON: { data: { param1: 'test-value' } }
+          bodyJSON: { data: { param1: 'test-value' }, auth: authData }
         });
 
-        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)
-        );
+        await expect(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 toolsService.processRequest(unknownRequest, mockToolFunction);
 
-        expect(response.status).toBe(404);
+        await expect(toolsService.processRequest(unknownRequest, mockToolFunction))
+          .rejects.toThrow(ToolError);
+
+        try {
+          await toolsService.processRequest(unknownRequest, mockToolFunction);
+        } catch (error) {
+          expect(error).toBeInstanceOf(ToolError);
+          expect((error as ToolError).status).toBe(404);
+          // ToolError prepends status to message
+          expect((error as ToolError).message).toContain('Function not found');
+        }
       });
 
       it('should handle tool with OptiID auth requirements', async () => {
@@ -678,7 +711,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',
@@ -702,13 +735,18 @@ describe('ToolsService', () => {
           body: null
         });
 
-        const response = await toolsService.processRequest(requestWithNullBody, mockToolFunction);
+        await expect(toolsService.processRequest(requestWithNullBody, mockToolFunction))
+          .rejects.toThrow(ToolError);
 
-        expect(response.status).toBe(200);
-        expect(toolWithoutRequiredParams.handler).toHaveBeenCalledWith(mockToolFunction, null, undefined);
+        try {
+          await toolsService.processRequest(requestWithNullBody, mockToolFunction);
+        } catch (error) {
+          expect((error as ToolError).status).toBe(403);
+          expect((error as ToolError).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',
@@ -732,10 +770,15 @@ describe('ToolsService', () => {
           body: undefined
         });
 
-        const response = await toolsService.processRequest(requestWithUndefinedBody, mockToolFunction);
+        await expect(toolsService.processRequest(requestWithUndefinedBody, mockToolFunction))
+          .rejects.toThrow(ToolError);
 
-        expect(response.status).toBe(200);
-        expect(toolWithoutRequiredParams.handler).toHaveBeenCalledWith(mockToolFunction, undefined, undefined);
+        try {
+          await toolsService.processRequest(requestWithUndefinedBody, mockToolFunction);
+        } catch (error) {
+          expect((error as ToolError).status).toBe(403);
+          expect((error as ToolError).message).toContain('Authentication data is required');
+        }
       });
 
       it('should extract auth data from bodyJSON when body exists', async () => {
@@ -747,10 +790,15 @@ describe('ToolsService', () => {
           mockTool.endpoint
         );
 
-        const authData = new OptiIdAuthData(
-          'optiId',
-          new 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: {
@@ -773,7 +821,7 @@ describe('ToolsService', () => {
         );
       });
 
-      it('should handle missing auth data gracefully', async () => {
+      it('should throw 403 when auth data is missing for tool with auth requirements', async () => {
         toolsService.registerTool(
           mockTool.name,
           mockTool.description,
@@ -792,14 +840,15 @@ describe('ToolsService', () => {
           })
         });
 
-        const response = await toolsService.processRequest(requestWithoutAuth, mockToolFunction);
+        await expect(toolsService.processRequest(requestWithoutAuth, mockToolFunction))
+          .rejects.toThrow(ToolError);
 
-        expect(response.status).toBe(200);
-        expect(mockTool.handler).toHaveBeenCalledWith(
-          mockToolFunction, // functionContext
-          { param1: 'test-value' },
-          undefined
-        );
+        try {
+          await toolsService.processRequest(requestWithoutAuth, mockToolFunction);
+        } catch (error) {
+          expect((error as ToolError).status).toBe(403);
+          expect((error as ToolError).message).toContain('Authentication data is required');
+        }
       });
 
       it('should handle auth extraction when body is falsy but bodyJSON has auth', async () => {
@@ -811,10 +860,15 @@ describe('ToolsService', () => {
           mockTool.endpoint
         );
 
-        const authData = new OptiIdAuthData(
-          'optiId',
-          new 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: {
@@ -840,7 +894,7 @@ describe('ToolsService', () => {
         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',
@@ -874,26 +928,25 @@ describe('ToolsService', () => {
           }
         });
 
-        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');
+        await expect(toolsService.processRequest(invalidRequest, mockToolFunction))
+          .rejects.toThrow(ToolError);
+
+        try {
+          await toolsService.processRequest(invalidRequest, mockToolFunction);
+        } catch (error) {
+          expect(error).toBeInstanceOf(ToolError);
+          const toolError = error as ToolError;
+          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();
@@ -916,13 +969,24 @@ describe('ToolsService', () => {
           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
           }
         });
 
@@ -932,7 +996,7 @@ describe('ToolsService', () => {
         expect(toolWithoutParams.handler).toHaveBeenCalledWith(
           mockToolFunction,
           { unexpected: 'value' },
-          undefined
+          authData
         );
       });
     });