chore(code review): merge received configs and allow validation for forest integrations

Author: nbouliol

packages/ai-proxy/src/index.ts

@@ -1,11 +1,12 @@
+import type { ForestIntegrationConfig } from './integration-client';
 import type { McpConfiguration } from './mcp-client';
 
 import McpConfigChecker from './mcp-config-checker';
 
 export { createAiProvider } from './create-ai-provider';
 export { default as ProviderDispatcher } from './provider-dispatcher';
 
-export { ForestIntegrationConfig, CustomConfig } from './integration-client';
+export { ForestIntegrationConfig, CustomConfig, ForestIntegrationName } from './integration-client';
 
 export * from './provider-dispatcher';
 export * from './remote-tools';
@@ -14,6 +15,8 @@ export * from './mcp-client';
 export * from './oauth-token-injector';
 export * from './errors';
 
-export function validMcpConfigurationOrThrow(mcpConfig: McpConfiguration) {
+export function validMcpConfigurationOrThrow(
+  mcpConfig: McpConfiguration | ForestIntegrationConfig,
+) {
   return McpConfigChecker.check(mcpConfig);
 }

packages/ai-proxy/src/integration-client.ts

@@ -1,18 +1,15 @@
 import type McpServerRemoteTool from './mcp-server-remote-tool';
 import type { Logger } from '@forestadmin/datasource-toolkit';
-import type { MultiServerMCPClient } from '@langchain/mcp-adapters';
 
 import getZendeskTools, { type ZendeskConfig } from './integrations/zendesk/tools';
 
-export type McpConfiguration = {
-  configs: MultiServerMCPClient['config']['mcpServers'];
-} & Omit<MultiServerMCPClient['config'], 'mcpServers'>;
-
 export type CustomConfig = ZendeskConfig;
+export type ForestIntegrationName = 'Zendesk';
 
 export interface ForestIntegrationConfig {
-  integrationName: string;
+  integrationName: ForestIntegrationName;
   config: CustomConfig;
+  isForestConnector: true;
 }
 
 export default class IntegrationClient {
@@ -29,7 +26,7 @@ export default class IntegrationClient {
   loadTools(): McpServerRemoteTool[] {
     this.configs.forEach(({ integrationName, config }) => {
       switch (integrationName) {
-        case 'zendesk':
+        case 'Zendesk':
           this.tools.push(...getZendeskTools(config as ZendeskConfig));
           break;
         default:

packages/ai-proxy/src/integrations/zendesk/tools.ts

@@ -6,6 +6,7 @@ import createGetTicketTool from './tools/get-ticket';
 import createGetTicketCommentsTool from './tools/get-ticket-comments';
 import createGetTicketsTool from './tools/get-tickets';
 import createUpdateTicketTool from './tools/update-ticket';
+import { getZendeskConfig } from './utils';
 import ServerRemoteTool from '../../server-remote-tool';
 
 export interface ZendeskConfig {
@@ -15,12 +16,7 @@ export interface ZendeskConfig {
 }
 
 export default function getZendeskTools(config: ZendeskConfig): RemoteTool[] {
-  const baseUrl = `https://${config.subdomain}.zendesk.com/api/v2`;
-  const auth = Buffer.from(`${config.email}/token:${config.apiToken}`).toString('base64');
-  const headers = {
-    Authorization: `Basic ${auth}`,
-    'Content-Type': 'application/json',
-  };
+  const { baseUrl, headers } = getZendeskConfig(config);
 
   return [
     createGetTicketsTool(headers, baseUrl),

packages/ai-proxy/src/mcp-client.ts

@@ -1,14 +1,17 @@
+import type { ForestIntegrationConfig } from './integration-client';
 import type { Logger } from '@forestadmin/datasource-toolkit';
 
 import { MultiServerMCPClient } from '@langchain/mcp-adapters';
 
 import { McpConnectionError } from './errors';
 import McpServerRemoteTool from './mcp-server-remote-tool';
 
+export type McpServers = MultiServerMCPClient['config']['mcpServers'];
+
 export type McpServerConfig = MultiServerMCPClient['config']['mcpServers'][string];
 
 export type McpConfiguration = {
-  configs: MultiServerMCPClient['config']['mcpServers'];
+  configs: McpServers | Record<string, ForestIntegrationConfig>;
 } & Omit<MultiServerMCPClient['config'], 'mcpServers'>;
 
 export default class McpClient {

packages/ai-proxy/src/mcp-config-checker.ts

@@ -1,9 +1,26 @@
+import type { ForestIntegrationConfig } from './integration-client';
 import type { McpConfiguration } from './mcp-client';
 
+import { validateZendeskConfig } from './integrations/zendesk/utils';
 import McpClient from './mcp-client';
 
 export default class McpConfigChecker {
-  static check(mcpConfig: McpConfiguration) {
+  static isForestIntegrationConfig(
+    config: McpConfiguration | ForestIntegrationConfig,
+  ): config is ForestIntegrationConfig {
+    return 'integrationName' in config;
+  }
+
+  static check(mcpConfig: McpConfiguration | ForestIntegrationConfig) {
+    if (McpConfigChecker.isForestIntegrationConfig(mcpConfig)) {
+      switch (mcpConfig.integrationName) {
+        case 'Zendesk':
+          return validateZendeskConfig(mcpConfig.config);
+        default:
+          throw new Error(`Unsupported integration: ${mcpConfig.integrationName}`);
+      }
+    }
+
     return new McpClient(mcpConfig).testConnections();
   }
 }

packages/ai-proxy/src/router.ts

@@ -63,7 +63,6 @@ export class Router {
   async route(
     args: RouteArgs & {
       mcpConfigs?: McpConfiguration;
-      integrationConfigs?: ForestIntegrationConfig[];
     },
   ) {
     // Validate input with Zod schema
@@ -77,13 +76,24 @@ export class Router {
     let mcpClient: McpClient | undefined;
     let integrationClient: IntegrationClient | undefined;
 
+    const mcpConfigs: McpConfiguration = { configs: {} };
+    const integrationConfigs: ForestIntegrationConfig[] = [];
+
+    Object.entries(args.mcpConfigs.configs).forEach(([name, config]) => {
+      if (config.isForestConnector) {
+        integrationConfigs.push(config as ForestIntegrationConfig);
+      } else {
+        mcpConfigs.configs[name] = config;
+      }
+    });
+
     try {
-      if (args.mcpConfigs) {
-        mcpClient = new McpClient(args.mcpConfigs, this.logger);
+      if (mcpConfigs && Object.keys(mcpConfigs.configs).length > 0) {
+        mcpClient = new McpClient(mcpConfigs, this.logger);
       }
 
-      if (args.integrationConfigs) {
-        integrationClient = new IntegrationClient(args.integrationConfigs, this.logger);
+      if (integrationConfigs.length > 0) {
+        integrationClient = new IntegrationClient(integrationConfigs, this.logger);
       }
 
       const remoteTools = new RemoteTools(this.localToolsApiKeys ?? {}, [

packages/ai-proxy/test/router.test.ts

@@ -2,6 +2,7 @@ import type { DispatchBody, InvokeRemoteToolArgs } from '../src';
 import type { Logger } from '@forestadmin/datasource-toolkit';
 
 import { AIModelNotSupportedError, Router } from '../src';
+import IntegrationClient from '../src/integration-client';
 import McpClient from '../src/mcp-client';
 import ProviderDispatcher from '../src/provider-dispatcher';
 
@@ -39,6 +40,18 @@ jest.mock('../src/mcp-client', () => {
 
 const MockedMcpClient = McpClient as jest.MockedClass<typeof McpClient>;
 
+const loadToolsMock = jest.fn().mockReturnValue([]);
+jest.mock('../src/integration-client', () => {
+  return {
+    __esModule: true,
+    default: jest.fn().mockImplementation(() => ({
+      loadTools: loadToolsMock,
+    })),
+  };
+});
+
+const MockedIntegrationClient = IntegrationClient as jest.MockedClass<typeof IntegrationClient>;
+
 describe('route', () => {
   beforeEach(() => {
     jest.clearAllMocks();
@@ -60,6 +73,7 @@ describe('route', () => {
       await router.route({
         route: 'ai-query',
         body: { tools: [], tool_choice: 'required', messages: [] } as unknown as DispatchBody,
+        mcpConfigs: { configs: {} },
       });
 
       expect(dispatchMock).toHaveBeenCalledWith({
@@ -90,6 +104,7 @@ describe('route', () => {
         route: 'ai-query',
         query: { 'ai-name': 'gpt4mini' },
         body: { tools: [], tool_choice: 'required', messages: [] } as unknown as DispatchBody,
+        mcpConfigs: { configs: {} },
       });
 
       expect(ProviderDispatcherMock).toHaveBeenCalledWith(gpt4MiniConfig, expect.anything());
@@ -115,6 +130,7 @@ describe('route', () => {
       await router.route({
         route: 'ai-query',
         body: { tools: [], tool_choice: 'required', messages: [] } as unknown as DispatchBody,
+        mcpConfigs: { configs: {} },
       });
 
       expect(ProviderDispatcherMock).toHaveBeenCalledWith(gpt4Config, expect.anything());
@@ -137,6 +153,7 @@ describe('route', () => {
         route: 'ai-query',
         query: { 'ai-name': 'non-existent' },
         body: { tools: [], tool_choice: 'required', messages: [] } as unknown as DispatchBody,
+        mcpConfigs: { configs: {} },
       });
 
       expect(mockLogger).toHaveBeenCalledWith(
@@ -155,6 +172,7 @@ describe('route', () => {
         route: 'invoke-remote-tool',
         query: { 'tool-name': 'tool-name' },
         body: { inputs: [] },
+        mcpConfigs: { configs: {} },
       });
 
       expect(invokeToolMock).toHaveBeenCalledWith('tool-name', []);
@@ -168,6 +186,7 @@ describe('route', () => {
           route: 'invoke-remote-tool',
           query: {},
           body: { inputs: [] },
+          mcpConfigs: { configs: {} },
         } as any),
       ).rejects.toThrow('query.tool-name: Missing required query parameter: tool-name');
     });
@@ -180,6 +199,7 @@ describe('route', () => {
           route: 'invoke-remote-tool',
           query: { 'tool-name': 'tool-name' },
           body: {} as InvokeRemoteToolArgs['body'],
+          mcpConfigs: { configs: {} },
         }),
       ).rejects.toThrow('body.inputs: Missing required body parameter: inputs');
     });
@@ -192,6 +212,7 @@ describe('route', () => {
           route: 'invoke-remote-tool',
           query: {},
           body: {},
+          mcpConfigs: { configs: {} },
         } as any),
       ).rejects.toThrow(/tool-name.*;.*inputs|inputs.*;.*tool-name/);
     });
@@ -201,7 +222,7 @@ describe('route', () => {
     it('returns the remote tools definitions', async () => {
       const router = new Router({});
 
-      const result = await router.route({ route: 'remote-tools' });
+      const result = await router.route({ route: 'remote-tools', mcpConfigs: { configs: {} } });
 
       expect(result).toEqual(toolDefinitionsForFrontend);
     });
@@ -211,7 +232,9 @@ describe('route', () => {
     it('throws a validation error with helpful message', async () => {
       const router = new Router({});
 
-      await expect(router.route({ route: 'unknown' } as any)).rejects.toThrow(
+      await expect(
+        router.route({ route: 'unknown', mcpConfigs: { configs: {} } } as any),
+      ).rejects.toThrow(
         "Invalid route. Expected: 'ai-query', 'invoke-remote-tool', 'remote-tools'",
       );
     });
@@ -264,11 +287,12 @@ describe('route', () => {
       expect(mcpClientInstance.closeConnections).toHaveBeenCalledTimes(1);
     });
 
-    it('does not call closeConnections when no mcpConfigs provided', async () => {
+    it('does not call closeConnections when no mcp configs provided', async () => {
       const router = new Router({});
 
       await router.route({
         route: 'remote-tools',
+        mcpConfigs: { configs: {} },
       });
 
       expect(MockedMcpClient).not.toHaveBeenCalled();
@@ -385,6 +409,72 @@ describe('route', () => {
     });
   });
 
+  describe('config splitting between MCP and integration configs', () => {
+    const zendeskIntegration = {
+      isForestConnector: true,
+      integrationName: 'zendesk',
+      config: { subdomain: 'test', apiToken: 'token', email: 'a@b.c' },
+    };
+
+    it('passes only non-forest configs to McpClient', async () => {
+      const router = new Router({});
+
+      await router.route({
+        route: 'remote-tools',
+        mcpConfigs: {
+          configs: {
+            server1: { command: 'test', args: [] },
+            zendesk: zendeskIntegration,
+          } as any,
+        },
+      });
+
+      expect(MockedMcpClient).toHaveBeenCalledWith(
+        { configs: { server1: { command: 'test', args: [] } } },
+        undefined,
+      );
+    });
+
+    it('passes forest configs to IntegrationClient', async () => {
+      const router = new Router({});
+
+      await router.route({
+        route: 'remote-tools',
+        mcpConfigs: {
+          configs: { zendesk: zendeskIntegration } as any,
+        },
+      });
+
+      expect(MockedIntegrationClient).toHaveBeenCalledWith([zendeskIntegration], undefined);
+    });
+
+    it('does not create IntegrationClient when no forest configs', async () => {
+      const router = new Router({});
+
+      await router.route({
+        route: 'remote-tools',
+        mcpConfigs: {
+          configs: { server1: { command: 'test', args: [] } },
+        },
+      });
+
+      expect(MockedIntegrationClient).not.toHaveBeenCalled();
+    });
+
+    it('does not create McpClient when only forest configs', async () => {
+      const router = new Router({});
+
+      await router.route({
+        route: 'remote-tools',
+        mcpConfigs: {
+          configs: { zendesk: zendeskIntegration } as any,
+        },
+      });
+
+      expect(MockedMcpClient).not.toHaveBeenCalled();
+    });
+  });
+
   describe('Model validation', () => {
     it('throws AIModelNotSupportedError when model does not support tools', () => {
       expect(