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

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,22 @@ spec) {
     }
     return new ReadableStream({
         async start(controller) {
+            const userEventHandler = async (eventName, data) => {
+                const graphEvent = {
+                    type: 'event',
+                    graphEvent: {
+                        name: eventName,
+                        message: coerceType(data, 'string')
+                    }
+                };
+                sendEvent(controller, 'event', graphEvent);
+            };
+            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 +165,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,100 @@
+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',
+        });
+    }
+    if (data.transportType === 'http' && data.useHeadersInput) {
+        inputs.push({
+            dataType: 'object',
+            id: 'headers',
+            title: 'Headers',
+        });
+    }
+    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',
+        }, {
+            type: 'code',
+            label: 'Headers',
+            dataKey: 'headers',
+            useInputToggleDataKey: 'useHeadersInput',
+            language: 'json',
+        });
+    }
+    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

@@ -13,7 +13,6 @@ import { coerceTypeOptional } from '../utils/coerceType.js';
 import { globalRivetNodeRegistry } from './Nodes.js';
 import { getPluginConfig } from '../utils/index.js';
 import { GptTokenizerTokenizer } from '../integrations/GptTokenizerTokenizer.js';
-// eslint-disable-next-line import/no-cycle -- There has to be a cycle because CodeRunner needs to import the entirety of Rivet
 import { IsomorphicCodeRunner } from '../integrations/CodeRunner.js';
 // CJS compatibility, gets default.default for whatever reason
 let PQueue = PQueueImport;
@@ -79,6 +78,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 +499,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(
@@ -512,6 +513,7 @@ export class GraphProcessor {
             if (this.#running) {
                 throw new Error('Cannot process graph while already processing');
             }
+            console.info(`Process graph called. Context:${context}, Inputs: ${JSON.stringify(inputs)}, Context Values: ${JSON.stringify(contextValues)}`);
             this.#initProcessState();
             this.#context = context;
             this.#graphInputs = inputs;
@@ -522,8 +524,11 @@ export class GraphProcessor {
                     this.#emitter.emit('error', { error });
                 });
             }
+            console.info(`Process graph calling loadProjectReferences`);
             await this.#loadProjectReferences();
+            console.info(`Process graph called loadProjectReferences`);
             this.#preprocessGraph();
+            console.info(`Process graph called preprocessGraph`);
             if (!this.#isSubProcessor) {
                 await this.#emitter.emit('start', {
                     contextValues: this.#contextValues,
@@ -1227,6 +1232,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/HttpCallNode.js

@@ -141,7 +141,7 @@ export class HttpCallNodeImpl extends NodeImpl {
         return dedent `
       ${this.data.useMethodInput ? '(Method Using Input)' : this.data.method} ${this.data.useUrlInput ? '(URL Using Input)' : this.data.url} ${this.data.useHeadersInput
             ? '\nHeaders: (Using Input)'
-            : this.data.headers.trim()
+            : this.data.headers?.trim()
                 ? `\nHeaders: ${this.data.headers}`
                 : ''}${this.data.useBodyInput ? '\nBody: (Using Input)' : this.data.body.trim() ? `\nBody: ${this.data.body}` : ''}${this.data.errorOnNon200 ? '\nError on non-200' : ''}
     `;
@@ -179,7 +179,7 @@ export class HttpCallNodeImpl extends NodeImpl {
                 headers = coerceType(headersInput, 'object');
             }
         }
-        else if (this.data.headers.trim()) {
+        else if (this.data.headers?.trim()) {
             headers = JSON.parse(this.data.headers);
         }
         let body;