@olane/o-tool-registry 0.6.7 → 0.6.9

package/dist/intelligence/perplexity-intelligence.tool.js

@@ -0,0 +1,309 @@
+import { oAddress } from '@olane/o-core';
+import { oVirtualTool } from '@olane/o-tool';
+import { INTELLIGENCE_PARAMS } from './methods/intelligence.methods.js';
+export class PerplexityIntelligenceTool extends oVirtualTool {
+    constructor(config) {
+        super({
+            ...config,
+            address: new oAddress('o://perplexity'),
+            description: 'Intelligence tool using Perplexity LLM suite of models',
+            methods: INTELLIGENCE_PARAMS,
+            dependencies: [],
+        });
+    }
+    /**
+     * Chat completion with Perplexity
+     */
+    async _tool_completion(request) {
+        try {
+            const params = request.params;
+            const { model = this.defaultModel, messages, max_tokens, temperature, top_p, top_k, presence_penalty, frequency_penalty, apiKey, search_domain, return_citations, return_images, return_related_questions, } = params;
+            if (!messages || !Array.isArray(messages)) {
+                return {
+                    success: false,
+                    error: '"messages" array is required',
+                };
+            }
+            if (!apiKey) {
+                return {
+                    success: false,
+                    error: 'Perplexity API key is required',
+                };
+            }
+            const chatRequest = {
+                model: model,
+                messages: messages,
+                stream: false,
+            };
+            // Add optional parameters if provided
+            if (max_tokens !== undefined)
+                chatRequest.max_tokens = max_tokens;
+            if (temperature !== undefined)
+                chatRequest.temperature = temperature;
+            if (top_p !== undefined)
+                chatRequest.top_p = top_p;
+            if (top_k !== undefined)
+                chatRequest.top_k = top_k;
+            if (presence_penalty !== undefined)
+                chatRequest.presence_penalty = presence_penalty;
+            if (frequency_penalty !== undefined)
+                chatRequest.frequency_penalty = frequency_penalty;
+            if (search_domain !== undefined)
+                chatRequest.search_domain = search_domain;
+            if (return_citations !== undefined)
+                chatRequest.return_citations = return_citations;
+            if (return_images !== undefined)
+                chatRequest.return_images = return_images;
+            if (return_related_questions !== undefined)
+                chatRequest.return_related_questions = return_related_questions;
+            const response = await fetch(`https://api.perplexity.ai/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify(chatRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error: `Perplexity API error: ${response.status} - ${errorText}`,
+                };
+            }
+            const result = (await response.json());
+            return {
+                success: true,
+                response: result.choices[0]?.message?.content || '',
+                model: result.model,
+                usage: result.usage,
+                finish_reason: result.choices[0]?.finish_reason,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to complete chat: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * Generate text with Perplexity (alias for completion)
+     */
+    async _tool_generate(request) {
+        try {
+            const params = request.params;
+            const { model = this.defaultModel, prompt, system, max_tokens, temperature, top_p, top_k, presence_penalty, frequency_penalty, search_domain, return_citations, return_images, return_related_questions, apiKey, } = params;
+            if (!prompt) {
+                return {
+                    success: false,
+                    error: 'Prompt is required',
+                };
+            }
+            if (!apiKey) {
+                return {
+                    success: false,
+                    error: 'Perplexity API key is required',
+                };
+            }
+            // Convert prompt to messages format
+            const messages = [];
+            if (system) {
+                messages.push({ role: 'system', content: system });
+            }
+            messages.push({ role: 'user', content: prompt });
+            const chatRequest = {
+                model: model,
+                messages,
+                stream: false,
+            };
+            // Add optional parameters if provided
+            if (max_tokens !== undefined)
+                chatRequest.max_tokens = max_tokens;
+            if (temperature !== undefined)
+                chatRequest.temperature = temperature;
+            if (top_p !== undefined)
+                chatRequest.top_p = top_p;
+            if (top_k !== undefined)
+                chatRequest.top_k = top_k;
+            if (presence_penalty !== undefined)
+                chatRequest.presence_penalty = presence_penalty;
+            if (frequency_penalty !== undefined)
+                chatRequest.frequency_penalty = frequency_penalty;
+            if (search_domain !== undefined)
+                chatRequest.search_domain = search_domain;
+            if (return_citations !== undefined)
+                chatRequest.return_citations = return_citations;
+            if (return_images !== undefined)
+                chatRequest.return_images = return_images;
+            if (return_related_questions !== undefined)
+                chatRequest.return_related_questions = return_related_questions;
+            const response = await fetch(`https://api.perplexity.ai/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify(chatRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error: `Perplexity API error: ${response.status} - ${errorText}`,
+                };
+            }
+            const result = (await response.json());
+            return {
+                success: true,
+                response: result.choices[0]?.message?.content || '',
+                model: result.model,
+                usage: result.usage,
+                finish_reason: result.choices[0]?.finish_reason,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to generate text: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * List available models
+     */
+    async _tool_list_models(request) {
+        try {
+            const params = request.params;
+            const { apiKey } = params;
+            if (!apiKey) {
+                return {
+                    success: false,
+                    error: 'Perplexity API key is required',
+                };
+            }
+            const response = await fetch(`https://api.perplexity.ai/models`, {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error: `Perplexity API error: ${response.status} - ${errorText}`,
+                };
+            }
+            const result = (await response.json());
+            return {
+                success: true,
+                models: result.data,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to list models: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * Search with Perplexity
+     */
+    async _tool_search(request) {
+        try {
+            const params = request.params;
+            const { query, search_domain, include_domains, exclude_domains, use_autoprompt, type, apiKey, } = params;
+            if (!query) {
+                return {
+                    success: false,
+                    error: 'Query is required',
+                };
+            }
+            if (!apiKey) {
+                return {
+                    success: false,
+                    error: 'Perplexity API key is required',
+                };
+            }
+            const searchRequest = {
+                query: query,
+            };
+            // Add optional parameters if provided
+            if (search_domain !== undefined)
+                searchRequest.search_domain = search_domain;
+            if (include_domains !== undefined)
+                searchRequest.include_domains = include_domains;
+            if (exclude_domains !== undefined)
+                searchRequest.exclude_domains = exclude_domains;
+            if (use_autoprompt !== undefined)
+                searchRequest.use_autoprompt = use_autoprompt;
+            if (type !== undefined)
+                searchRequest.type = type;
+            const response = await fetch(`https://api.perplexity.ai/search`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify(searchRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error: `Perplexity API error: ${response.status} - ${errorText}`,
+                };
+            }
+            const result = (await response.json());
+            return {
+                success: true,
+                response: result.choices[0]?.message?.content || '',
+                model: result.model,
+                usage: result.usage,
+                finish_reason: result.choices[0]?.finish_reason,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to search: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * Check Perplexity API status
+     */
+    async _tool_status(request) {
+        try {
+            const params = request.params;
+            const { apiKey } = params;
+            if (!apiKey) {
+                return {
+                    success: false,
+                    status: 'error',
+                    error: 'Perplexity API key is required',
+                };
+            }
+            const response = await fetch(`https://api.perplexity.ai/models`, {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                },
+            });
+            return {
+                success: response.ok,
+                status: response.ok ? 'online' : 'offline',
+                status_code: response.status,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                status: 'offline',
+                error: `Connection failed: ${error.message}`,
+            };
+        }
+    }
+}

package/dist/mcp/index.d.ts

@@ -0,0 +1,3 @@
+export * from './mcp-bridge.tool.js';
+export * from './mcp.tool.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC"}

package/dist/mcp/index.js

@@ -0,0 +1,2 @@
+export * from './mcp-bridge.tool.js';
+export * from './mcp.tool.js';

package/dist/mcp/mcp-bridge.tool.d.ts

@@ -0,0 +1,12 @@
+import { oToolConfig, oVirtualTool, ToolResult } from '@olane/o-tool';
+import { oRequest } from '@olane/o-core';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { McpTool } from './mcp.tool.js';
+export declare class McpBridgeTool extends oVirtualTool {
+    constructor(config: oToolConfig);
+    _tool_add_remote_server(request: oRequest): Promise<ToolResult>;
+    _tool_add_remote_server_with_api_key(request: oRequest): Promise<ToolResult>;
+    _tool_add_local_server(request: oRequest): Promise<ToolResult>;
+    createMcpTool(mcpClient: Client, url: string, name?: string): Promise<McpTool>;
+}
+//# sourceMappingURL=mcp-bridge.tool.d.ts.map

package/dist/mcp/mcp-bridge.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-bridge.tool.d.ts","sourceRoot":"","sources":["../../src/mcp/mcp-bridge.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACtE,OAAO,EAAY,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAEnE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAIxC,qBAAa,aAAc,SAAQ,YAAY;gBACjC,MAAM,EAAE,WAAW;IASzB,uBAAuB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAiC/D,oCAAoC,CACxC,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,UAAU,CAAC;IAmDhB,sBAAsB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA+B9D,aAAa,CACjB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,OAAO,CAAC;CAsBpB"}

package/dist/mcp/mcp-bridge.tool.js

@@ -0,0 +1,126 @@
+import { oVirtualTool } from '@olane/o-tool';
+import { oAddress } from '@olane/o-core';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { McpTool } from './mcp.tool.js';
+import { MCP_BRIDGE_METHODS } from './methods/mcp-bridge.methods.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+export class McpBridgeTool extends oVirtualTool {
+    constructor(config) {
+        super({
+            ...config,
+            address: new oAddress('o://mcp'),
+            description: 'Tool to help add MCP servers to the network',
+            methods: MCP_BRIDGE_METHODS,
+        });
+    }
+    async _tool_add_remote_server(request) {
+        const params = request.params;
+        // params have already been validated
+        const { mcpServerUrl } = params;
+        try {
+            this.logger.debug('Adding MCP server: ' + mcpServerUrl);
+            const transport = new StreamableHTTPClientTransport(new URL(mcpServerUrl));
+            const mcpClient = new Client({
+                name: 'o-node:mcp:' + this.peerId.toString(),
+                version: '1.0.0',
+            });
+            await mcpClient.connect(transport);
+            await this.createMcpTool(mcpClient, mcpServerUrl);
+            return {
+                message: 'Successfully added MCP server with ' +
+                    this.childNodes.length +
+                    ' tools',
+            };
+        }
+        catch (e) {
+            throw new Error('Error when trying to add MCP server (' +
+                mcpServerUrl +
+                ') to the network: ' +
+                e?.message);
+        }
+    }
+    async _tool_add_remote_server_with_api_key(request) {
+        const params = request.params;
+        // params have already been validated
+        const { mcpServerUrl, apiKey } = params;
+        try {
+            // let apiKey = apiKeyInput as string;
+            // if (apiKey.indexOf('o://') > -1) {
+            //   const {
+            //     result: { data },
+            //   }: any = await this.use(new oAddress('o://vault'), {
+            //     method: 'get',
+            //     params: { key: apiKeyInput },
+            //   });
+            //   apiKey = data.value;
+            // }
+            this.logger.debug('Adding API keyed MCP server: ' + mcpServerUrl, apiKey);
+            const transport = new StreamableHTTPClientTransport(new URL(mcpServerUrl), {
+                requestInit: {
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                    },
+                },
+            });
+            const mcpClient = new Client({
+                name: 'o-node:mcp:' + this.peerId.toString(),
+                version: '1.0.0',
+            });
+            await mcpClient.connect(transport);
+            await this.createMcpTool(mcpClient, mcpServerUrl);
+            return {
+                _save: true,
+                message: 'Successfully added MCP server with ' +
+                    this.childNodes.length +
+                    ' tools',
+            };
+        }
+        catch (e) {
+            throw new Error('Error when trying to add MCP server (' +
+                mcpServerUrl +
+                ') to the network: ' +
+                e?.message);
+        }
+    }
+    async _tool_add_local_server(request) {
+        const params = request.params;
+        this.logger.debug('Adding local MCP server: ', params);
+        // params have already been validated
+        const { command, args, name } = params;
+        // this.logger.debug('Adding local MCP server: ' + mcpServerUrl);
+        const transport = new StdioClientTransport({
+            command: command,
+            args: args,
+        });
+        const mcpClient = new Client({
+            name: 'o-node:mcp:' + this.peerId.toString(),
+            version: '1.0.0',
+        });
+        await mcpClient.connect(transport);
+        await this.createMcpTool(mcpClient, args.join(' '), name);
+        return {
+            _save: true,
+            message: 'Successfully added local MCP server',
+        };
+    }
+    async createMcpTool(mcpClient, url, name) {
+        this.logger.debug('Creating MCP tool: ', name, url);
+        const mcpTool = new McpTool({
+            name: name || 'mcp-' + Date.now(),
+            description: 'MCP server for ' + url,
+            address: new oAddress(`o://${name || `mcp-${Date.now()}`}`),
+            mcpClient: mcpClient,
+            dependencies: [],
+            leader: this.config.leader,
+            parent: this.address,
+        });
+        this.addChildNode(mcpTool);
+        await this.startChildren();
+        await this.use(mcpTool.address, {
+            method: 'index_network',
+            params: {},
+        });
+        return mcpTool;
+    }
+}

package/dist/mcp/mcp.tool.d.ts

@@ -0,0 +1,14 @@
+import { oToolConfig, oVirtualTool } from '@olane/o-tool';
+import { oAddress } from '@olane/o-core';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+export declare class McpTool extends oVirtualTool {
+    private mcpClient;
+    constructor(config: oToolConfig & {
+        address: oAddress;
+        mcpClient: Client;
+    });
+    setupTools(mcpClient: Client): Promise<void>;
+    index(): Promise<any>;
+    whoami(): Promise<any>;
+}
+//# sourceMappingURL=mcp.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.tool.d.ts","sourceRoot":"","sources":["../../src/mcp/mcp.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAAY,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAGnE,qBAAa,OAAQ,SAAQ,YAAY;IACvC,OAAO,CAAC,SAAS,CAAS;gBAEd,MAAM,EAAE,WAAW,GAAG;QAAE,OAAO,EAAE,QAAQ,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;IAepE,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA2B5C,KAAK;IA2BL,MAAM,IAAI,OAAO,CAAC,GAAG,CAAC;CAe7B"}

package/dist/mcp/mcp.tool.js

@@ -0,0 +1,83 @@
+import { oVirtualTool } from '@olane/o-tool';
+import { oAddress } from '@olane/o-core';
+import { v4 as uuidv4 } from 'uuid';
+export class McpTool extends oVirtualTool {
+    constructor(config) {
+        super({
+            ...config,
+            address: config.address,
+            description: config.description ||
+                'Tool for wrapping MCP servers to be used as tools in the network',
+        });
+        this.mcpClient = config.mcpClient;
+        this.setupTools(this.mcpClient).catch((err) => {
+            this.logger.error('Error setting up MCP tools: ', err);
+        });
+    }
+    // _tool_ functions are dynamically added to the tool based on the MCP server's methods
+    async setupTools(mcpClient) {
+        this.logger.debug('Setting up MCP tools');
+        const tools = await mcpClient.listTools();
+        this.logger.debug('MCP tools: ', tools);
+        tools.tools.forEach((tool) => {
+            this.logger.debug('Setting up MCP server tool: ' + tool.name);
+            this.methods[tool.name] = {
+                name: tool.name,
+                description: tool.description || '',
+                parameters: tool.inputSchema,
+                dependencies: [],
+            };
+            // @ts-ignore
+            this[`_tool_${tool.name}`] = async (request) => {
+                this.logger.debug('Calling MCP tool: ' + tool.name, request);
+                const params = request.params;
+                const result = await this.mcpClient.callTool({
+                    name: tool.name,
+                    arguments: params,
+                });
+                return result.content;
+            };
+        });
+        await this.startChildren();
+    }
+    // let's customize the index functionality to ensure we capture MCP insights
+    async index() {
+        const result = await super.index();
+        // add each mcp tool to the vector store
+        const tools = await this.mcpClient.listTools();
+        await Promise.all(tools.tools.map((tool) => {
+            return this.use(new oAddress('o://vector-store'), {
+                method: 'add_documents',
+                params: {
+                    documents: [
+                        {
+                            pageContent: tool.description,
+                            metadata: {
+                                address: this.address?.toString() + '/' + tool.name,
+                                id: uuidv4(),
+                            },
+                        },
+                    ],
+                },
+            });
+        })).catch((err) => {
+            this.logger.error('Error adding MCP tools to vector store: ', err);
+        });
+        return result;
+    }
+    async whoami() {
+        // do nothing
+        const tools = await this.mcpClient.listTools();
+        console.log('mcp+tools: ', tools);
+        return {
+            tools: tools.tools.map((tool) => {
+                return {
+                    name: tool.name,
+                    description: tool.description,
+                    title: tool.title,
+                    inputSchema: tool.inputSchema,
+                };
+            }),
+        };
+    }
+}

package/dist/mcp/methods/mcp-bridge.methods.d.ts

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

package/dist/mcp/methods/mcp-bridge.methods.d.ts.map

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

package/dist/mcp/methods/mcp-bridge.methods.js

@@ -0,0 +1,79 @@
+export const MCP_BRIDGE_METHODS = {
+    add_remote_server_with_api_key: {
+        name: 'add_remote_server_with_api_key',
+        description: 'Add a MCP server that requires an API key to the bridge',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'mcpServerUrl',
+                type: 'string',
+                value: 'string',
+                description: 'The URL of the MCP server to use',
+                required: true,
+            },
+            {
+                name: 'apiKey',
+                type: 'string',
+                value: 'string',
+                description: 'The API key to use for the MCP server',
+                required: true,
+            },
+        ],
+    },
+    add_remote_server_with_oauth: {
+        name: 'add_remote_server_with_oauth',
+        description: 'Add a MCP server that requires an OAuth authentication token to the bridge',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'mcpServerUrl',
+                type: 'string',
+                value: 'string',
+                description: 'The URL of the MCP server to use',
+                required: true,
+            },
+        ],
+    },
+    add_remote_server: {
+        name: 'add_remote_server',
+        description: 'Add a MCP server that does not require authentication to the bridge',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'mcpServerUrl',
+                type: 'string',
+                value: 'string',
+                description: 'The URL of the MCP server to use',
+                required: true,
+            },
+        ],
+    },
+    add_local_server: {
+        name: 'add_local_server',
+        description: 'Add a local MCP server to the bridge using command and arguments',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'command',
+                type: 'string',
+                value: 'string',
+                description: 'The command to execute for the local MCP server',
+                required: true,
+            },
+            {
+                name: 'args',
+                type: 'array',
+                value: 'string[]',
+                description: 'The arguments to pass to the command',
+                required: true,
+            },
+            {
+                name: 'name',
+                type: 'string',
+                value: 'string',
+                description: 'The name for the MCP server',
+                required: true,
+            },
+        ],
+    },
+};

package/dist/nlp/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ner.tool.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/nlp/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/dist/nlp/index.js

@@ -0,0 +1 @@
+export * from './ner.tool.js';

package/dist/nlp/methods/nlp.methods.d.ts

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

package/dist/nlp/methods/nlp.methods.d.ts.map

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