@optimizely-opal/opal-tool-ocp-sdk 0.0.0-beta.5 → 0.0.0-beta.6

package/src/function/ToolFunction.test.ts

@@ -26,11 +26,13 @@ jest.mock('@zaiusinc/app-sdk', () => ({
     bodyJSON: data,
     bodyAsU8Array: new Uint8Array()
   })),
+  amendLogContext: jest.fn(),
 }));
 
 // Create a concrete implementation for testing
 class TestToolFunction extends ToolFunction {
   private mockValidateBearerToken: jest.MockedFunction<(token: string) => boolean>;
+  private mockReady: jest.MockedFunction<() => Promise<boolean>>;
 
   public constructor(request?: any) {
     super(request || {}); // Pass the request parameter properly
@@ -38,6 +40,7 @@ class TestToolFunction extends ToolFunction {
     (this as any).request = request;
 
     this.mockValidateBearerToken = jest.fn().mockReturnValue(true);
+    this.mockReady = jest.fn().mockResolvedValue(true);
   }
 
   // Override the concrete method with mock implementation for testing
@@ -45,6 +48,11 @@ class TestToolFunction extends ToolFunction {
     return this.mockValidateBearerToken(bearerToken);
   }
 
+  // Override the ready method with mock implementation for testing
+  protected ready(): Promise<boolean> {
+    return this.mockReady();
+  }
+
   // Expose request and validation mock for testing
   public getRequest() {
     return (this as any).request;
@@ -53,6 +61,10 @@ class TestToolFunction extends ToolFunction {
   public getMockValidateBearerToken() {
     return this.mockValidateBearerToken;
   }
+
+  public getMockReady() {
+    return this.mockReady;
+  }
 }
 
 describe('ToolFunction', () => {
@@ -81,6 +93,137 @@ describe('ToolFunction', () => {
     toolFunction = new TestToolFunction(mockRequest);
   });
 
+  describe('/ready endpoint', () => {
+    it('should return ready: true when ready method returns true', async () => {
+      // Arrange
+      const readyRequest = {
+        headers: new Map(),
+        method: 'GET',
+        path: '/ready'
+      };
+      toolFunction = new TestToolFunction(readyRequest);
+      toolFunction.getMockReady().mockResolvedValue(true);
+
+      // Act
+      const result = await toolFunction.perform();
+
+      // Assert
+      expect(toolFunction.getMockReady()).toHaveBeenCalledTimes(1);
+      expect(result).toEqual(new Response(200, { ready: true }));
+      expect(mockProcessRequest).not.toHaveBeenCalled(); // Should not call service
+    });
+
+    it('should return ready: false when ready method returns false', async () => {
+      // Arrange
+      const readyRequest = {
+        headers: new Map(),
+        method: 'GET',
+        path: '/ready'
+      };
+      toolFunction = new TestToolFunction(readyRequest);
+      toolFunction.getMockReady().mockResolvedValue(false);
+
+      // Act
+      const result = await toolFunction.perform();
+
+      // Assert
+      expect(toolFunction.getMockReady()).toHaveBeenCalledTimes(1);
+      expect(result).toEqual(new Response(200, { ready: false }));
+      expect(mockProcessRequest).not.toHaveBeenCalled(); // Should not call service
+    });
+
+    it('should handle ready method throwing an error', async () => {
+      // Arrange
+      const readyRequest = {
+        headers: new Map(),
+        method: 'GET',
+        path: '/ready'
+      };
+      toolFunction = new TestToolFunction(readyRequest);
+      toolFunction.getMockReady().mockRejectedValue(new Error('Ready check failed'));
+
+      // Act & Assert
+      await expect(toolFunction.perform()).rejects.toThrow('Ready check failed');
+      expect(toolFunction.getMockReady()).toHaveBeenCalledTimes(1);
+      expect(mockProcessRequest).not.toHaveBeenCalled(); // Should not call service
+    });
+
+    it('should handle /ready endpoint after bearer token validation passes', async () => {
+      // Arrange
+      const readyRequest = {
+        headers: new Map([['authorization', 'Bearer valid-token']]),
+        method: 'GET',
+        path: '/ready'
+      };
+      toolFunction = new TestToolFunction(readyRequest);
+      toolFunction.getMockReady().mockResolvedValue(true);
+      mockExtractBearerToken.mockReturnValue('valid-token');
+      toolFunction.getMockValidateBearerToken().mockReturnValue(true); // Make sure auth passes so we reach /ready
+
+      // Act
+      const result = await toolFunction.perform();
+
+      // Assert
+      expect(toolFunction.getMockReady()).toHaveBeenCalledTimes(1);
+      expect(result).toEqual(new Response(200, { ready: true }));
+      expect(mockExtractBearerToken).toHaveBeenCalledWith(readyRequest.headers); // Auth is checked first
+      expect(toolFunction.getMockValidateBearerToken()).toHaveBeenCalledWith('valid-token'); // Auth validation happens
+      expect(mockProcessRequest).not.toHaveBeenCalled(); // Should not call service
+    });
+
+    it('should return 403 when bearer token validation fails even for /ready endpoint', async () => {
+      // Arrange
+      const readyRequest = {
+        headers: new Map([['authorization', 'Bearer invalid-token']]),
+        method: 'GET',
+        path: '/ready'
+      };
+      toolFunction = new TestToolFunction(readyRequest);
+      toolFunction.getMockReady().mockResolvedValue(true);
+      mockExtractBearerToken.mockReturnValue('invalid-token');
+      toolFunction.getMockValidateBearerToken().mockReturnValue(false); // Auth fails
+
+      // Act
+      const result = await toolFunction.perform();
+
+      // Assert
+      expect(result).toEqual(new Response(403, { error: 'Forbidden' }));
+      expect(mockExtractBearerToken).toHaveBeenCalledWith(readyRequest.headers);
+      expect(toolFunction.getMockValidateBearerToken()).toHaveBeenCalledWith('invalid-token');
+      expect(toolFunction.getMockReady()).not.toHaveBeenCalled(); // Should not reach ready check
+      expect(mockProcessRequest).not.toHaveBeenCalled(); // Should not call service
+    });
+
+    it('should use default ready implementation when not overridden', async () => {
+      // Create a class that doesn't override ready method
+      class DefaultReadyToolFunction extends ToolFunction {
+        public constructor(request?: any) {
+          super(request || {});
+          (this as any).request = request;
+        }
+
+        public getRequest() {
+          return (this as any).request;
+        }
+      }
+
+      // Arrange
+      const readyRequest = {
+        headers: new Map(),
+        method: 'GET',
+        path: '/ready'
+      };
+      const defaultToolFunction = new DefaultReadyToolFunction(readyRequest);
+
+      // Act
+      const result = await defaultToolFunction.perform();
+
+      // Assert - Default implementation should return true
+      expect(result).toEqual(new Response(200, { ready: true }));
+      expect(mockProcessRequest).not.toHaveBeenCalled(); // Should not call service
+    });
+  });
+
   describe('bearer token validation', () => {
     it('should extract bearer token from headers and validate it', async () => {
       // Arrange
@@ -95,7 +238,7 @@ describe('ToolFunction', () => {
       // Assert
       expect(mockExtractBearerToken).toHaveBeenCalledWith(mockRequest.headers);
       expect(toolFunction.getMockValidateBearerToken()).toHaveBeenCalledWith(bearerToken);
-      expect(mockProcessRequest).toHaveBeenCalledWith(mockRequest, expect.any(Function), toolFunction);
+      expect(mockProcessRequest).toHaveBeenCalledWith(mockRequest, toolFunction);
       expect(result).toBe(mockResponse);
     });
 
@@ -129,7 +272,7 @@ describe('ToolFunction', () => {
       // Assert
       expect(mockExtractBearerToken).toHaveBeenCalledWith(mockRequest.headers);
       expect(toolFunction.getMockValidateBearerToken()).toHaveBeenCalledWith(complexToken);
-      expect(mockProcessRequest).toHaveBeenCalledWith(mockRequest, expect.any(Function), toolFunction);
+      expect(mockProcessRequest).toHaveBeenCalledWith(mockRequest, toolFunction);
       expect(result).toBe(mockResponse);
     });
 
@@ -189,7 +332,7 @@ describe('ToolFunction', () => {
       // Assert
       expect(mockExtractBearerToken).toHaveBeenCalledWith(mockRequest.headers);
       expect(toolFunction.getMockValidateBearerToken()).not.toHaveBeenCalled();
-      expect(mockProcessRequest).toHaveBeenCalledWith(mockRequest, expect.any(Function), toolFunction);
+      expect(mockProcessRequest).toHaveBeenCalledWith(mockRequest, toolFunction);
       expect(result).toBe(mockResponse);
     });
 
@@ -204,7 +347,7 @@ describe('ToolFunction', () => {
       // Assert
       expect(mockExtractBearerToken).toHaveBeenCalledWith(mockRequest.headers);
       expect(toolFunction.getMockValidateBearerToken()).not.toHaveBeenCalled();
-      expect(mockProcessRequest).toHaveBeenCalledWith(mockRequest, expect.any(Function), toolFunction);
+      expect(mockProcessRequest).toHaveBeenCalledWith(mockRequest, toolFunction);
       expect(result).toBe(mockResponse);
     });
 
@@ -232,7 +375,7 @@ describe('ToolFunction', () => {
 
       // Assert - Default implementation should return true and allow request to proceed
       expect(mockExtractBearerToken).toHaveBeenCalledWith(mockRequest.headers);
-      expect(mockProcessRequest).toHaveBeenCalledWith(mockRequest, expect.any(Function), defaultToolFunction);
+      expect(mockProcessRequest).toHaveBeenCalledWith(mockRequest, defaultToolFunction);
       expect(result).toBe(mockResponse);
     });
   });

package/src/function/ToolFunction.ts

@@ -1,4 +1,4 @@
-import { Function, Response } from '@zaiusinc/app-sdk';
+import { Function, Response, amendLogContext } from '@zaiusinc/app-sdk';
 import { toolsService } from '../service/Service';
 
 /**
@@ -23,13 +23,18 @@ export abstract class ToolFunction extends Function {
    * @returns Response as the HTTP response
    */
   public async perform(): Promise<Response> {
+    amendLogContext({ opalThreadId: this.request.headers.get('x-opal-thread-id') || '' });
     const bearerToken = toolsService.extractBearerToken(this.request.headers);
     if (bearerToken && !this.validateBearerToken(bearerToken)) {
       return new Response(403, { error: 'Forbidden' });
     }
 
+    if (this.request.path === '/ready') {
+      const isReady = await this.ready();
+      return new Response(200, { ready: isReady });
+    }
     // Pass 'this' as context so decorated methods can use the existing instance
-    return toolsService.processRequest(this.request, this.ready.bind(this), this);
+    return toolsService.processRequest(this.request, this);
   }
 
   /**

package/src/service/Service.test.ts

@@ -22,7 +22,7 @@ jest.mock('@zaiusinc/app-sdk', () => ({
 describe('ToolsService', () => {
   let mockTool: Tool<unknown>;
   let mockInteraction: Interaction<unknown>;
-  let mockReadyCheck: jest.MockedFunction<() => Promise<boolean>>;
+  let mockToolFunction: ToolFunction;
 
   beforeEach(() => {
     // Clear registered functions and interactions before each test
@@ -32,8 +32,13 @@ describe('ToolsService', () => {
     // Reset all mocks
     jest.clearAllMocks();
 
-    // Create mock ready check function
-    mockReadyCheck = jest.fn().mockResolvedValue(true);
+    // Create mock ToolFunction
+    mockToolFunction = {
+      ready: jest.fn().mockResolvedValue(true),
+      perform: jest.fn(),
+      validateBearerToken: jest.fn().mockReturnValue(true),
+      request: {} as any
+    } as any;
 
     // Create mock tool handler
     const mockToolHandler = jest.fn().mockResolvedValue({ result: 'success' });
@@ -98,7 +103,7 @@ describe('ToolsService', () => {
         );
 
         const discoveryRequest = createMockRequest({ path: '/discovery' });
-        const response = await toolsService.processRequest(discoveryRequest, mockReadyCheck);
+        const response = await toolsService.processRequest(discoveryRequest, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(response).toHaveProperty('bodyJSON');
@@ -123,7 +128,7 @@ describe('ToolsService', () => {
 
       it('should return empty functions array when no tools are registered', async () => {
         const discoveryRequest = createMockRequest({ path: '/discovery' });
-        const response = await toolsService.processRequest(discoveryRequest, mockReadyCheck);
+        const response = await toolsService.processRequest(discoveryRequest, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(response.bodyAsU8Array).toBeDefined();
@@ -157,7 +162,7 @@ describe('ToolsService', () => {
         );
 
         const discoveryRequest = createMockRequest({ path: '/discovery' });
-        const response = await toolsService.processRequest(discoveryRequest, mockReadyCheck);
+        const response = await toolsService.processRequest(discoveryRequest, mockToolFunction);
 
         expect(response.status).toBe(200);
 
@@ -190,37 +195,6 @@ describe('ToolsService', () => {
       });
     });
 
-    describe('/ready endpoint', () => {
-      it('should return ready: true when readyCheck returns true', async () => {
-        const readyRequest = createMockRequest({ path: '/ready' });
-        const mockReadyCheckTrue = jest.fn().mockResolvedValue(true);
-        const response = await toolsService.processRequest(readyRequest, mockReadyCheckTrue);
-
-        expect(response.status).toBe(200);
-        expect(response.bodyJSON).toEqual({ ready: true });
-        expect(mockReadyCheckTrue).toHaveBeenCalledTimes(1);
-      });
-
-      it('should return ready: false when readyCheck returns false', async () => {
-        const readyRequest = createMockRequest({ path: '/ready' });
-        const mockReadyCheckFalse = jest.fn().mockResolvedValue(false);
-        const response = await toolsService.processRequest(readyRequest, mockReadyCheckFalse);
-
-        expect(response.status).toBe(200);
-        expect(response.bodyJSON).toEqual({ ready: false });
-        expect(mockReadyCheckFalse).toHaveBeenCalledTimes(1);
-      });
-
-      it('should handle readyCheck throwing an error', async () => {
-        const readyRequest = createMockRequest({ path: '/ready' });
-        const mockReadyCheckError = jest.fn().mockRejectedValue(new Error('Ready check failed'));
-
-        await expect(toolsService.processRequest(readyRequest, mockReadyCheckError)).
-          rejects.toThrow('Ready check failed');
-        expect(mockReadyCheckError).toHaveBeenCalledTimes(1);
-      });
-    });
-
     describe('tool execution', () => {
       beforeEach(() => {
         toolsService.registerTool(
@@ -234,11 +208,11 @@ describe('ToolsService', () => {
 
       it('should execute tool successfully with parameters', async () => {
         const mockRequest = createMockRequest();
-        const response = await toolsService.processRequest(mockRequest, mockReadyCheck);
+        const response = await toolsService.processRequest(mockRequest, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
-          undefined, // functionContext
+          mockToolFunction, // functionContext
           { param1: 'test-value' },
           undefined
         );
@@ -248,11 +222,15 @@ describe('ToolsService', () => {
         // Create a mock ToolFunction instance
         const mockToolFunctionInstance = {
           someProperty: 'test-value',
-          someMethod: jest.fn()
-        };
+          someMethod: jest.fn(),
+          ready: jest.fn().mockResolvedValue(true),
+          perform: jest.fn(),
+          validateBearerToken: jest.fn().mockReturnValue(true),
+          request: {} as any
+        } as any;
 
         const mockRequest = createMockRequest();
-        const response = await toolsService.processRequest(mockRequest, mockReadyCheck, mockToolFunctionInstance);
+        const response = await toolsService.processRequest(mockRequest, mockToolFunctionInstance);
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
@@ -310,7 +288,7 @@ describe('ToolsService', () => {
           bodyJSON: { action: 'test' }
         });
 
-        const response = await toolsService.processRequest(testRequest, mockReadyCheck, mockToolFunctionInstance);
+        const response = await toolsService.processRequest(testRequest, mockToolFunctionInstance);
 
         expect(response.status).toBe(200);
         expect((response as any).data).toBeDefined();
@@ -342,11 +320,11 @@ describe('ToolsService', () => {
           })
         });
 
-        const response = await toolsService.processRequest(requestWithAuth, mockReadyCheck);
+        const response = await toolsService.processRequest(requestWithAuth, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
-          undefined, // functionContext
+          mockToolFunction, // functionContext
           { param1: 'test-value' },
           authData
         );
@@ -358,11 +336,11 @@ describe('ToolsService', () => {
           body: JSON.stringify({ param1: 'test-value' })
         });
 
-        const response = await toolsService.processRequest(requestWithoutWrapper, mockReadyCheck);
+        const response = await toolsService.processRequest(requestWithoutWrapper, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
-          undefined, // functionContext
+          mockToolFunction, // functionContext
           { param1: 'test-value' },
           undefined
         );
@@ -373,7 +351,7 @@ describe('ToolsService', () => {
         jest.mocked(mockTool.handler).mockRejectedValueOnce(new Error(errorMessage));
 
         const mockRequest = createMockRequest();
-        const response = await toolsService.processRequest(mockRequest, mockReadyCheck);
+        const response = await toolsService.processRequest(mockRequest, mockToolFunction);
 
         expect(response.status).toBe(500);
         expect(logger.error).toHaveBeenCalledWith(
@@ -386,7 +364,7 @@ describe('ToolsService', () => {
         jest.mocked(mockTool.handler).mockRejectedValueOnce({});
 
         const mockRequest = createMockRequest();
-        const response = await toolsService.processRequest(mockRequest, mockReadyCheck);
+        const response = await toolsService.processRequest(mockRequest, mockToolFunction);
 
         expect(response.status).toBe(500);
       });
@@ -408,10 +386,10 @@ describe('ToolsService', () => {
           body: JSON.stringify({ data: { param1: 'test-value' } })
         });
 
-        const response = await toolsService.processRequest(interactionRequest, mockReadyCheck);
+        const response = await toolsService.processRequest(interactionRequest, mockToolFunction);
 
         expect(response.status).toBe(200);
-        expect(mockInteraction.handler).toHaveBeenCalledWith(undefined, { param1: 'test-value' }, undefined);
+        expect(mockInteraction.handler).toHaveBeenCalledWith(mockToolFunction, { param1: 'test-value' }, undefined);
       });
 
       it('should handle interaction request body without data wrapper', async () => {
@@ -421,10 +399,10 @@ describe('ToolsService', () => {
           body: JSON.stringify({ param1: 'test-value' })
         });
 
-        const response = await toolsService.processRequest(interactionRequest, mockReadyCheck);
+        const response = await toolsService.processRequest(interactionRequest, mockToolFunction);
 
         expect(response.status).toBe(200);
-        expect(mockInteraction.handler).toHaveBeenCalledWith(undefined, { param1: 'test-value' }, undefined);
+        expect(mockInteraction.handler).toHaveBeenCalledWith(mockToolFunction, { param1: 'test-value' }, undefined);
       });
 
       it('should execute interaction with OptiID auth data when provided', async () => {
@@ -445,11 +423,11 @@ describe('ToolsService', () => {
           })
         });
 
-        const response = await toolsService.processRequest(interactionRequest, mockReadyCheck);
+        const response = await toolsService.processRequest(interactionRequest, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(mockInteraction.handler).toHaveBeenCalledWith(
-          undefined, // functionContext
+          mockToolFunction, // functionContext
           { param1: 'test-value' },
           authData
         );
@@ -473,11 +451,11 @@ describe('ToolsService', () => {
           })
         });
 
-        const response = await toolsService.processRequest(interactionRequest, mockReadyCheck);
+        const response = await toolsService.processRequest(interactionRequest, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(mockInteraction.handler).toHaveBeenCalledWith(
-          undefined, // functionContext
+          mockToolFunction, // functionContext
           {
             param1: 'test-value',
             auth: authData
@@ -495,7 +473,7 @@ describe('ToolsService', () => {
           bodyJSON: { data: { param1: 'test-value' } }
         });
 
-        const response = await toolsService.processRequest(interactionRequest, mockReadyCheck);
+        const response = await toolsService.processRequest(interactionRequest, mockToolFunction);
 
         expect(response.status).toBe(500);
         expect(logger.error).toHaveBeenCalledWith(
@@ -508,7 +486,7 @@ describe('ToolsService', () => {
     describe('error cases', () => {
       it('should return 404 when no matching tool or interaction is found', async () => {
         const unknownRequest = createMockRequest({ path: '/unknown-endpoint' });
-        const response = await toolsService.processRequest(unknownRequest, mockReadyCheck);
+        const response = await toolsService.processRequest(unknownRequest, mockToolFunction);
 
         expect(response.status).toBe(404);
       });
@@ -531,7 +509,7 @@ describe('ToolsService', () => {
           path: '/optid-auth-tool'
         });
 
-        const response = await toolsService.processRequest(authRequest, mockReadyCheck);
+        const response = await toolsService.processRequest(authRequest, mockToolFunction);
 
         expect(response.status).toBe(200);
       });
@@ -552,10 +530,10 @@ describe('ToolsService', () => {
           body: null
         });
 
-        const response = await toolsService.processRequest(requestWithNullBody, mockReadyCheck);
+        const response = await toolsService.processRequest(requestWithNullBody, mockToolFunction);
 
         expect(response.status).toBe(200);
-        expect(mockTool.handler).toHaveBeenCalledWith(undefined, null, undefined);
+        expect(mockTool.handler).toHaveBeenCalledWith(mockToolFunction, null, undefined);
       });
 
       it('should handle request with undefined bodyJSON', async () => {
@@ -572,10 +550,10 @@ describe('ToolsService', () => {
           body: undefined
         });
 
-        const response = await toolsService.processRequest(requestWithUndefinedBody, mockReadyCheck);
+        const response = await toolsService.processRequest(requestWithUndefinedBody, mockToolFunction);
 
         expect(response.status).toBe(200);
-        expect(mockTool.handler).toHaveBeenCalledWith(undefined, undefined, undefined);
+        expect(mockTool.handler).toHaveBeenCalledWith(mockToolFunction, undefined, undefined);
       });
 
       it('should extract auth data from bodyJSON when body exists', async () => {
@@ -603,11 +581,11 @@ describe('ToolsService', () => {
           })
         });
 
-        const response = await toolsService.processRequest(requestWithAuth, mockReadyCheck);
+        const response = await toolsService.processRequest(requestWithAuth, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
-          undefined, // functionContext
+          mockToolFunction, // functionContext
           { param1: 'test-value' },
           authData
         );
@@ -632,11 +610,11 @@ describe('ToolsService', () => {
           })
         });
 
-        const response = await toolsService.processRequest(requestWithoutAuth, mockReadyCheck);
+        const response = await toolsService.processRequest(requestWithoutAuth, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
-          undefined, // functionContext
+          mockToolFunction, // functionContext
           { param1: 'test-value' },
           undefined
         );
@@ -664,11 +642,11 @@ describe('ToolsService', () => {
           body: ''
         });
 
-        const response = await toolsService.processRequest(requestWithAuthButNoBody, mockReadyCheck);
+        const response = await toolsService.processRequest(requestWithAuthButNoBody, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
-          undefined, // functionContext
+          mockToolFunction, // functionContext
           { param1: 'test-value' },
           authData
         );

package/src/service/Service.ts

@@ -2,6 +2,7 @@
 import { AuthRequirement, Parameter } from '../types/Models';
 import * as App from '@zaiusinc/app-sdk';
 import { logger } from '@zaiusinc/app-sdk';
+import { ToolFunction } from '../function/ToolFunction';
 
 
 
@@ -22,7 +23,7 @@ export class Interaction<TAuthData> {
   public constructor(
     public name: string,
     public endpoint: string,
-    public handler: (functionContext: any, data: unknown, authData?: TAuthData) => Promise<InteractionResult>
+    public handler: (functionContext: ToolFunction, data: unknown, authData?: TAuthData) => Promise<InteractionResult>
   ) {}
 }
 
@@ -49,7 +50,7 @@ export class Tool<TAuthData> {
     public description: string,
     public parameters: Parameter[],
     public endpoint: string,
-    public handler: (functionContext: any, params: unknown, authData?: TAuthData) => Promise<unknown>,
+    public handler: (functionContext: ToolFunction, params: unknown, authData?: TAuthData) => Promise<unknown>,
     public authRequirements?: AuthRequirement[]
   ) {}
 
@@ -104,7 +105,7 @@ export class ToolsService {
   public registerTool<TAuthData>(
     name: string,
     description: string,
-    handler: (functionContext: any, params: unknown, authData?: TAuthData) => Promise<unknown>,
+    handler: (functionContext: ToolFunction, params: unknown, authData?: TAuthData) => Promise<unknown>,
     parameters: Parameter[],
     endpoint: string,
     authRequirements?: AuthRequirement[]
@@ -121,7 +122,7 @@ export class ToolsService {
    */
   public registerInteraction<TAuthData>(
     name: string,
-    handler: (functionContext: any, data: unknown, authData?: TAuthData) => Promise<InteractionResult>,
+    handler: (functionContext: ToolFunction, data: unknown, authData?: TAuthData) => Promise<InteractionResult>,
     endpoint: string
   ): void {
     const func = new Interaction<TAuthData>(name, endpoint, handler);
@@ -129,13 +130,9 @@ export class ToolsService {
   }
 
   public async processRequest(req: App.Request,
-                              readyCheck: () => Promise<boolean>,
-                              functionContext?: any): Promise<App.Response> {
+                              functionContext: ToolFunction): Promise<App.Response> {
     if (req.path === '/discovery') {
       return new App.Response(200, { functions: Array.from(this.functions.values()).map((f) => f.toJSON()) });
-    } else if (req.path === '/ready') {
-      const isReady = await readyCheck();
-      return new App.Response(200, { ready: isReady });
     } else {
       const func = this.functions.get(req.path);
       if (func) {