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

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

@@ -0,0 +1,233 @@
+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 {} 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',
+                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 endpoint URL for the MCP server to connect',
+            });
+        }
+        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;
+        if (this.data.transportType === 'http') {
+            base = this.data.useServerUrlInput ? '(Using Server URL Input)' : this.data.serverUrl;
+        }
+        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];
+        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');
+                }
+                getPromptResponse = await context.mcpProvider.getHTTPrompt({ name, version }, serverUrl, 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');

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

@@ -0,0 +1,261 @@
+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 {} from '../../index.js';
+import { MCPError, MCPErrorType } from '../../integrations/mcp/MCPProvider.js';
+import { coerceTypeOptional } from '../../utils/coerceType.js';
+import { 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 { dedent } from 'ts-dedent';
+import {} from '../EditorDefinition.js';
+import { interpolate } from '../../utils/interpolation.js';
+import { keys } from '../../utils/typeSafety.js';
+export class MCPToolCallNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'mcpToolCall',
+            title: 'MCP Tool Call',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                name: 'mcp-tool-call-client',
+                version: '1.0.0',
+                transportType: 'stdio',
+                serverUrl: 'http://localhost:8080/mcp',
+                serverId: '',
+                toolName: '',
+                toolArguments: dedent `
+        {
+          "key": "value"
+        }`,
+                toolCallId: '',
+                useNameInput: false,
+                useVersionInput: false,
+                useToolNameInput: true,
+                useToolArgumentsInput: true,
+                useToolCallIdInput: true,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = getMCPBaseInputs(this.data);
+        if (this.data.useToolNameInput) {
+            inputs.push({
+                dataType: 'string',
+                id: 'toolName',
+                title: 'Tool Name',
+            });
+        }
+        if (this.data.useToolArgumentsInput) {
+            inputs.push({
+                dataType: 'object',
+                id: 'toolArguments',
+                title: 'Tool Arguments',
+            });
+        }
+        if (this.data.useToolCallIdInput) {
+            inputs.push({
+                dataType: 'object',
+                id: 'toolCallId',
+                title: 'Tool ID',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        const outputDefinitions = [];
+        outputDefinitions.push({
+            id: 'response',
+            title: 'Response',
+            dataType: 'object',
+            description: 'Response from the Tool Call',
+        });
+        outputDefinitions.push({
+            id: 'toolCallId',
+            title: 'Tool ID',
+            dataType: 'string',
+            description: 'ID associated with the Tool Call',
+        });
+        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: 'Tool Name',
+                dataKey: 'toolName',
+                useInputToggleDataKey: 'useToolNameInput',
+                helperMessage: 'The name for the MCP Tool Call',
+            },
+            {
+                type: 'code',
+                label: 'Tool Arguments',
+                dataKey: 'toolArguments',
+                language: 'json',
+                useInputToggleDataKey: 'useToolArgumentsInput',
+            },
+            {
+                type: 'string',
+                label: 'Tool ID',
+                dataKey: 'toolCallId',
+                useInputToggleDataKey: 'useToolCallIdInput',
+                helperMessage: 'The name for the MCP Tool Call',
+            },
+        ];
+        if (this.data.transportType === 'http') {
+            editors.push({
+                type: 'string',
+                label: 'Server URL',
+                dataKey: 'serverUrl',
+                useInputToggleDataKey: 'useServerUrlInput',
+                helperMessage: 'The endpoint URL for the MCP server to connect',
+            });
+        }
+        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;
+        if (this.data.transportType === 'http') {
+            base = this.data.useServerUrlInput ? '(Using Server URL Input)' : this.data.serverUrl;
+        }
+        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];
+        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 tool call response.
+      `,
+            infoBoxTitle: 'MCP Tool Call Node',
+            contextMenuTitle: 'MCP Tool Call',
+            group: ['MCP'],
+        };
+    }
+    async process(inputs, context) {
+        const name = getInputOrData(this.data, inputs, 'name', 'string');
+        const version = getInputOrData(this.data, inputs, 'version', 'string');
+        const toolName = getInputOrData(this.data, inputs, 'toolName', 'string');
+        const toolCallId = getInputOrData(this.data, inputs, 'toolCallId', 'string');
+        let toolArguments;
+        if (this.data.useToolArgumentsInput) {
+            toolArguments = getInputOrData(this.data, inputs, 'toolArguments', 'object');
+            if (toolArguments == 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.toolArguments ?? '', inputMap);
+            toolArguments = JSON.parse(interpolated);
+        }
+        const toolCall = {
+            name: toolName,
+            arguments: toolArguments,
+        };
+        const transportType = getInputOrData(this.data, inputs, 'transportType', 'string');
+        let toolResponse = 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');
+                }
+                toolResponse = await context.mcpProvider.httpToolCall({ name, version }, serverUrl, toolCall);
+            }
+            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,
+                };
+                toolResponse = await context.mcpProvider.stdioToolCall({ name, version }, serverConfig, toolCall);
+            }
+            const output = {};
+            output['response'] = {
+                type: 'object[]',
+                value: toolResponse?.content,
+            };
+            output['toolCallId'] = {
+                type: 'string',
+                value: toolCallId,
+            };
+            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 mcpToolCallNode = nodeDefinition(MCPToolCallNodeImpl, 'MCP Tool Call');

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

@@ -5,6 +5,7 @@ import { nodeDefinition } from '../NodeDefinition.js';
 import {} from '../DataValue.js';
 import { dedent } from 'ts-dedent';
 import {} from '../EditorDefinition.js';
+import { resolveExpressionRawValue, unwrapPotentialDataValue } from '../../utils/interpolation.js';
 const DEFAULT_JSON_TEMPLATE = `{
   "key": "{{input}}"
 }`;
@@ -26,17 +27,23 @@ export class ObjectNodeImpl extends NodeImpl {
         return chartNode;
     }
     getInputDefinitions() {
-        // Extract inputs from text, everything like {{input}}
-        const inputNames = [...new Set(this.chartNode.data.jsonTemplate.match(/\{\{([^}]+)\}\}/g))];
-        return (inputNames?.map((inputName) => {
+        // Provide default empty string for jsonTemplate if undefined
+        const jsonTemplate = this.chartNode.data.jsonTemplate ?? '';
+        const matches = jsonTemplate.match(/\{\{([^}]+?)\}\}/g); // matches is string[] | null
+        const allTokens = matches ?? []; // allTokens is now explicitly string[]
+        const inputTokens = allTokens
+            // id and title should not have the {{ and }}
+            .map((token) => token.slice(2, -2).trim())
+            .filter((tokenContent) => !tokenContent.startsWith('@graphInputs.') && !tokenContent.startsWith('@context.'))
+            .filter((token) => token !== '');
+        return [...new Set(inputTokens)].map((inputName) => {
             return {
-                // id and title should not have the {{ and }}
-                id: inputName.slice(2, -2),
-                title: inputName.slice(2, -2),
+                id: inputName,
+                title: inputName,
                 dataType: 'any',
                 required: false,
             };
-        }) ?? []);
+        });
     }
     getOutputDefinitions() {
         return [
@@ -77,10 +84,22 @@ export class ObjectNodeImpl extends NodeImpl {
             group: ['Objects'],
         };
     }
-    interpolate(baseString, values) {
-        return baseString.replace(/("?)\{\{([^}]+)\}\}("?)/g, (_m, openQuote, key, _closeQuote) => {
+    interpolate(baseString, values, graphInputNodeValues, contextValues) {
+        return baseString.replace(/("?)\{\{([^}]+?)\}\}("?)/g, (_m, openQuote, key, _closeQuote) => {
             const isQuoted = Boolean(openQuote);
-            const value = values[key];
+            const trimmedKey = key.trim(); // Use trimmedKey for lookups
+            let value;
+            const graphInputPrefix = '@graphInputs.';
+            const contextPrefix = '@context.';
+            if (trimmedKey.startsWith(graphInputPrefix) && graphInputNodeValues) {
+                value = resolveExpressionRawValue(graphInputNodeValues, trimmedKey.substring(graphInputPrefix.length), 'graphInputs');
+            }
+            else if (trimmedKey.startsWith(contextPrefix) && contextValues) {
+                value = resolveExpressionRawValue(contextValues, trimmedKey.substring(contextPrefix.length), 'context');
+            }
+            else {
+                value = values[trimmedKey]; // Original logic for non-@ variables
+            }
             if (value == null) {
                 return 'null';
             }
@@ -96,23 +115,25 @@ export class ObjectNodeImpl extends NodeImpl {
             return JSON.stringify(value);
         });
     }
-    async process(inputs) {
+    async process(inputs, context) {
         const inputMap = Object.keys(inputs).reduce((acc, key) => {
-            acc[key] = inputs[key]?.value;
+            acc[key] = unwrapPotentialDataValue(inputs[key]);
             return acc;
         }, {});
-        const outputValue = JSON.parse(this.interpolate(this.chartNode.data.jsonTemplate, inputMap));
-        if (Array.isArray(outputValue)) {
-            return {
-                output: {
-                    type: 'object[]',
-                    value: outputValue,
-                },
-            };
+        const interpolatedString = this.interpolate(this.chartNode.data.jsonTemplate, inputMap, context.graphInputNodeValues, // Pass graph inputs
+        context.contextValues // Pass context values
+        );
+        let outputValue;
+        try {
+            outputValue = JSON.parse(interpolatedString);
+        }
+        catch (err) {
+            throw new Error(`Failed to parse JSON template: ${err.message}`);
         }
+        const outputType = Array.isArray(outputValue) ? 'object[]' : 'object';
         return {
             output: {
-                type: 'object',
+                type: outputType,
                 value: outputValue,
             },
         };

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

@@ -177,7 +177,7 @@ export class PromptNodeImpl extends NodeImpl {
     }
     async process(inputs, context) {
         const inputMap = mapValues(inputs, (input) => coerceType(input, 'string'));
-        const outputValue = interpolate(this.chartNode.data.promptText, inputMap);
+        const outputValue = interpolate(this.chartNode.data.promptText, inputMap, context.graphInputNodeValues, context.contextValues);
         const type = getInputOrData(this.data, inputs, 'type', 'string');
         const isCacheBreakpoint = getInputOrData(this.data, inputs, 'isCacheBreakpoint', 'boolean');
         if (['assistant', 'system', 'user', 'function'].includes(type) === false) {

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

@@ -20,6 +20,7 @@ export class TextNodeImpl extends NodeImpl {
             },
             data: {
                 text: '{{input}}',
+                normalizeLineEndings: true, // Default to true for better compatibility
             },
         };
         return chartNode;
@@ -61,6 +62,12 @@ export class TextNodeImpl extends NodeImpl {
                 language: 'prompt-interpolation-markdown',
                 theme: 'prompt-interpolation',
             },
+            {
+                type: 'toggle',
+                label: 'Normalize Line Endings',
+                dataKey: 'normalizeLineEndings',
+                helperMessage: 'Normalize line endings to use only LF (\\n) instead of CRLF (\\r\\n).',
+            },
         ];
     }
     getBody() {
@@ -72,13 +79,17 @@ export class TextNodeImpl extends NodeImpl {
             text: truncated,
         };
     }
-    async process(inputs) {
+    async process(inputs, context) {
         const inputMap = Object.keys(inputs).reduce((acc, key) => {
             const stringValue = coerceTypeOptional(inputs[key], 'string') ?? '';
             acc[key] = stringValue;
             return acc;
         }, {});
-        const outputValue = interpolate(this.chartNode.data.text, inputMap);
+        let outputValue = interpolate(this.chartNode.data.text, inputMap, context.graphInputNodeValues, // Pass graph inputs
+        context.contextValues);
+        if (this.chartNode.data.normalizeLineEndings) {
+            outputValue = outputValue.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        }
         return {
             output: {
                 type: 'string',