@olane/o-tool-registry 0.6.12 → 0.6.13

package/dist/auth/oAuth.tool.js

@@ -0,0 +1,419 @@
+import { oVirtualTool } from '@olane/o-tool';
+import { oAddress } from '@olane/o-core';
+import { oauthMethods } from './methods/auth.methods.js';
+export class OAuthTool extends oVirtualTool {
+    constructor(config) {
+        super({
+            ...config,
+            address: new oAddress('o://oauth'),
+            description: 'Generic OAuth client tool for custom OAuth provider services',
+            methods: oauthMethods,
+        });
+        this.oauthConfigs = new Map();
+        this.tokenStore = new Map();
+    }
+    // Tool methods
+    async _tool_configure(request) {
+        const { serviceName, ...config } = request.params;
+        if (!serviceName) {
+            throw new Error('Service name is required');
+        }
+        const oauthConfig = {
+            clientId: config.clientId,
+            clientSecret: config.clientSecret,
+            redirectUri: config.redirectUri,
+            authorizationUrl: config.authorizationUrl,
+            tokenUrl: config.tokenUrl,
+            userInfoUrl: config.userInfoUrl,
+            scope: config.scope || 'openid profile email',
+            responseType: config.responseType || 'code',
+            grantType: config.grantType || 'authorization_code',
+            tokenValidationUrl: config.tokenValidationUrl,
+            tokenRevocationUrl: config.tokenRevocationUrl,
+        };
+        this.oauthConfigs.set(serviceName, oauthConfig);
+        this.logger.info(`OAuth configuration saved for service: ${serviceName}`);
+        return {
+            success: true,
+            serviceName,
+            message: `OAuth configuration saved for service: ${serviceName}`,
+            endpoints: {
+                authorization: config.authorizationUrl,
+                token: config.tokenUrl,
+                userInfo: config.userInfoUrl,
+                tokenValidation: config.tokenValidationUrl,
+                tokenRevocation: config.tokenRevocationUrl,
+            },
+        };
+    }
+    async _tool_getAuthorizationUrl(request) {
+        const { serviceName, state, scope, additionalParams } = request.params;
+        const config = this.oauthConfigs.get(serviceName);
+        if (!config) {
+            throw new Error(`OAuth configuration not found for service: ${serviceName}`);
+        }
+        const url = new URL(config.authorizationUrl);
+        url.searchParams.set('client_id', config.clientId);
+        url.searchParams.set('redirect_uri', config.redirectUri);
+        url.searchParams.set('response_type', config.responseType || 'code');
+        url.searchParams.set('scope', scope || config.scope);
+        if (state) {
+            url.searchParams.set('state', state);
+        }
+        // Add PKCE support for authorization code flow
+        if (config.responseType === 'code') {
+            const codeVerifier = this.generateCodeVerifier();
+            const codeChallenge = await this.generateCodeChallenge(codeVerifier);
+            url.searchParams.set('code_challenge', codeChallenge);
+            url.searchParams.set('code_challenge_method', 'S256');
+            // Store code verifier for later use
+            this.tokenStore.set(`${serviceName}_code_verifier`, {
+                code_verifier: codeVerifier,
+                access_token: '',
+                token_type: '',
+            });
+        }
+        // Add any additional parameters
+        if (additionalParams && typeof additionalParams === 'object') {
+            Object.entries(additionalParams).forEach(([key, value]) => {
+                if (typeof value === 'string') {
+                    url.searchParams.set(key, value);
+                }
+            });
+        }
+        return {
+            authorizationUrl: url.toString(),
+            serviceName,
+            state,
+            scope: scope || config.scope,
+        };
+    }
+    async _tool_exchangeCode(request) {
+        const { serviceName, code, state } = request.params;
+        const config = this.oauthConfigs.get(serviceName);
+        if (!config) {
+            throw new Error(`OAuth configuration not found for service: ${serviceName}`);
+        }
+        const tokenData = {
+            grant_type: config.grantType,
+            client_id: config.clientId,
+            redirect_uri: config.redirectUri,
+            code,
+        };
+        if (config.clientSecret) {
+            tokenData.client_secret = config.clientSecret;
+        }
+        // Add PKCE code verifier if available
+        const storedVerifier = this.tokenStore.get(`${serviceName}_code_verifier`);
+        if (storedVerifier?.code_verifier) {
+            tokenData.code_verifier = storedVerifier.code_verifier;
+            this.tokenStore.delete(`${serviceName}_code_verifier`);
+        }
+        try {
+            const response = await fetch(config.tokenUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: new URLSearchParams(tokenData),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Token exchange failed: ${response.status} ${errorText}`);
+            }
+            const tokens = (await response.json());
+            // Store tokens
+            this.tokenStore.set(`${serviceName}_tokens`, tokens);
+            this.logger.info(`Token exchange successful for service: ${serviceName}`);
+            return {
+                success: true,
+                serviceName,
+                tokens: {
+                    access_token: tokens.access_token,
+                    refresh_token: tokens.refresh_token,
+                    token_type: tokens.token_type,
+                    expires_in: tokens.expires_in,
+                    scope: tokens.scope,
+                },
+            };
+        }
+        catch (error) {
+            this.logger.error(`Token exchange failed for service ${serviceName}:`, error);
+            throw error;
+        }
+    }
+    async _tool_refreshToken(request) {
+        const { serviceName, refreshToken } = request.params;
+        const config = this.oauthConfigs.get(serviceName);
+        if (!config) {
+            throw new Error(`OAuth configuration not found for service: ${serviceName}`);
+        }
+        const tokenData = {
+            grant_type: 'refresh_token',
+            client_id: config.clientId,
+            refresh_token: refreshToken,
+        };
+        if (config.clientSecret) {
+            tokenData.client_secret = config.clientSecret;
+        }
+        try {
+            const response = await fetch(config.tokenUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: new URLSearchParams(tokenData),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Token refresh failed: ${response.status} ${errorText}`);
+            }
+            const tokens = (await response.json());
+            // Update stored tokens
+            const existingTokens = this.tokenStore.get(`${serviceName}_tokens`);
+            if (existingTokens) {
+                existingTokens.access_token = tokens.access_token;
+                existingTokens.expires_in = tokens.expires_in;
+                if (tokens.refresh_token) {
+                    existingTokens.refresh_token = tokens.refresh_token;
+                }
+                this.tokenStore.set(`${serviceName}_tokens`, existingTokens);
+            }
+            this.logger.info(`Token refresh successful for service: ${serviceName}`);
+            return {
+                success: true,
+                serviceName,
+                tokens: {
+                    access_token: tokens.access_token,
+                    refresh_token: tokens.refresh_token,
+                    token_type: tokens.token_type,
+                    expires_in: tokens.expires_in,
+                    scope: tokens.scope,
+                },
+            };
+        }
+        catch (error) {
+            this.logger.error(`Token refresh failed for service ${serviceName}:`, error);
+            throw error;
+        }
+    }
+    async _tool_getUserInfo(request) {
+        const { serviceName, accessToken, userInfoUrl } = request.params;
+        const config = this.oauthConfigs.get(serviceName);
+        if (!config) {
+            throw new Error(`OAuth configuration not found for service: ${serviceName}`);
+        }
+        const url = userInfoUrl || config.userInfoUrl;
+        if (!url) {
+            throw new Error(`No user info URL configured for service: ${serviceName}`);
+        }
+        try {
+            const response = await fetch(url, {
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                    Accept: 'application/json',
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`User info request failed: ${response.status} ${errorText}`);
+            }
+            const userInfo = (await response.json());
+            return {
+                success: true,
+                serviceName,
+                userInfo,
+            };
+        }
+        catch (error) {
+            this.logger.error(`User info request failed for service ${serviceName}:`, error);
+            throw error;
+        }
+    }
+    async _tool_validateToken(request) {
+        const { serviceName, accessToken, tokenValidationUrl } = request.params;
+        const config = this.oauthConfigs.get(serviceName);
+        if (!config) {
+            throw new Error(`OAuth configuration not found for service: ${serviceName}`);
+        }
+        const url = tokenValidationUrl || config.tokenValidationUrl;
+        if (!url) {
+            throw new Error(`No token validation URL configured for service: ${serviceName}`);
+        }
+        try {
+            const response = await fetch(url, {
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                    Accept: 'application/json',
+                },
+            });
+            const isValid = response.ok;
+            return {
+                success: true,
+                serviceName,
+                isValid,
+                status: response.status,
+                statusText: response.statusText,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Token validation failed for service ${serviceName}:`, error);
+            return {
+                success: true,
+                serviceName,
+                isValid: false,
+                error: error.message,
+            };
+        }
+    }
+    async _tool_revokeToken(request) {
+        const { serviceName, token, tokenType = 'access_token', tokenRevocationUrl, } = request.params;
+        const config = this.oauthConfigs.get(serviceName);
+        if (!config) {
+            throw new Error(`OAuth configuration not found for service: ${serviceName}`);
+        }
+        const url = tokenRevocationUrl || config.tokenRevocationUrl;
+        if (!url) {
+            throw new Error(`No token revocation URL configured for service: ${serviceName}`);
+        }
+        const revocationData = {
+            token,
+            client_id: config.clientId,
+        };
+        if (config.clientSecret) {
+            revocationData.client_secret = config.clientSecret;
+        }
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: new URLSearchParams(revocationData),
+            });
+            const isRevoked = response.ok;
+            // Remove tokens from storage if revoked
+            if (isRevoked) {
+                const storedTokens = this.tokenStore.get(`${serviceName}_tokens`);
+                if (storedTokens) {
+                    if (tokenType === 'access_token' &&
+                        storedTokens.access_token === token) {
+                        this.tokenStore.delete(`${serviceName}_tokens`);
+                    }
+                    else if (tokenType === 'refresh_token' &&
+                        storedTokens.refresh_token === token) {
+                        delete storedTokens.refresh_token;
+                        this.tokenStore.set(`${serviceName}_tokens`, storedTokens);
+                    }
+                }
+            }
+            return {
+                success: true,
+                serviceName,
+                isRevoked,
+                tokenType,
+                status: response.status,
+                statusText: response.statusText,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Token revocation failed for service ${serviceName}:`, error);
+            return {
+                success: true,
+                serviceName,
+                isRevoked: false,
+                tokenType,
+                error: error.message,
+            };
+        }
+    }
+    async _tool_listServices(request) {
+        const services = Array.from(this.oauthConfigs.keys());
+        return {
+            success: true,
+            services,
+            count: services.length,
+        };
+    }
+    async _tool_getStoredTokens(request) {
+        const { serviceName } = request.params;
+        if (serviceName) {
+            const tokens = this.tokenStore.get(`${serviceName}_tokens`);
+            return {
+                success: true,
+                serviceName,
+                hasTokens: !!tokens,
+                tokens: tokens
+                    ? {
+                        access_token: tokens.access_token,
+                        refresh_token: tokens.refresh_token,
+                        token_type: tokens.token_type,
+                        expires_in: tokens.expires_in,
+                        scope: tokens.scope,
+                    }
+                    : null,
+            };
+        }
+        else {
+            const allTokens = {};
+            for (const [key, value] of this.tokenStore.entries()) {
+                if (key.endsWith('_tokens')) {
+                    const serviceName = key.replace('_tokens', '');
+                    allTokens[serviceName] = {
+                        access_token: value.access_token,
+                        refresh_token: value.refresh_token,
+                        token_type: value.token_type,
+                        expires_in: value.expires_in,
+                        scope: value.scope,
+                    };
+                }
+            }
+            return {
+                success: true,
+                tokens: allTokens,
+            };
+        }
+    }
+    async _tool_clearTokens(request) {
+        const { serviceName } = request.params;
+        if (serviceName) {
+            this.tokenStore.delete(`${serviceName}_tokens`);
+            this.tokenStore.delete(`${serviceName}_code_verifier`);
+            return {
+                success: true,
+                serviceName,
+                message: `Tokens cleared for service: ${serviceName}`,
+            };
+        }
+        else {
+            // Clear all tokens
+            for (const key of this.tokenStore.keys()) {
+                if (key.endsWith('_tokens') || key.endsWith('_code_verifier')) {
+                    this.tokenStore.delete(key);
+                }
+            }
+            return {
+                success: true,
+                message: 'All tokens cleared',
+            };
+        }
+    }
+    // Helper methods
+    generateCodeVerifier() {
+        const array = new Uint8Array(32);
+        crypto.getRandomValues(array);
+        return this.base64URLEncode(array);
+    }
+    async generateCodeChallenge(verifier) {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(verifier);
+        const digest = await crypto.subtle.digest('SHA-256', data);
+        return this.base64URLEncode(new Uint8Array(digest));
+    }
+    base64URLEncode(buffer) {
+        return btoa(String.fromCharCode(...buffer))
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=/g, '');
+    }
+}

package/dist/embeddings/embeddings.tool.d.ts

@@ -0,0 +1,6 @@
+import { oVirtualTool } from '@olane/o-tool';
+import { oToolConfig } from '@olane/o-tool';
+export declare class EmbeddingsTool extends oVirtualTool {
+    constructor(config: oToolConfig);
+}
+//# sourceMappingURL=embeddings.tool.d.ts.map

package/dist/embeddings/embeddings.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embeddings.tool.d.ts","sourceRoot":"","sources":["../../src/embeddings/embeddings.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,YAAY,EAAE,MAAM,eAAe,CAAC;AAEpD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,qBAAa,cAAe,SAAQ,YAAY;gBAClC,MAAM,EAAE,WAAW;CAQhC"}

package/dist/embeddings/embeddings.tool.js

@@ -0,0 +1,11 @@
+import { oVirtualTool } from '@olane/o-tool';
+import { oAddress } from '@olane/o-core';
+export class EmbeddingsTool extends oVirtualTool {
+    constructor(config) {
+        super({
+            ...config,
+            address: new oAddress('o://embeddings'),
+            description: config.description || 'Generic base class for embeddings tools',
+        });
+    }
+}

package/dist/embeddings/huggingface-text-embeddings.tool.d.ts

@@ -0,0 +1,9 @@
+import { oRequest } from '@olane/o-core';
+import { TextEmbeddingsTool } from './text-embeddings.tool.js';
+export declare class HuggingfaceTextEmbeddingsTool extends TextEmbeddingsTool {
+    private model;
+    initialize(): Promise<void>;
+    _tool_embed_documents(request: oRequest): Promise<number[][]>;
+    _tool_embed_query(request: oRequest): Promise<number[]>;
+}
+//# sourceMappingURL=huggingface-text-embeddings.tool.d.ts.map

package/dist/embeddings/huggingface-text-embeddings.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"huggingface-text-embeddings.tool.d.ts","sourceRoot":"","sources":["../../src/embeddings/huggingface-text-embeddings.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAG/D,qBAAa,6BAA8B,SAAQ,kBAAkB;IACnE,OAAO,CAAC,KAAK,CAAqC;IAE5C,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAO3B,qBAAqB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;IAM7D,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CAM9D"}

package/dist/embeddings/huggingface-text-embeddings.tool.js

@@ -0,0 +1,21 @@
+import { TextEmbeddingsTool } from './text-embeddings.tool.js';
+import { HuggingFaceTransformersEmbeddings } from '@langchain/community/embeddings/huggingface_transformers';
+export class HuggingfaceTextEmbeddingsTool extends TextEmbeddingsTool {
+    async initialize() {
+        await super.initialize();
+        this.model = new HuggingFaceTransformersEmbeddings({
+            model: 'Xenova/all-MiniLM-L6-v2', // TODO: make this configurable
+        });
+    }
+    async _tool_embed_documents(request) {
+        const { documents } = request.params;
+        const result = await this.model.embedDocuments(documents);
+        return result;
+    }
+    async _tool_embed_query(request) {
+        const { query } = request.params;
+        console.log('Embedding query: ', request.params);
+        const result = await this.model.embedQuery(query);
+        return result;
+    }
+}

package/dist/embeddings/index.d.ts

@@ -0,0 +1,4 @@
+export * from './huggingface-text-embeddings.tool.js';
+export * from './text-embeddings.tool.js';
+export * from './embeddings.tool.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/embeddings/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/embeddings/index.ts"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAC;AACtD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC"}

package/dist/embeddings/index.js

@@ -0,0 +1,3 @@
+export * from './huggingface-text-embeddings.tool.js';
+export * from './text-embeddings.tool.js';
+export * from './embeddings.tool.js';

package/dist/embeddings/methods/text-embeddings.method.d.ts

@@ -0,0 +1,5 @@
+import { oMethod } from '@olane/o-protocol';
+export declare const TEXT_EMBEDDINGS_PARAMS: {
+    [key: string]: oMethod;
+};
+//# sourceMappingURL=text-embeddings.method.d.ts.map

package/dist/embeddings/methods/text-embeddings.method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-embeddings.method.d.ts","sourceRoot":"","sources":["../../../src/embeddings/methods/text-embeddings.method.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE5C,eAAO,MAAM,sBAAsB,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CA4B5D,CAAC"}

package/dist/embeddings/methods/text-embeddings.method.js

@@ -0,0 +1,29 @@
+export const TEXT_EMBEDDINGS_PARAMS = {
+    embed_documents: {
+        name: 'embed_documents',
+        description: 'Embed documents',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'documents',
+                type: 'array',
+                value: 'string[]',
+                description: 'The documents to embed',
+                required: true,
+            },
+        ],
+    },
+    embed_query: {
+        name: 'embed_query',
+        description: 'Embed a query',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'query',
+                type: 'string',
+                value: 'string',
+                description: 'The query to embed',
+            },
+        ],
+    },
+};

package/dist/embeddings/text-embeddings.tool.d.ts

@@ -0,0 +1,9 @@
+import { oVirtualTool } from '@olane/o-tool';
+import { oRequest } from '@olane/o-core';
+import { oToolConfig } from '@olane/o-tool';
+export declare abstract class TextEmbeddingsTool extends oVirtualTool {
+    constructor(config: oToolConfig);
+    abstract _tool_embed_documents(request: oRequest): Promise<number[][]>;
+    abstract _tool_embed_query(request: oRequest): Promise<number[]>;
+}
+//# sourceMappingURL=text-embeddings.tool.d.ts.map

package/dist/embeddings/text-embeddings.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-embeddings.tool.d.ts","sourceRoot":"","sources":["../../src/embeddings/text-embeddings.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAY,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C,8BAAsB,kBAAmB,SAAQ,YAAY;gBAC/C,MAAM,EAAE,WAAW;IAS/B,QAAQ,CAAC,qBAAqB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;IACtE,QAAQ,CAAC,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CACjE"}

package/dist/embeddings/text-embeddings.tool.js

@@ -0,0 +1,13 @@
+import { oVirtualTool } from '@olane/o-tool';
+import { oAddress } from '@olane/o-core';
+import { TEXT_EMBEDDINGS_PARAMS } from './methods/text-embeddings.method.js';
+export class TextEmbeddingsTool extends oVirtualTool {
+    constructor(config) {
+        super({
+            ...config,
+            address: new oAddress('o://embeddings-text'),
+            methods: TEXT_EMBEDDINGS_PARAMS,
+            description: config.description || 'Tool to generate text embeddings',
+        });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './intelligence/index.js';
+export * from './init.js';
+export * from './nlp/index.js';
+export * from './vector-store/index.js';
+export * from './mcp/index.js';
+export * from './auth/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,yBAAyB,CAAC;AACxC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from './intelligence/index.js';
+export * from './init.js';
+export * from './nlp/index.js';
+export * from './vector-store/index.js';
+export * from './mcp/index.js';
+export * from './auth/index.js';

package/dist/init.d.ts

@@ -0,0 +1,3 @@
+import { oVirtualTool } from '@olane/o-tool';
+export declare const initRegistryTools: (oNode: oVirtualTool) => void;
+//# sourceMappingURL=init.d.ts.map

package/dist/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,eAAO,MAAM,iBAAiB,UAAW,YAAY,KAAG,IA8BvD,CAAC"}

package/dist/init.js

@@ -0,0 +1,36 @@
+import { NERTool } from './nlp/ner.tool.js';
+import { HuggingfaceTextEmbeddingsTool } from './embeddings/index.js';
+import { LangchainMemoryVectorStoreTool } from './vector-store/index.js';
+import { IntelligenceTool } from './intelligence/index.js';
+import { McpBridgeTool } from './mcp/index.js';
+export const initRegistryTools = (oNode) => {
+    const params = {
+        parent: oNode.address,
+        leader: oNode.address,
+    };
+    const tools = [
+        new NERTool({
+            name: 'ner',
+            ...params,
+        }),
+        new IntelligenceTool({
+            name: 'intelligence',
+            ...params,
+        }),
+        new HuggingfaceTextEmbeddingsTool({
+            name: 'embeddings-text',
+            ...params,
+        }),
+        new LangchainMemoryVectorStoreTool({
+            name: 'vector-store',
+            ...params,
+        }),
+        new McpBridgeTool({
+            name: 'mcp',
+            ...params,
+        }),
+    ];
+    tools.forEach((tool) => {
+        oNode.addChildNode(tool);
+    });
+};