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

package/dist/esm/api/createProcessor.js

@@ -1,5 +1,6 @@
 import {} from '../index.js';
 import { getProcessorEvents, getProcessorSSEStream, getSingleNodeStream } from './streaming.js';
+// eslint-disable-next-line import/no-cycle -- Necessary cycle
 import { GraphProcessor } from '../model/GraphProcessor.js';
 import { deserializeProject } from '../utils/serialization/serialization.js';
 import { DEFAULT_CHAT_NODE_TIMEOUT } from '../utils/defaults.js';
@@ -89,6 +90,7 @@ export function coreCreateProcessor(project, options) {
                 nativeApi: options.nativeApi,
                 datasetProvider: options.datasetProvider,
                 audioProvider: options.audioProvider,
+                mcpProvider: options.mcpProvider,
                 codeRunner: options.codeRunner,
                 projectPath: options.projectPath,
                 projectReferenceLoader: options.projectReferenceLoader,

package/dist/esm/api/streaming.js

@@ -9,12 +9,14 @@ function nodeMatches(spec, event) {
 export async function* getProcessorEvents(processor, spec) {
     const previousIndexes = new Map();
     const usages = [];
+    let hasDelta = false;
     for await (const event of processor.events()) {
         if (event.type === 'partialOutput') {
             if (spec.partialOutputs === true ||
                 nodeMatches(spec.partialOutputs, event)) {
                 const currentOutput = coerceType(event.outputs['response'], 'string');
                 const delta = currentOutput.slice(previousIndexes.get(event.node.id) ?? 0);
+                hasDelta = true;
                 yield {
                     type: 'partialOutput',
                     nodeId: event.node.id,
@@ -76,8 +78,8 @@ export async function* getProcessorEvents(processor, spec) {
                     usages.push(usage);
                 }
             }
-            if (spec.nodeFinish === true ||
-                nodeMatches(spec.nodeFinish, event)) {
+            if ((spec.nodeFinish === true || nodeMatches(spec.nodeFinish, event)) &&
+                !(spec.removeFinalOutput && hasDelta)) {
                 yield {
                     type: 'nodeFinish',
                     outputs: event.outputs,
@@ -88,6 +90,21 @@ export async function* getProcessorEvents(processor, spec) {
         }
     }
 }
+export const createOnStreamUserEvents = (eventList, handleUserEvent) => {
+    if (!eventList?.trim()) {
+        return undefined;
+    }
+    const events = eventList.split(',').map(e => e.trim()).filter(Boolean);
+    if (!events.length) {
+        return undefined;
+    }
+    return Object.fromEntries(events.map(event => [
+        event,
+        async (data) => {
+            await handleUserEvent(event, data);
+        }
+    ]));
+};
 /**
  * Creates a ReadableStream for processor events, following the Server-Sent Events protocol.
  * https://developer.mozilla.org/en-US/docs/Web/API/EventSource
@@ -105,6 +122,18 @@ spec) {
     }
     return new ReadableStream({
         async start(controller) {
+            const userEventHandler = async (eventName, data) => {
+                sendEvent(controller, 'event', {
+                    name: eventName,
+                    message: coerceType(data, 'string')
+                });
+            };
+            const streamEvents = createOnStreamUserEvents(spec.userStreamEvents, userEventHandler);
+            if (streamEvents) {
+                for (const [name, fn] of Object.entries(streamEvents)) {
+                    processor.onUserEvent(name, fn);
+                }
+            }
             try {
                 for await (const event of getProcessorEvents(processor, spec)) {
                     sendEvent(controller, event.type, event);
@@ -132,6 +161,19 @@ export function getSingleNodeStream(processor, arg) {
     return new ReadableStream({
         async start(controller) {
             try {
+                const userEventHandler = async (eventName, data) => {
+                    const payload = {
+                        name: eventName,
+                        message: coerceType(data, 'string')
+                    };
+                    controller.enqueue(`event: ${JSON.stringify(payload)}\n\n`);
+                };
+                const streamEvents = createOnStreamUserEvents(spec.userStreamEvents, userEventHandler);
+                if (streamEvents) {
+                    for (const [name, fn] of Object.entries(streamEvents)) {
+                        processor.onUserEvent(name, fn);
+                    }
+                }
                 for await (const event of getProcessorEvents(processor, spec)) {
                     if (event.type === 'partialOutput') { //nodeIdOrTitle filter managed by spec
                         controller.enqueue(`data: ${JSON.stringify(event.delta)}\n\n`);

package/dist/esm/exports.js

@@ -14,6 +14,7 @@ export * from './model/ProcessContext.js';
 export * from './integrations/integrations.js';
 import './integrations/enableIntegrations.js';
 export * from './integrations/VectorDatabase.js';
+export * from './integrations/mcp/MCPProvider.js';
 export * from './integrations/EmbeddingGenerator.js';
 export * from './integrations/LLMProvider.js';
 export * from './recording/ExecutionRecorder.js';

package/dist/esm/integrations/CodeRunner.js

@@ -1,7 +1,7 @@
 // eslint-disable-next-line import/no-cycle -- There has to be a cycle if we're to import the entirety of Rivet here.
 import * as Rivet from '../exports.js';
 export class IsomorphicCodeRunner {
-    async runCode(code, inputs, options) {
+    async runCode(code, inputs, options, graphInputs, contextValues) {
         const argNames = ['inputs'];
         const args = [inputs];
         if (options.includeRequire) {
@@ -22,6 +22,14 @@ export class IsomorphicCodeRunner {
             argNames.push('Rivet');
             args.push(Rivet);
         }
+        if (graphInputs) {
+            argNames.push('graphInputs');
+            args.push(graphInputs);
+        }
+        if (contextValues) {
+            argNames.push('context');
+            args.push(contextValues);
+        }
         argNames.push(code);
         const AsyncFunction = async function () { }.constructor;
         const codeFunction = new AsyncFunction(...argNames);
@@ -30,7 +38,7 @@ export class IsomorphicCodeRunner {
     }
 }
 export class NotAllowedCodeRunner {
-    async runCode(_code, _inputs, _options) {
+    async runCode(_code, _inputs, _options, _graphInputs, _contextValues) {
         throw new Error('Dynamic code execution is disabled.');
     }
 }

package/dist/esm/integrations/mcp/MCPBase.js

@@ -0,0 +1,87 @@
+import { getServerHelperMessage, getServerOptions } from './MCPUtils.js';
+export const getMCPBaseInputs = (data) => {
+    const inputs = [];
+    if (data.useNameInput) {
+        inputs.push({
+            dataType: 'string',
+            id: 'name',
+            title: 'Name',
+        });
+    }
+    if (data.useVersionInput) {
+        inputs.push({
+            dataType: 'string',
+            id: 'version',
+            title: 'Version',
+        });
+    }
+    if (data.transportType === 'http' && data.useServerUrlInput) {
+        inputs.push({
+            dataType: 'string',
+            id: 'serverUrl',
+            title: 'Server URL',
+            description: 'The endpoint URL for the MCP server',
+        });
+    }
+    return inputs;
+};
+export const getMCPBaseEditors = async (context, data) => {
+    const editors = [];
+    editors.push([
+        {
+            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 (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 (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;
+};

package/dist/esm/integrations/mcp/MCPProvider.js

@@ -0,0 +1,23 @@
+/**
+ * Derived from types here - https://github.com/modelcontextprotocol/typescript-sdk/blob/main/src/types.ts
+ */
+/**
+ * Errors
+ */
+export var MCPErrorType;
+(function (MCPErrorType) {
+    MCPErrorType["CONFIG_NOT_FOUND"] = "CONFIG_NOT_FOUND";
+    MCPErrorType["SERVER_NOT_FOUND"] = "SERVER_NOT_FOUND";
+    MCPErrorType["SERVER_COMMUNICATION_FAILED"] = "SERVER_COMMUNICATION_FAILED";
+    MCPErrorType["INVALID_SCHEMA"] = "INVALID_SCHEMA";
+})(MCPErrorType || (MCPErrorType = {}));
+export class MCPError extends Error {
+    type;
+    details;
+    constructor(type, message, details) {
+        super(message);
+        this.type = type;
+        this.details = details;
+        this.name = 'Error';
+    }
+}

package/dist/esm/integrations/mcp/MCPUtils.js

@@ -0,0 +1,33 @@
+import { MCPError, MCPErrorType } from './MCPProvider.js';
+export const loadMCPConfiguration = async (context) => {
+    if (context.executor !== 'nodejs') {
+        throw new MCPError(MCPErrorType.CONFIG_NOT_FOUND, 'MCP config is not supported in browser environment');
+    }
+    const mcpConfig = context.project.metadata.mcpServer;
+    if (!mcpConfig || mcpConfig.mcpServers == null) {
+        throw new MCPError(MCPErrorType.CONFIG_NOT_FOUND, 'MCP configuration not defined in Project tab');
+    }
+    return mcpConfig;
+};
+export const getServerOptions = async (context) => {
+    if (context.executor === 'nodejs' && context.nativeApi) {
+        try {
+            const config = await loadMCPConfiguration(context);
+            return Object.entries(config.mcpServers)
+                .filter(([, config]) => !config.disabled)
+                .map(([id]) => ({
+                label: id,
+                value: id,
+            }));
+        }
+        catch { }
+    }
+    return [];
+};
+export const getServerHelperMessage = (context, optionsLength) => {
+    if (optionsLength > 0)
+        return 'Select an MCP server from local configuration located in the Project tab';
+    if (context.executor !== 'nodejs')
+        return 'MCP nodes require Node Executor';
+    return 'No MCP servers found in config';
+};

package/dist/esm/model/GraphProcessor.js

@@ -79,6 +79,7 @@ export class GraphProcessor {
     // @ts-expect-error
     #nodesNotInCycle = undefined;
     #nodeAbortControllers = new Map();
+    #graphInputNodeValues = {};
     /** User input nodes that are pending user input. */
     #pendingUserInputs = undefined;
     get isRunning() {
@@ -499,6 +500,7 @@ export class GraphProcessor {
         this.#abortSuccessfully = false;
         this.#nodeAbortControllers = new Map();
         this.#loadedProjects = {};
+        this.#graphInputNodeValues = {};
     }
     /** Main function for running a graph. Runs a graph and returns the outputs from the output nodes of the graph. */
     async processGraph(
@@ -1227,6 +1229,7 @@ export class GraphProcessor {
                 });
                 return results;
             },
+            graphInputNodeValues: this.#graphInputNodeValues,
         };
         await this.#waitUntilUnpaused();
         const results = await instance.process(inputValues, context);

package/dist/esm/model/NodeRegistration.js

@@ -101,7 +101,6 @@ export class NodeRegistration {
         if (!ImplClass) {
             throw new Error(`Unknown node type: ${type}`);
         }
-        // eslint-disable-next-line new-cap
         const impl = new ImplClass.impl(node, ImplClass.pluginImpl);
         if (!impl) {
             throw new Error(`Unknown node type: ${type}`);

package/dist/esm/model/Nodes.js

@@ -162,6 +162,12 @@ import { toTreeNode } from './nodes/ToTreeNode.js';
 export * from './nodes/ToTreeNode.js';
 import { loopUntilNode } from './nodes/LoopUntilNode.js';
 export * from './nodes/LoopUntilNode.js';
+import { mcpDiscoveryNode } from './nodes/MCPDiscoveryNode.js';
+export * from './nodes/MCPDiscoveryNode.js';
+import { mcpToolCallNode } from './nodes/MCPToolCallNode.js';
+export * from './nodes/MCPToolCallNode.js';
+import { mcpGetPromptNode } from './nodes/MCPGetPromptNode.js';
+export * from './nodes/MCPGetPromptNode.js';
 import { referencedGraphAliasNode } from './nodes/ReferencedGraphAliasNode.js';
 export * from './nodes/ReferencedGraphAliasNode.js';
 export const registerBuiltInNodes = (registry) => {
@@ -247,6 +253,9 @@ export const registerBuiltInNodes = (registry) => {
         .register(cronNode)
         .register(toTreeNode)
         .register(loopUntilNode)
+        .register(mcpDiscoveryNode)
+        .register(mcpToolCallNode)
+        .register(mcpGetPromptNode)
         .register(referencedGraphAliasNode);
 };
 let globalRivetNodeRegistry = registerBuiltInNodes(new NodeRegistration());

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

@@ -755,7 +755,7 @@ export const ChatNodeBase = {
             type: 'function',
         }));
         const { messages } = getChatNodeMessages(inputs);
-        const isReasoningModel = finalModel.startsWith('o1') || finalModel.startsWith('o3');
+        const isReasoningModel = finalModel.startsWith('o1') || finalModel.startsWith('o3') || finalModel.startsWith('o4');
         const completionMessages = await Promise.all(messages.map((message) => chatMessageToOpenAIChatCompletionMessage(message, { isReasoningModel })));
         let { maxTokens } = data;
         const openaiModel = {

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

@@ -155,7 +155,7 @@ export class CodeNodeImpl extends NodeImpl {
             includeRivet: this.data.allowRivet ?? false,
             includeProcess: this.data.allowProcess ?? false,
             includeConsole: this.data.allowConsole ?? false,
-        });
+        }, context.graphInputNodeValues, context.contextValues);
         if (outputs == null || typeof outputs !== 'object' || ('then' in outputs && typeof outputs.then === 'function')) {
             throw new Error('Code node must return an object with output values.');
         }

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

@@ -36,7 +36,7 @@ export class GetAllDatasetsNodeImpl extends NodeImpl {
     getEditors() {
         return [];
     }
-    async process(context) {
+    async process(_inputs, context) {
         const { datasetProvider } = context;
         if (datasetProvider == null) {
             throw new Error('datasetProvider is required');

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

@@ -124,6 +124,8 @@ export class GraphInputNodeImpl extends NodeImpl {
             type: this.data.dataType,
             value: inputValue,
         };
+        // Store the resolved value in the context for access by other nodes
+        context.graphInputNodeValues[this.data.id] = value;
         return { ['data']: value };
     }
 }

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

@@ -0,0 +1,210 @@
+import { nanoid } from 'nanoid';
+import { NodeImpl } from '../NodeImpl.js';
+import {} from '../../index.js';
+import { MCPError, MCPErrorType } from '../../integrations/mcp/MCPProvider.js';
+import { 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',
+                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`',
+            });
+        }
+        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 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');
+                }
+                tools = await context.mcpProvider.getHTTPTools({ name, version }, serverUrl);
+                prompts = await context.mcpProvider.getHTTPrompts({ name, version }, serverUrl);
+            }
+            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');