@alpic80/rivet-core 1.24.0-aidon.5 → 1.24.2-aidon.10

package/dist/esm/model/nodes/MCPDiscoveryNode.js

@@ -0,0 +1,239 @@
+import { nanoid } from 'nanoid';
+import { NodeImpl } from '../NodeImpl.js';
+import {} from '../../index.js';
+import { MCPError, MCPErrorType } from '../../integrations/mcp/MCPProvider.js';
+import { coerceType, dedent, getInputOrData } from '../../utils/index.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { getServerHelperMessage, getServerOptions, loadMCPConfiguration } from '../../integrations/mcp/MCPUtils.js';
+import { getMCPBaseInputs } from '../../integrations/mcp/MCPBase.js';
+class MCPDiscoveryNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'mcpDiscovery',
+            title: 'MCP Discovery',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                name: 'mcp-client',
+                version: '1.0.0',
+                transportType: 'stdio',
+                serverUrl: 'http://localhost:8080/mcp',
+                headers: '',
+                serverId: '',
+                useNameInput: false,
+                useVersionInput: false,
+                useToolsOutput: true,
+                usePromptsOutput: true,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = getMCPBaseInputs(this.data);
+        return inputs;
+    }
+    getOutputDefinitions() {
+        const outputDefinitions = [];
+        if (this.data.useToolsOutput) {
+            outputDefinitions.push({
+                id: 'tools',
+                title: 'Tools',
+                dataType: 'object[]',
+                description: 'Tools returned from the MCP server',
+            });
+        }
+        if (this.data.usePromptsOutput) {
+            outputDefinitions.push({
+                id: 'prompts',
+                title: 'Prompts',
+                dataType: 'object[]',
+                description: 'Prompts returned from the MCP server',
+            });
+        }
+        return outputDefinitions;
+    }
+    async getEditors(context) {
+        const editors = [
+            {
+                type: 'toggle',
+                label: 'Output Tools',
+                dataKey: 'useToolsOutput',
+                helperMessage: 'Toggle on if you want to get a Tools output',
+            },
+            {
+                type: 'toggle',
+                label: 'Output Prompts',
+                dataKey: 'usePromptsOutput',
+                helperMessage: 'Toggle on if you want to get a Prompts output',
+            },
+            {
+                type: 'string',
+                label: 'Name',
+                dataKey: 'name',
+                useInputToggleDataKey: 'useNameInput',
+                helperMessage: 'The name for the MCP Client',
+            },
+            {
+                type: 'string',
+                label: 'Version',
+                dataKey: 'version',
+                useInputToggleDataKey: 'useVersionInput',
+                helperMessage: 'A version for the MCP Client',
+            },
+            {
+                type: 'dropdown',
+                label: 'Transport Type',
+                dataKey: 'transportType',
+                options: [
+                    { label: 'HTTP', value: 'http' },
+                    { label: 'STDIO', value: 'stdio' },
+                ],
+            },
+        ];
+        if (this.data.transportType === 'http') {
+            editors.push({
+                type: 'string',
+                label: 'Server URL',
+                dataKey: 'serverUrl',
+                useInputToggleDataKey: 'useServerUrlInput',
+                helperMessage: 'The base URL endpoint for the MCP server with `/mcp`',
+            }, {
+                type: 'code',
+                label: 'Headers',
+                dataKey: 'headers',
+                useInputToggleDataKey: 'useHeadersInput',
+                language: 'json',
+            });
+        }
+        else if (this.data.transportType === 'stdio') {
+            const serverOptions = await getServerOptions(context);
+            editors.push({
+                type: 'dropdown',
+                label: 'Server ID',
+                dataKey: 'serverId',
+                helperMessage: getServerHelperMessage(context, serverOptions.length),
+                options: serverOptions,
+            });
+        }
+        return editors;
+    }
+    getBody(context) {
+        let base;
+        let headers = '';
+        if (this.data.transportType === 'http') {
+            base = this.data.useServerUrlInput ? '(Using Server URL Input)' : this.data.serverUrl;
+            headers = this.data.useHeadersInput
+                ? '\nHeaders: (Using Input)'
+                : this.data.headers?.trim()
+                    ? `\nHeaders: ${this.data.headers}`
+                    : '';
+        }
+        else {
+            base = `Server ID: ${this.data.serverId || '(None)'}`;
+        }
+        const namePart = `Name: ${this.data.name}`;
+        const versionPart = `Version: ${this.data.version}`;
+        const parts = [namePart, versionPart, base, headers];
+        if (context.executor !== 'nodejs') {
+            parts.push('(Requires Node Executor)');
+        }
+        return parts.join('\n');
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Connects to an MCP (Model Context Protocol) server to discover capabilities like tools and prompts.
+      `,
+            infoBoxTitle: 'MCP Discovery Node',
+            contextMenuTitle: 'MCP Discovery',
+            group: ['MCP'],
+        };
+    }
+    async process(inputs, context) {
+        const name = getInputOrData(this.data, inputs, 'name', 'string');
+        const version = getInputOrData(this.data, inputs, 'version', 'string');
+        const transportType = getInputOrData(this.data, inputs, 'transportType', 'string');
+        let tools = [];
+        let prompts = [];
+        try {
+            if (!context.mcpProvider) {
+                throw new Error('MCP Provider not found');
+            }
+            if (transportType === 'http') {
+                const serverUrl = getInputOrData(this.data, inputs, 'serverUrl', 'string');
+                if (!serverUrl || serverUrl === '') {
+                    throw new MCPError(MCPErrorType.SERVER_NOT_FOUND, 'No server URL was provided');
+                }
+                if (!serverUrl.includes('/mcp')) {
+                    throw new MCPError(MCPErrorType.SERVER_COMMUNICATION_FAILED, 'Include /mcp in your server URL. For example: http://localhost:8080/mcp');
+                }
+                let headers;
+                if (this.data.useHeadersInput) {
+                    const headersInput = inputs['headers'];
+                    if (headersInput?.type === 'string') {
+                        headers = JSON.parse(headersInput.value);
+                    }
+                    else if (headersInput?.type === 'object') {
+                        headers = headersInput.value;
+                    }
+                    else {
+                        headers = coerceType(headersInput, 'object');
+                    }
+                }
+                else if (this.data.headers?.trim()) {
+                    headers = JSON.parse(this.data.headers);
+                }
+                tools = await context.mcpProvider.getHTTPTools({ name, version }, serverUrl, headers);
+                prompts = await context.mcpProvider.getHTTPrompts({ name, version }, serverUrl, headers);
+            }
+            else if (transportType === 'stdio') {
+                const serverId = this.data.serverId ?? '';
+                const mcpConfig = await loadMCPConfiguration(context);
+                if (!mcpConfig.mcpServers[serverId]) {
+                    throw new MCPError(MCPErrorType.SERVER_NOT_FOUND, `Server ${serverId} not found in MCP config`);
+                }
+                const serverConfig = {
+                    config: mcpConfig.mcpServers[serverId],
+                    serverId,
+                };
+                tools = await context.mcpProvider.getStdioTools({ name, version }, serverConfig);
+                prompts = await context.mcpProvider.getStdioPrompts({ name, version }, serverConfig);
+            }
+            const output = {};
+            const gptFunctions = tools.map((tool) => ({
+                name: tool.name,
+                description: tool.description ?? '',
+                parameters: tool.inputSchema,
+                strict: false,
+            }));
+            if (this.data.useToolsOutput) {
+                output['tools'] = {
+                    type: 'gpt-function[]',
+                    value: gptFunctions,
+                };
+            }
+            if (this.data.usePromptsOutput) {
+                output['prompts'] = {
+                    type: 'object[]',
+                    value: prompts.map((prompt) => ({
+                        name: prompt.name,
+                        description: prompt.description,
+                        arguments: prompt.arugments,
+                    })),
+                };
+            }
+            return output;
+        }
+        catch (err) {
+            if (context.executor === 'browser') {
+                throw new Error('Failed to create Client without Node Executor');
+            }
+            throw err;
+        }
+    }
+}
+export const mcpDiscoveryNode = nodeDefinition(MCPDiscoveryNodeImpl, 'MCP Discovery');

package/dist/esm/model/nodes/MCPGetPromptNode.js

@@ -0,0 +1,262 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../GraphProcessor.js';
+import { coerceType } from '../../index.js';
+import { MCPError, MCPErrorType } from '../../integrations/mcp/MCPProvider.js';
+import { coerceTypeOptional } from '../../utils/coerceType.js';
+import { dedent, getInputOrData } from '../../utils/index.js';
+import { getError } from '../../utils/errors.js';
+import { getMCPBaseInputs } from '../../integrations/mcp/MCPBase.js';
+import { getServerHelperMessage, getServerOptions, loadMCPConfiguration } from '../../integrations/mcp/MCPUtils.js';
+import { keys } from '../../utils/typeSafety.js';
+import { interpolate } from '../../utils/interpolation.js';
+export class MCPGetPromptNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'mcpGetPrompt',
+            title: 'MCP Get Prompt',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                name: 'mcp-get-prompt-client',
+                version: '1.0.0',
+                transportType: 'stdio',
+                serverUrl: 'http://localhost:8080/mcp',
+                headers: '',
+                serverId: '',
+                promptName: '',
+                promptArguments: dedent `
+        {
+          "key": "value"
+        }`,
+                useNameInput: false,
+                useVersionInput: false,
+                usePromptNameInput: false,
+                usePromptArgumentsInput: false,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = getMCPBaseInputs(this.data);
+        if (this.data.usePromptNameInput) {
+            inputs.push({
+                dataType: 'string',
+                id: 'promptName',
+                title: 'Prompt Name',
+            });
+        }
+        if (this.data.usePromptArgumentsInput) {
+            inputs.push({
+                dataType: 'object',
+                id: 'promptArguments',
+                title: 'Prompt Arguments',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        const outputDefinitions = [];
+        outputDefinitions.push({
+            id: 'prompt',
+            title: 'Prompt',
+            dataType: 'object',
+            description: 'Prompt response result',
+        });
+        return outputDefinitions;
+    }
+    async getEditors(context) {
+        const editors = [
+            {
+                type: 'string',
+                label: 'Name',
+                dataKey: 'name',
+                useInputToggleDataKey: 'useNameInput',
+                helperMessage: 'The name for the MCP Client',
+            },
+            {
+                type: 'string',
+                label: 'Version',
+                dataKey: 'version',
+                useInputToggleDataKey: 'useVersionInput',
+                helperMessage: 'A version for the MCP Client',
+            },
+            {
+                type: 'dropdown',
+                label: 'Transport Type',
+                dataKey: 'transportType',
+                options: [
+                    { label: 'HTTP', value: 'http' },
+                    { label: 'STDIO', value: 'stdio' },
+                ],
+            },
+            {
+                type: 'string',
+                label: 'Prompt Name',
+                dataKey: 'promptName',
+                useInputToggleDataKey: 'usePromptNameInput',
+                helperMessage: 'The name for the MCP prompt',
+            },
+            {
+                type: 'code',
+                label: 'Prompt Arguments',
+                dataKey: 'promptArguments',
+                useInputToggleDataKey: 'usePromptArgumentsInput',
+                language: 'json',
+                helperMessage: 'Arguments to provide the prompt',
+            },
+        ];
+        if (this.data.transportType === 'http') {
+            editors.push({
+                type: 'string',
+                label: 'Server URL',
+                dataKey: 'serverUrl',
+                useInputToggleDataKey: 'useServerUrlInput',
+                helperMessage: 'The base URL endpoint for the MCP server with `/mcp`',
+            }, {
+                type: 'code',
+                label: 'Headers',
+                dataKey: 'headers',
+                useInputToggleDataKey: 'useHeadersInput',
+                language: 'json',
+            });
+        }
+        else if (this.data.transportType === 'stdio') {
+            const serverOptions = await getServerOptions(context);
+            editors.push({
+                type: 'dropdown',
+                label: 'Server ID',
+                dataKey: 'serverId',
+                helperMessage: getServerHelperMessage(context, serverOptions.length),
+                options: serverOptions,
+            });
+        }
+        return editors;
+    }
+    getBody(context) {
+        let base;
+        let headers = '';
+        if (this.data.transportType === 'http') {
+            base = this.data.useServerUrlInput ? '(Using Server URL Input)' : this.data.serverUrl;
+            headers = this.data.useHeadersInput
+                ? '\nHeaders: (Using Input)'
+                : this.data.headers?.trim()
+                    ? `\nHeaders: ${this.data.headers}`
+                    : '';
+        }
+        else {
+            base = `Server ID: ${this.data.serverId || '(None)'}`;
+        }
+        const namePart = `Name: ${this.data.name}`;
+        const versionPart = `Version: ${this.data.version}`;
+        const parts = [namePart, versionPart, base, headers];
+        if (context.executor !== 'nodejs') {
+            parts.push('(Requires Node Executor)');
+        }
+        return parts.join('\n');
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Connects to an MCP (Model Context Protocol) server and gets a prompt response.
+      `,
+            infoBoxTitle: 'MCP Get Prompt Node',
+            contextMenuTitle: 'MCP Get Prompt',
+            group: ['MCP'],
+        };
+    }
+    async process(inputs, context) {
+        const name = getInputOrData(this.data, inputs, 'name', 'string');
+        const version = getInputOrData(this.data, inputs, 'version', 'string');
+        const promptName = getInputOrData(this.data, inputs, 'promptName', 'string');
+        let promptArguments;
+        if (this.data.usePromptArgumentsInput) {
+            promptArguments = getInputOrData(this.data, inputs, 'promptArguments', 'object');
+            if (promptArguments == null) {
+                throw new MCPError(MCPErrorType.INVALID_SCHEMA, 'Cannot parse tool argument with input toggle on');
+            }
+        }
+        else {
+            const inputMap = keys(inputs)
+                .filter((key) => key.startsWith('input'))
+                .reduce((acc, key) => {
+                const stringValue = coerceTypeOptional(inputs[key], 'string') ?? '';
+                const interpolationKey = key.slice('input-'.length);
+                acc[interpolationKey] = stringValue;
+                return acc;
+            }, {});
+            const interpolated = interpolate(this.data.promptArguments ?? '', inputMap);
+            promptArguments = JSON.parse(interpolated);
+        }
+        const getPromptRequest = {
+            name: promptName,
+            arguments: promptArguments,
+        };
+        const transportType = getInputOrData(this.data, inputs, 'transportType', 'string');
+        let getPromptResponse = undefined;
+        try {
+            if (!context.mcpProvider) {
+                throw new Error('MCP Provider not found');
+            }
+            if (transportType === 'http') {
+                const serverUrl = getInputOrData(this.data, inputs, 'serverUrl', 'string');
+                if (!serverUrl || serverUrl === '') {
+                    throw new MCPError(MCPErrorType.SERVER_NOT_FOUND, 'No server URL was provided');
+                }
+                if (!serverUrl.includes('/mcp')) {
+                    throw new MCPError(MCPErrorType.SERVER_COMMUNICATION_FAILED, 'Include /mcp in your server URL. For example: http://localhost:8080/mcp');
+                }
+                let headers;
+                if (this.data.useHeadersInput) {
+                    const headersInput = inputs['headers'];
+                    if (headersInput?.type === 'string') {
+                        headers = JSON.parse(headersInput.value);
+                    }
+                    else if (headersInput?.type === 'object') {
+                        headers = headersInput.value;
+                    }
+                    else {
+                        headers = coerceType(headersInput, 'object');
+                    }
+                }
+                else if (this.data.headers?.trim()) {
+                    headers = JSON.parse(this.data.headers);
+                }
+                getPromptResponse = await context.mcpProvider.getHTTPrompt({ name, version }, serverUrl, headers, getPromptRequest);
+            }
+            else if (transportType === 'stdio') {
+                const serverId = this.data.serverId ?? '';
+                const mcpConfig = await loadMCPConfiguration(context);
+                if (!mcpConfig.mcpServers[serverId]) {
+                    throw new MCPError(MCPErrorType.SERVER_NOT_FOUND, `Server ${serverId} not found in MCP config`);
+                }
+                const serverConfig = {
+                    config: mcpConfig.mcpServers[serverId],
+                    serverId,
+                };
+                getPromptResponse = await context.mcpProvider.getStdioPrompt({ name, version }, serverConfig, getPromptRequest);
+            }
+            const output = {};
+            output['response'] = {
+                type: 'object',
+                value: getPromptResponse,
+            };
+            return output;
+        }
+        catch (err) {
+            const { message } = getError(err);
+            if (context.executor === 'browser') {
+                throw new Error('Failed to create Client without a node executor');
+            }
+            console.log(message);
+            throw err;
+        }
+    }
+}
+export const mcpGetPromptNode = nodeDefinition(MCPGetPromptNodeImpl, 'MCP Get Prompt');