@forestadmin/ai-proxy 0.0.1 → 1.0.0

package/dist/errors.d.ts

@@ -0,0 +1,42 @@
+/**
+ * -------------------------------------
+ * -------------------------------------
+ * -------------------------------------
+ * All custom errors must extend the AIError class.
+ * This inheritance is crucial for proper error translation
+ * and consistent handling throughout the system.
+ * -------------------------------------
+ * -------------------------------------
+ * -------------------------------------
+ */
+export declare class AIError extends Error {
+    constructor(message: string);
+}
+export declare class AIUnprocessableError extends AIError {
+    constructor(message: string);
+}
+export declare class AINotConfiguredError extends AIError {
+    constructor();
+}
+export declare class OpenAIUnprocessableError extends AIUnprocessableError {
+    constructor(message: string);
+}
+export declare class AIToolUnprocessableError extends AIUnprocessableError {
+    constructor(message: string);
+}
+export declare class AIToolNotFoundError extends AIError {
+    constructor(message: string);
+}
+export declare class McpError extends AIError {
+    constructor(message: string);
+}
+export declare class McpConnectionError extends McpError {
+    constructor(message: string);
+}
+export declare class McpConflictError extends McpError {
+    constructor(entityName: string);
+}
+export declare class McpConfigError extends McpError {
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * -------------------------------------
+ * -------------------------------------
+ * -------------------------------------
+ * All custom errors must extend the AIError class.
+ * This inheritance is crucial for proper error translation
+ * and consistent handling throughout the system.
+ * -------------------------------------
+ * -------------------------------------
+ * -------------------------------------
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpConfigError = exports.McpConflictError = exports.McpConnectionError = exports.McpError = exports.AIToolNotFoundError = exports.AIToolUnprocessableError = exports.OpenAIUnprocessableError = exports.AINotConfiguredError = exports.AIUnprocessableError = exports.AIError = void 0;
+// eslint-disable-next-line max-classes-per-file
+class AIError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AIError';
+    }
+}
+exports.AIError = AIError;
+class AIUnprocessableError extends AIError {
+    constructor(message) {
+        super(message);
+        this.name = 'AIUnprocessableError';
+    }
+}
+exports.AIUnprocessableError = AIUnprocessableError;
+class AINotConfiguredError extends AIError {
+    constructor() {
+        super('AI is not configured. Please call addAI() on your agent.');
+        this.name = 'AINotConfiguredError';
+    }
+}
+exports.AINotConfiguredError = AINotConfiguredError;
+class OpenAIUnprocessableError extends AIUnprocessableError {
+    constructor(message) {
+        super(message);
+        this.name = 'OpenAIError';
+    }
+}
+exports.OpenAIUnprocessableError = OpenAIUnprocessableError;
+class AIToolUnprocessableError extends AIUnprocessableError {
+    constructor(message) {
+        super(message);
+        this.name = 'AIToolError';
+    }
+}
+exports.AIToolUnprocessableError = AIToolUnprocessableError;
+class AIToolNotFoundError extends AIError {
+    constructor(message) {
+        super(message);
+        this.name = 'AIToolNotFoundError';
+    }
+}
+exports.AIToolNotFoundError = AIToolNotFoundError;
+class McpError extends AIError {
+    constructor(message) {
+        super(message);
+        this.name = 'McpError';
+    }
+}
+exports.McpError = McpError;
+class McpConnectionError extends McpError {
+    constructor(message) {
+        super(message);
+        this.name = 'McpConnectionError';
+    }
+}
+exports.McpConnectionError = McpConnectionError;
+class McpConflictError extends McpError {
+    constructor(entityName) {
+        super(`"${entityName}" already exists for your project`);
+        this.name = 'McpConflictError';
+    }
+}
+exports.McpConflictError = McpConflictError;
+class McpConfigError extends McpError {
+    constructor(message) {
+        super(message);
+        this.name = 'McpConfigError';
+    }
+}
+exports.McpConfigError = McpConfigError;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7Ozs7Ozs7R0FVRzs7O0FBRUgsZ0RBQWdEO0FBQ2hELE1BQWEsT0FBUSxTQUFRLEtBQUs7SUFDaEMsWUFBWSxPQUFlO1FBQ3pCLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNmLElBQUksQ0FBQyxJQUFJLEdBQUcsU0FBUyxDQUFDO0lBQ3hCLENBQUM7Q0FDRjtBQUxELDBCQUtDO0FBRUQsTUFBYSxvQkFBcUIsU0FBUSxPQUFPO0lBQy9DLFlBQVksT0FBZTtRQUN6QixLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDZixJQUFJLENBQUMsSUFBSSxHQUFHLHNCQUFzQixDQUFDO0lBQ3JDLENBQUM7Q0FDRjtBQUxELG9EQUtDO0FBRUQsTUFBYSxvQkFBcUIsU0FBUSxPQUFPO0lBQy9DO1FBQ0UsS0FBSyxDQUFDLDBEQUEwRCxDQUFDLENBQUM7UUFDbEUsSUFBSSxDQUFDLElBQUksR0FBRyxzQkFBc0IsQ0FBQztJQUNyQyxDQUFDO0NBQ0Y7QUFMRCxvREFLQztBQUVELE1BQWEsd0JBQXlCLFNBQVEsb0JBQW9CO0lBQ2hFLFlBQVksT0FBZTtRQUN6QixLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDZixJQUFJLENBQUMsSUFBSSxHQUFHLGFBQWEsQ0FBQztJQUM1QixDQUFDO0NBQ0Y7QUFMRCw0REFLQztBQUVELE1BQWEsd0JBQXlCLFNBQVEsb0JBQW9CO0lBQ2hFLFlBQVksT0FBZTtRQUN6QixLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDZixJQUFJLENBQUMsSUFBSSxHQUFHLGFBQWEsQ0FBQztJQUM1QixDQUFDO0NBQ0Y7QUFMRCw0REFLQztBQUVELE1BQWEsbUJBQW9CLFNBQVEsT0FBTztJQUM5QyxZQUFZLE9BQWU7UUFDekIsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ2YsSUFBSSxDQUFDLElBQUksR0FBRyxxQkFBcUIsQ0FBQztJQUNwQyxDQUFDO0NBQ0Y7QUFMRCxrREFLQztBQUVELE1BQWEsUUFBUyxTQUFRLE9BQU87SUFDbkMsWUFBWSxPQUFlO1FBQ3pCLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNmLElBQUksQ0FBQyxJQUFJLEdBQUcsVUFBVSxDQUFDO0lBQ3pCLENBQUM7Q0FDRjtBQUxELDRCQUtDO0FBRUQsTUFBYSxrQkFBbUIsU0FBUSxRQUFRO0lBQzlDLFlBQVksT0FBZTtRQUN6QixLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDZixJQUFJLENBQUMsSUFBSSxHQUFHLG9CQUFvQixDQUFDO0lBQ25DLENBQUM7Q0FDRjtBQUxELGdEQUtDO0FBRUQsTUFBYSxnQkFBaUIsU0FBUSxRQUFRO0lBQzVDLFlBQVksVUFBa0I7UUFDNUIsS0FBSyxDQUFDLElBQUksVUFBVSxtQ0FBbUMsQ0FBQyxDQUFDO1FBQ3pELElBQUksQ0FBQyxJQUFJLEdBQUcsa0JBQWtCLENBQUM7SUFDakMsQ0FBQztDQUNGO0FBTEQsNENBS0M7QUFFRCxNQUFhLGNBQWUsU0FBUSxRQUFRO0lBQzFDLFlBQVksT0FBZTtRQUN6QixLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDZixJQUFJLENBQUMsSUFBSSxHQUFHLGdCQUFnQixDQUFDO0lBQy9CLENBQUM7Q0FDRjtBQUxELHdDQUtDIn0=

package/dist/examples/run-mcp-calculator-server.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=run-mcp-calculator-server.d.ts.map

package/dist/examples/run-mcp-calculator-server.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies, import/extensions */
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const zod_1 = require("zod");
+/* eslint-enable import/no-extraneous-dependencies, import/extensions */
+const simple_mcp_server_1 = __importDefault(require("./simple-mcp-server"));
+const server = new mcp_js_1.McpServer({
+    name: 'calculator',
+    version: '1.0.0',
+});
+server.tool('add', { a: zod_1.z.number(), b: zod_1.z.number() }, async ({ a, b }) => {
+    // eslint-disable-next-line no-console
+    console.log('Received add request:', a, b);
+    return { content: [{ type: 'text', text: String(a + b) }] };
+});
+(0, simple_mcp_server_1.default)(server, 3123);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVuLW1jcC1jYWxjdWxhdG9yLXNlcnZlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9leGFtcGxlcy9ydW4tbWNwLWNhbGN1bGF0b3Itc2VydmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEseUVBQXlFO0FBQ3pFLG9FQUFvRTtBQUNwRSw2QkFBd0I7QUFDeEIsd0VBQXdFO0FBRXhFLDRFQUErQztBQUUvQyxNQUFNLE1BQU0sR0FBRyxJQUFJLGtCQUFTLENBQUM7SUFDM0IsSUFBSSxFQUFFLFlBQVk7SUFDbEIsT0FBTyxFQUFFLE9BQU87Q0FDakIsQ0FBQyxDQUFDO0FBRUgsTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLEVBQUUsT0FBQyxDQUFDLE1BQU0sRUFBRSxFQUFFLENBQUMsRUFBRSxPQUFDLENBQUMsTUFBTSxFQUFFLEVBQUUsRUFBRSxLQUFLLEVBQUUsRUFBRSxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUUsRUFBRTtJQUN0RSxzQ0FBc0M7SUFDdEMsT0FBTyxDQUFDLEdBQUcsQ0FBQyx1QkFBdUIsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFFM0MsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsTUFBTSxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQztBQUM5RCxDQUFDLENBQUMsQ0FBQztBQUVILElBQUEsMkJBQVksRUFBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLENBQUMifQ==

package/dist/examples/run-mcp-zendesk-server.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=run-mcp-zendesk-server.d.ts.map

package/dist/examples/run-mcp-zendesk-server.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies, import/extensions */
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const node_zendesk_1 = __importDefault(require("node-zendesk"));
+/* eslint-enable import/no-extraneous-dependencies, import/extensions */
+const simple_mcp_server_1 = __importDefault(require("./simple-mcp-server"));
+const client = node_zendesk_1.default.createClient({
+    username: 'your-email@example.com',
+    token: 'YOUR_ZENDESK_API_TOKEN',
+    subdomain: 'your-subdomain',
+});
+const server = new mcp_js_1.McpServer({
+    name: 'zendesk',
+    version: '1.0.0',
+});
+server.tool('listUsers', {}, async () => {
+    const users = await client.users.list();
+    return { content: [{ type: 'text', text: JSON.stringify(users.map(u => u.name)) }] };
+});
+server.tool('listArticles', {}, async () => {
+    const articles = await client.helpcenter.articles.list();
+    return { content: [{ type: 'text', text: JSON.stringify(articles) }] };
+});
+(0, simple_mcp_server_1.default)(server, 3124);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVuLW1jcC16ZW5kZXNrLXNlcnZlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9leGFtcGxlcy9ydW4tbWNwLXplbmRlc2stc2VydmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEseUVBQXlFO0FBQ3pFLG9FQUFvRTtBQUNwRSxnRUFBbUM7QUFDbkMsd0VBQXdFO0FBRXhFLDRFQUErQztBQUUvQyxNQUFNLE1BQU0sR0FBRyxzQkFBTyxDQUFDLFlBQVksQ0FBQztJQUNsQyxRQUFRLEVBQUUsd0JBQXdCO0lBQ2xDLEtBQUssRUFBRSx3QkFBd0I7SUFDL0IsU0FBUyxFQUFFLGdCQUFnQjtDQUM1QixDQUFDLENBQUM7QUFFSCxNQUFNLE1BQU0sR0FBRyxJQUFJLGtCQUFTLENBQUM7SUFDM0IsSUFBSSxFQUFFLFNBQVM7SUFDZixPQUFPLEVBQUUsT0FBTztDQUNqQixDQUFDLENBQUM7QUFFSCxNQUFNLENBQUMsSUFBSSxDQUFDLFdBQVcsRUFBRSxFQUFFLEVBQUUsS0FBSyxJQUFJLEVBQUU7SUFDdEMsTUFBTSxLQUFLLEdBQUcsTUFBTSxNQUFNLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxDQUFDO0lBRXhDLE9BQU8sRUFBRSxPQUFPLEVBQUUsQ0FBQyxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLElBQUksQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDO0FBQ3ZGLENBQUMsQ0FBQyxDQUFDO0FBRUgsTUFBTSxDQUFDLElBQUksQ0FBQyxjQUFjLEVBQUUsRUFBRSxFQUFFLEtBQUssSUFBSSxFQUFFO0lBQ3pDLE1BQU0sUUFBUSxHQUFHLE1BQU0sTUFBTSxDQUFDLFVBQVUsQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLENBQUM7SUFFekQsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQztBQUN6RSxDQUFDLENBQUMsQ0FBQztBQUVILElBQUEsMkJBQVksRUFBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLENBQUMifQ==

package/dist/examples/simple-mcp-server.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+declare const _default: (server: McpServer, port: number, secureToken?: string) => import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+export default _default;
+//# sourceMappingURL=simple-mcp-server.d.ts.map

package/dist/examples/simple-mcp-server.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const express_1 = __importDefault(require("express"));
+/* eslint-enable import/no-extraneous-dependencies, import/extensions */
+const BEARER_TOKEN = 'your-secure-token-here';
+exports.default = (server, port, secureToken = BEARER_TOKEN) => {
+    const app = (0, express_1.default)();
+    app.use(express_1.default.json());
+    // Bearer Token Middleware
+    app.use('/mcp', (req, res, next) => {
+        const authHeader = req.headers.authorization || '';
+        const token = authHeader.replace(/^Bearer\s+/i, '');
+        if (token !== secureToken) {
+            res.status(401).json({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32001,
+                    message: 'Unauthorized: Invalid or missing Bearer token',
+                },
+                id: null,
+            });
+            return;
+        }
+        next();
+    });
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    app.post('/mcp', async (req, res) => {
+        try {
+            const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+                sessionIdGenerator: undefined,
+            });
+            res.on('close', () => {
+                // eslint-disable-next-line no-console
+                console.log('Request closed');
+                void transport.close();
+                void server.close();
+            });
+            await server.connect(transport);
+            await transport.handleRequest(req, res, req.body);
+        }
+        catch (error) {
+            console.error('Error handling MCP request:', error);
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32603,
+                        message: 'Internal server error',
+                    },
+                    id: null,
+                });
+            }
+        }
+    });
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    app.get('/mcp', async (req, res) => {
+        res.writeHead(405).end(JSON.stringify({
+            jsonrpc: '2.0',
+            error: { code: -32000, message: 'Method not allowed.' },
+            id: null,
+        }));
+    });
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    app.delete('/mcp', async (req, res) => {
+        res.writeHead(405).end(JSON.stringify({
+            jsonrpc: '2.0',
+            error: { code: -32000, message: 'Method not allowed.' },
+            id: null,
+        }));
+    });
+    return app.listen(port, () => {
+        // eslint-disable-next-line no-console
+        console.log(`MCP Stateless Streamable HTTP Server listening on port ${port}`);
+    });
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import type { McpConfiguration } from './mcp-client';
+export * from './provider-dispatcher';
+export * from './remote-tools';
+export * from './router';
+export * from './mcp-client';
+export * from './errors';
+export declare function validMcpConfigurationOrThrow(mcpConfig: McpConfiguration): Promise<true>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validMcpConfigurationOrThrow = validMcpConfigurationOrThrow;
+const mcp_config_checker_1 = __importDefault(require("./mcp-config-checker"));
+__exportStar(require("./provider-dispatcher"), exports);
+__exportStar(require("./remote-tools"), exports);
+__exportStar(require("./router"), exports);
+__exportStar(require("./mcp-client"), exports);
+__exportStar(require("./errors"), exports);
+function validMcpConfigurationOrThrow(mcpConfig) {
+    return mcp_config_checker_1.default.check(mcpConfig);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQVdBLG9FQUVDO0FBWEQsOEVBQW9EO0FBRXBELHdEQUFzQztBQUN0QyxpREFBK0I7QUFDL0IsMkNBQXlCO0FBQ3pCLCtDQUE2QjtBQUU3QiwyQ0FBeUI7QUFFekIsU0FBZ0IsNEJBQTRCLENBQUMsU0FBMkI7SUFDdEUsT0FBTyw0QkFBZ0IsQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDLENBQUM7QUFDM0MsQ0FBQyJ9

package/dist/mcp-client.d.ts

@@ -0,0 +1,16 @@
+import type { Logger } from '@forestadmin/datasource-toolkit';
+import { MultiServerMCPClient } from '@langchain/mcp-adapters';
+import RemoteTool from './remote-tool';
+export type McpConfiguration = {
+    configs: MultiServerMCPClient['config']['mcpServers'];
+} & Omit<MultiServerMCPClient['config'], 'mcpServers'>;
+export default class McpClient {
+    private readonly mcpClients;
+    private readonly logger?;
+    readonly tools: RemoteTool[];
+    constructor(config: McpConfiguration, logger?: Logger);
+    loadTools(): Promise<RemoteTool[]>;
+    testConnections(): Promise<true>;
+    closeConnections(): Promise<void>;
+}
+//# sourceMappingURL=mcp-client.d.ts.map

package/dist/mcp-client.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_adapters_1 = require("@langchain/mcp-adapters");
+const errors_1 = require("./errors");
+const remote_tool_1 = __importDefault(require("./remote-tool"));
+class McpClient {
+    constructor(config, logger) {
+        this.mcpClients = {};
+        this.tools = [];
+        this.logger = logger;
+        // split the config into several clients to be more resilient
+        // if a mcp server is down, the others will still work
+        Object.entries(config.configs).forEach(([name, serverConfig]) => {
+            this.mcpClients[name] = new mcp_adapters_1.MultiServerMCPClient({
+                mcpServers: { [name]: serverConfig },
+                ...config,
+            });
+        });
+    }
+    async loadTools() {
+        const errors = [];
+        await Promise.all(Object.entries(this.mcpClients).map(async ([name, client]) => {
+            try {
+                const tools = (await client.getTools()) ?? [];
+                const extendedTools = tools.map(tool => new remote_tool_1.default({
+                    tool,
+                    sourceId: name,
+                    sourceType: 'mcp-server',
+                }));
+                this.tools.push(...extendedTools);
+            }
+            catch (error) {
+                this.logger?.('Error', `Error loading tools for ${name}`, error);
+                errors.push({ server: name, error: error });
+            }
+        }));
+        // Surface partial failures to provide better feedback
+        if (errors.length > 0) {
+            const errorMessage = errors.map(e => `${e.server}: ${e.error.message}`).join('; ');
+            this.logger?.('Error', `Failed to load tools from ${errors.length}/${Object.keys(this.mcpClients).length} ` +
+                `MCP server(s): ${errorMessage}`);
+        }
+        return this.tools;
+    }
+    async testConnections() {
+        try {
+            await Promise.all(Object.values(this.mcpClients).map(client => client.initializeConnections()));
+            return true;
+        }
+        catch (error) {
+            throw new errors_1.McpConnectionError(error.message);
+        }
+        finally {
+            try {
+                await this.closeConnections();
+            }
+            catch (cleanupError) {
+                // Log but don't throw - we don't want to mask the original connection error
+                this.logger?.('Error', 'Error during test connection cleanup', cleanupError);
+            }
+        }
+    }
+    async closeConnections() {
+        const entries = Object.entries(this.mcpClients);
+        const results = await Promise.allSettled(entries.map(([, client]) => client.close()));
+        // Check for failures but don't throw - cleanup should be best-effort
+        const failures = results
+            .map((result, index) => ({ result, name: entries[index][0] }))
+            .filter(({ result }) => result.status === 'rejected');
+        if (failures.length > 0) {
+            failures.forEach(({ name, result }) => {
+                this.logger?.('Error', `Failed to close MCP connection for ${name}`, result.reason);
+            });
+            this.logger?.('Error', `Failed to close ${failures.length}/${results.length} MCP connections. ` +
+                `This may result in resource leaks.`);
+        }
+    }
+}
+exports.default = McpClient;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mcp-config-checker.d.ts

@@ -0,0 +1,5 @@
+import type { McpConfiguration } from './mcp-client';
+export default class McpConfigChecker {
+    static check(mcpConfig: McpConfiguration): Promise<true>;
+}
+//# sourceMappingURL=mcp-config-checker.d.ts.map

package/dist/mcp-config-checker.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_client_1 = __importDefault(require("./mcp-client"));
+class McpConfigChecker {
+    static check(mcpConfig) {
+        return new mcp_client_1.default(mcpConfig).testConnections();
+    }
+}
+exports.default = McpConfigChecker;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWNwLWNvbmZpZy1jaGVja2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL21jcC1jb25maWctY2hlY2tlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUVBLDhEQUFxQztBQUVyQyxNQUFxQixnQkFBZ0I7SUFDbkMsTUFBTSxDQUFDLEtBQUssQ0FBQyxTQUEyQjtRQUN0QyxPQUFPLElBQUksb0JBQVMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxlQUFlLEVBQUUsQ0FBQztJQUNwRCxDQUFDO0NBQ0Y7QUFKRCxtQ0FJQyJ9

package/dist/provider-dispatcher.d.ts

@@ -0,0 +1,19 @@
+import type { RemoteTools } from './remote-tools';
+import type { ClientOptions } from 'openai';
+import type { ChatCompletionCreateParamsNonStreaming } from 'openai/resources/chat/completions';
+export type OpenAiConfiguration = ClientOptions & {
+    provider: 'openai';
+    model: ChatCompletionCreateParamsNonStreaming['model'];
+};
+export type AiConfiguration = OpenAiConfiguration;
+export type AiProvider = AiConfiguration['provider'];
+export type OpenAIBody = Pick<ChatCompletionCreateParamsNonStreaming, 'tools' | 'messages' | 'tool_choice'>;
+export type DispatchBody = OpenAIBody;
+export declare class ProviderDispatcher {
+    private readonly aiClient;
+    private readonly remoteTools;
+    constructor(configuration: AiConfiguration | null, remoteTools: RemoteTools);
+    dispatch(body: DispatchBody): Promise<unknown>;
+    private enhanceOpenAIRemoteTools;
+}
+//# sourceMappingURL=provider-dispatcher.d.ts.map

package/dist/provider-dispatcher.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderDispatcher = void 0;
+const function_calling_1 = require("@langchain/core/utils/function_calling");
+const openai_1 = __importDefault(require("openai"));
+const errors_1 = require("./errors");
+class ProviderDispatcher {
+    constructor(configuration, remoteTools) {
+        this.aiClient = null;
+        this.remoteTools = remoteTools;
+        if (configuration?.provider === 'openai' && configuration.apiKey) {
+            const { provider, model, ...clientOptions } = configuration;
+            this.aiClient = {
+                client: new openai_1.default(clientOptions),
+                model,
+            };
+        }
+    }
+    async dispatch(body) {
+        if (!this.aiClient) {
+            throw new errors_1.AINotConfiguredError();
+        }
+        // tools, messages and tool_choice must be extracted from the body and passed as options
+        // because we don't want to let users to pass any other option
+        const { tools, messages, tool_choice: toolChoice } = body;
+        const options = {
+            model: this.aiClient.model,
+            // Add the remote tools to the tools to be used by the AI
+            tools: this.enhanceOpenAIRemoteTools(tools),
+            messages,
+            tool_choice: toolChoice,
+        };
+        try {
+            return await this.aiClient.client.chat.completions.create(options);
+        }
+        catch (error) {
+            throw new errors_1.OpenAIUnprocessableError(`Error while calling OpenAI: ${error.message}`);
+        }
+    }
+    enhanceOpenAIRemoteTools(tools) {
+        if (!tools || !Array.isArray(tools))
+            return tools;
+        const remoteToolFunctions = this.remoteTools.tools.map(extendedTools => (0, function_calling_1.convertToOpenAIFunction)(extendedTools.base));
+        return tools.map(tool => {
+            const remoteFunction = remoteToolFunctions.find(functionDefinition => functionDefinition.name === tool.function.name);
+            if (remoteFunction)
+                return { ...tool, function: remoteFunction };
+            return tool;
+        });
+    }
+}
+exports.ProviderDispatcher = ProviderDispatcher;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/remote-tool.d.ts

@@ -0,0 +1,15 @@
+import type { StructuredToolInterface } from '@langchain/core/tools';
+export type SourceType = 'server' | 'mcp-server';
+export default class RemoteTool<ToolType = unknown> {
+    base: StructuredToolInterface<ToolType>;
+    sourceId: string;
+    sourceType: SourceType;
+    constructor(options: {
+        tool: StructuredToolInterface<ToolType>;
+        sourceId?: string;
+        sourceType?: SourceType;
+    });
+    get sanitizedName(): string;
+    private sanitizeName;
+}
+//# sourceMappingURL=remote-tool.d.ts.map

package/dist/remote-tool.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RemoteTool {
+    constructor(options) {
+        this.base = options.tool;
+        this.sourceId = options.sourceId;
+        this.sourceType = options.sourceType;
+    }
+    get sanitizedName() {
+        return this.sanitizeName(this.base.name);
+    }
+    sanitizeName(name) {
+        // OpenAI function names must be alphanumeric and can contain underscores
+        // This function replaces non-alphanumeric characters with underscores
+        return name.replace(/[^a-zA-Z0-9_-]/g, '_');
+    }
+}
+exports.default = RemoteTool;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3RlLXRvb2wuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvcmVtb3RlLXRvb2wudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFJQSxNQUFxQixVQUFVO0lBSzdCLFlBQVksT0FJWDtRQUNDLElBQUksQ0FBQyxJQUFJLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQztRQUN6QixJQUFJLENBQUMsUUFBUSxHQUFHLE9BQU8sQ0FBQyxRQUFRLENBQUM7UUFDakMsSUFBSSxDQUFDLFVBQVUsR0FBRyxPQUFPLENBQUMsVUFBVSxDQUFDO0lBQ3ZDLENBQUM7SUFFRCxJQUFJLGFBQWE7UUFDZixPQUFPLElBQUksQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUMzQyxDQUFDO0lBRU8sWUFBWSxDQUFDLElBQVk7UUFDL0IseUVBQXlFO1FBQ3pFLHNFQUFzRTtRQUN0RSxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsaUJBQWlCLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDOUMsQ0FBQztDQUNGO0FBeEJELDZCQXdCQyJ9

package/dist/remote-tools.d.ts

@@ -0,0 +1,22 @@
+import type { ResponseFormat } from '@langchain/core/tools';
+import type { ChatCompletionCreateParamsNonStreaming } from 'openai/resources/chat/completions';
+import RemoteTool from './remote-tool';
+export type Messages = ChatCompletionCreateParamsNonStreaming['messages'];
+export type RemoteToolsApiKeys = {
+    ['AI_REMOTE_TOOL_BRAVE_SEARCH_API_KEY']: string;
+} | Record<string, string>;
+export declare class RemoteTools {
+    private readonly apiKeys?;
+    readonly tools: RemoteTool[];
+    constructor(apiKeys: RemoteToolsApiKeys, tools?: RemoteTool[]);
+    get toolDefinitionsForFrontend(): {
+        name: string;
+        description: string;
+        responseFormat: ResponseFormat;
+        schema: import("@langchain/core/utils/json_schema").JSONSchema;
+        sourceId: string;
+        sourceType: import("./remote-tool").SourceType;
+    }[];
+    invokeTool(toolName: string, messages: ChatCompletionCreateParamsNonStreaming['messages']): Promise<unknown>;
+}
+//# sourceMappingURL=remote-tools.d.ts.map

package/dist/remote-tools.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteTools = void 0;
+const brave_search_1 = require("@langchain/community/tools/brave_search");
+const json_schema_1 = require("@langchain/core/utils/json_schema");
+const errors_1 = require("./errors");
+const remote_tool_1 = __importDefault(require("./remote-tool"));
+class RemoteTools {
+    constructor(apiKeys, tools) {
+        this.tools = [];
+        this.apiKeys = apiKeys;
+        this.tools.push(...(tools ?? []));
+        if (this.apiKeys?.AI_REMOTE_TOOL_BRAVE_SEARCH_API_KEY) {
+            this.tools.push(new remote_tool_1.default({
+                sourceId: 'brave_search',
+                sourceType: 'server',
+                tool: new brave_search_1.BraveSearch({ apiKey: this.apiKeys.AI_REMOTE_TOOL_BRAVE_SEARCH_API_KEY }),
+            }));
+        }
+    }
+    get toolDefinitionsForFrontend() {
+        return this.tools.map(extendedTool => {
+            return {
+                name: extendedTool.sanitizedName,
+                description: extendedTool.base.description,
+                responseFormat: 'content',
+                schema: (0, json_schema_1.toJsonSchema)(extendedTool.base.schema),
+                sourceId: extendedTool.sourceId,
+                sourceType: extendedTool.sourceType,
+            };
+        });
+    }
+    async invokeTool(toolName, messages) {
+        const extendedTool = this.tools.find(exTool => exTool.sanitizedName === toolName);
+        if (!extendedTool)
+            throw new errors_1.AIToolNotFoundError(`Tool ${toolName} not found`);
+        try {
+            return (await extendedTool.base.invoke(messages));
+        }
+        catch (error) {
+            throw new errors_1.AIToolUnprocessableError(`Error while calling tool ${toolName}: ${error.message}`);
+        }
+    }
+}
+exports.RemoteTools = RemoteTools;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3RlLXRvb2xzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3JlbW90ZS10b29scy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7QUFHQSwwRUFBc0U7QUFDdEUsbUVBQWlFO0FBRWpFLHFDQUF5RTtBQUN6RSxnRUFBdUM7QUFRdkMsTUFBYSxXQUFXO0lBSXRCLFlBQVksT0FBMkIsRUFBRSxLQUFvQjtRQUZwRCxVQUFLLEdBQWlCLEVBQUUsQ0FBQztRQUdoQyxJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztRQUN2QixJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsS0FBSyxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFFbEMsSUFBSSxJQUFJLENBQUMsT0FBTyxFQUFFLG1DQUFtQyxFQUFFLENBQUM7WUFDdEQsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQ2IsSUFBSSxxQkFBVSxDQUFDO2dCQUNiLFFBQVEsRUFBRSxjQUFjO2dCQUN4QixVQUFVLEVBQUUsUUFBUTtnQkFDcEIsSUFBSSxFQUFFLElBQUksMEJBQVcsQ0FBQyxFQUFFLE1BQU0sRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLG1DQUFtQyxFQUFFLENBQUM7YUFDcEYsQ0FBQyxDQUNILENBQUM7UUFDSixDQUFDO0lBQ0gsQ0FBQztJQUVELElBQUksMEJBQTBCO1FBQzVCLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsWUFBWSxDQUFDLEVBQUU7WUFDbkMsT0FBTztnQkFDTCxJQUFJLEVBQUUsWUFBWSxDQUFDLGFBQWE7Z0JBQ2hDLFdBQVcsRUFBRSxZQUFZLENBQUMsSUFBSSxDQUFDLFdBQVc7Z0JBQzFDLGNBQWMsRUFBRSxTQUEyQjtnQkFDM0MsTUFBTSxFQUFFLElBQUEsMEJBQVksRUFBQyxZQUFZLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQztnQkFDOUMsUUFBUSxFQUFFLFlBQVksQ0FBQyxRQUFRO2dCQUMvQixVQUFVLEVBQUUsWUFBWSxDQUFDLFVBQVU7YUFDcEMsQ0FBQztRQUNKLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVELEtBQUssQ0FBQyxVQUFVLENBQUMsUUFBZ0IsRUFBRSxRQUE0RDtRQUM3RixNQUFNLFlBQVksR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxhQUFhLEtBQUssUUFBUSxDQUFDLENBQUM7UUFFbEYsSUFBSSxDQUFDLFlBQVk7WUFBRSxNQUFNLElBQUksNEJBQW1CLENBQUMsUUFBUSxRQUFRLFlBQVksQ0FBQyxDQUFDO1FBRS9FLElBQUksQ0FBQztZQUNILE9BQU8sQ0FBQyxNQUFNLFlBQVksQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFZLENBQUM7UUFDL0QsQ0FBQztRQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7WUFDZixNQUFNLElBQUksaUNBQXdCLENBQ2hDLDRCQUE0QixRQUFRLEtBQU0sS0FBZSxDQUFDLE9BQU8sRUFBRSxDQUNwRSxDQUFDO1FBQ0osQ0FBQztJQUNILENBQUM7Q0FDRjtBQTdDRCxrQ0E2Q0MifQ==

package/dist/router.d.ts

@@ -0,0 +1,43 @@
+import type { McpConfiguration } from './mcp-client';
+import type { AiConfiguration, DispatchBody } from './provider-dispatcher';
+import type { Messages, RemoteToolsApiKeys } from './remote-tools';
+import type { Logger } from '@forestadmin/datasource-toolkit';
+export type InvokeRemoteToolBody = {
+    inputs: Messages;
+};
+export type Body = DispatchBody | InvokeRemoteToolBody | undefined;
+export type Route = 'ai-query' | 'remote-tools' | 'invoke-remote-tool';
+export type Query = {
+    'tool-name'?: string;
+};
+export type ApiKeys = RemoteToolsApiKeys;
+export declare class Router {
+    private readonly localToolsApiKeys?;
+    private readonly aiConfiguration;
+    private readonly logger?;
+    constructor(params?: {
+        aiConfiguration?: AiConfiguration;
+        localToolsApiKeys?: ApiKeys;
+        logger?: Logger;
+    });
+    /**
+     * Route the request to the appropriate handler
+     *
+     * List of routes:
+     * // dispatch the query to the AI
+     * - /ai-query
+     *
+     * // invoke a remote tool by name
+     * - /invoke-remote-tool?tool-name=:toolName
+     *
+     * // get the list of available remote tools
+     * - /remote-tools
+     */
+    route(args: {
+        body?: Body;
+        route: Route;
+        query?: Query;
+        mcpConfigs?: McpConfiguration;
+    }): Promise<unknown>;
+}
+//# sourceMappingURL=router.d.ts.map

package/dist/router.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = void 0;
+const index_1 = require("./index");
+const mcp_client_1 = __importDefault(require("./mcp-client"));
+const remote_tools_1 = require("./remote-tools");
+class Router {
+    constructor(params) {
+        this.aiConfiguration = params?.aiConfiguration ?? null;
+        this.localToolsApiKeys = params?.localToolsApiKeys;
+        this.logger = params?.logger;
+    }
+    /**
+     * Route the request to the appropriate handler
+     *
+     * List of routes:
+     * // dispatch the query to the AI
+     * - /ai-query
+     *
+     * // invoke a remote tool by name
+     * - /invoke-remote-tool?tool-name=:toolName
+     *
+     * // get the list of available remote tools
+     * - /remote-tools
+     */
+    async route(args) {
+        let mcpClient;
+        try {
+            if (args.mcpConfigs) {
+                mcpClient = new mcp_client_1.default(args.mcpConfigs, this.logger);
+            }
+            const remoteTools = new remote_tools_1.RemoteTools(this.localToolsApiKeys, await mcpClient?.loadTools());
+            if (args.route === 'ai-query') {
+                return await new index_1.ProviderDispatcher(this.aiConfiguration, remoteTools).dispatch(args.body);
+            }
+            if (args.route === 'invoke-remote-tool') {
+                return await remoteTools.invokeTool(args.query['tool-name'], args.body.inputs);
+            }
+            if (args.route === 'remote-tools') {
+                return remoteTools.toolDefinitionsForFrontend;
+            }
+            // don't add mcpConfigs to the error message, as it may contain sensitive information
+            throw new index_1.AIUnprocessableError(`No action to perform: ${JSON.stringify({
+                body: args.body,
+                route: args.route,
+                query: args.query,
+            })}`);
+        }
+        finally {
+            if (mcpClient) {
+                try {
+                    await mcpClient.closeConnections();
+                }
+                catch (cleanupError) {
+                    this.logger?.('Error', 'Error during MCP connection cleanup', cleanupError);
+                }
+            }
+        }
+    }
+}
+exports.Router = Router;
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forestadmin/ai-proxy",
-  "version": "0.0.1",
+  "version": "1.0.0",
   "main": "dist/index.js",
   "license": "GPL-3.0",
   "publishConfig": {