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

package/dist/esm/plugins/google/google.js

@@ -1,4 +1,4 @@
-import {} from '@google/generative-ai';
+import {} from '@google/genai';
 export const googleModelsDeprecated = {
     'gemini-pro': {
         maxTokens: 32760,
@@ -18,12 +18,20 @@ export const googleModelsDeprecated = {
     },
 };
 export const generativeAiGoogleModels = {
-    'gemini-2.0-flash-001': {
+    'gemini-2.5-flash-preview-04-17': {
         maxTokens: 1048576,
         cost: {
             prompt: 0.15 / 1000,
             completion: 0.6 / 1000,
         },
+        displayName: 'Gemini 2.5 Flash Preview',
+    },
+    'gemini-2.0-flash-001': {
+        maxTokens: 1048576,
+        cost: {
+            prompt: 0.1 / 1000,
+            completion: 0.4 / 1000,
+        },
         displayName: 'Gemini 2.0 Flash',
     },
     'gemini-2.0-pro-exp-02-05': {
@@ -99,31 +107,38 @@ export const generativeAiOptions = Object.entries(generativeAiGoogleModels).map(
     value: id,
     label: displayName,
 }));
-export async function* streamGenerativeAi({ apiKey, model, systemPrompt, prompt, maxOutputTokens, temperature, topP, topK, signal, tools, }) {
-    const { GoogleGenerativeAI } = await import('@google/generative-ai');
-    const genAi = new GoogleGenerativeAI(apiKey);
-    const genaiModel = genAi.getGenerativeModel({
+export async function* streamGenerativeAi({ apiKey, model, systemPrompt, prompt, maxOutputTokens, temperature, topP, topK, signal, tools, thinkingBudget, additionalHeaders, }) {
+    const { GoogleGenAI } = await import('@google/genai');
+    const genAi = new GoogleGenAI({ apiKey });
+    const result = await genAi.models.generateContentStream({
         model,
-        systemInstruction: systemPrompt,
-        generationConfig: {
+        contents: prompt,
+        config: {
+            systemInstruction: systemPrompt,
             maxOutputTokens,
             temperature,
             topP,
             topK,
+            tools,
+            abortSignal: signal,
+            thinkingConfig: {
+                thinkingBudget,
+            },
+            httpOptions: {
+                headers: {
+                    ...additionalHeaders,
+                },
+            },
         },
-        tools,
     });
-    const result = await genaiModel.generateContentStream({
-        contents: prompt,
-    }, { signal });
-    for await (const chunk of result.stream) {
+    for await (const chunk of result) {
         const outChunk = {
             completion: undefined,
             finish_reason: undefined,
             function_calls: undefined,
             model,
         };
-        const functionCalls = chunk.functionCalls();
+        const functionCalls = chunk.functionCalls;
         if (functionCalls) {
             outChunk.function_calls = functionCalls;
         }

package/dist/esm/plugins/google/nodes/ChatGoogleNode.js

@@ -10,8 +10,8 @@ import { getError } from '../../../utils/errors.js';
 import { uint8ArrayToBase64 } from '../../../utils/base64.js';
 import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
 import { getScalarTypeOf, isArrayDataValue } from '../../../model/DataValue.js';
-import { getInputOrData } from '../../../utils/inputs.js';
-import { SchemaType, } from '@google/generative-ai';
+import { getInputOrData, cleanHeaders } from '../../../utils/inputs.js';
+import { Type } from '@google/genai';
 import { mapValues } from 'lodash-es';
 // Temporary
 const cache = new Map();
@@ -27,7 +27,7 @@ export const ChatGoogleNodeImpl = {
                 width: 275,
             },
             data: {
-                model: 'gemini-2.0-flash-001',
+                model: 'gemini-2.5-flash-preview-04-17',
                 useModelInput: false,
                 temperature: 0.5,
                 useTemperatureInput: false,
@@ -42,6 +42,8 @@ export const ChatGoogleNodeImpl = {
                 cache: false,
                 useAsGraphPartialOutput: true,
                 useToolCalling: false,
+                thinkingBudget: undefined,
+                useThinkingBudgetInput: false,
             },
         };
         return chartNode;
@@ -99,11 +101,27 @@ export const ChatGoogleNodeImpl = {
                 description: 'Tools available for the model to call.',
             });
         }
+        if (data.useThinkingBudgetInput) {
+            inputs.push({
+                dataType: 'number',
+                id: 'thinkingBudget',
+                title: 'Thinking Budget',
+                description: 'The token budget for the model to think before responding.',
+            });
+        }
         inputs.push({
             dataType: ['chat-message', 'chat-message[]'],
             id: 'prompt',
             title: 'Prompt',
         });
+        if (data.useHeadersInput) {
+            inputs.push({
+                dataType: 'object',
+                id: 'headers',
+                title: 'Headers',
+                description: 'Additional headers to send to the API.',
+            });
+        }
         return inputs;
     },
     getOutputDefinitions(data) {
@@ -142,6 +160,7 @@ export const ChatGoogleNodeImpl = {
             ? `Top P: ${data.useTopPInput ? '(Using Input)' : data.top_p}`
             : `Temperature: ${data.useTemperatureInput ? '(Using Input)' : data.temperature}`}
       Max Tokens: ${data.maxTokens}
+      Thinking Budget: ${data.thinkingBudget ?? 'Automatic'}
     `;
     },
     getEditors() {
@@ -186,6 +205,17 @@ export const ChatGoogleNodeImpl = {
                 max: Number.MAX_SAFE_INTEGER,
                 step: 1,
             },
+            {
+                type: 'number',
+                label: 'Thinking Budget',
+                dataKey: 'thinkingBudget',
+                allowEmpty: true,
+                step: 1,
+                min: 0,
+                max: Number.MAX_SAFE_INTEGER,
+                useInputToggleDataKey: 'useThinkingBudgetInput',
+                helperMessage: 'The token budget for the model to think before responding. Leave blank for automatic budget.',
+            },
             {
                 type: 'toggle',
                 label: 'Enable Tool Calling',
@@ -201,6 +231,14 @@ export const ChatGoogleNodeImpl = {
                 label: 'Use for subgraph partial output',
                 dataKey: 'useAsGraphPartialOutput',
             },
+            {
+                type: 'keyValuePair',
+                label: 'Headers',
+                dataKey: 'headers',
+                useInputToggleDataKey: 'useHeadersInput',
+                keyPlaceholder: 'Header',
+                helperMessage: 'Additional headers to send to the API.',
+            },
         ];
     },
     getUIData() {
@@ -221,6 +259,7 @@ export const ChatGoogleNodeImpl = {
         const temperature = getInputOrData(data, inputs, 'temperature', 'number');
         const topP = getInputOrData(data, inputs, 'top_p', 'number');
         const useTopP = getInputOrData(data, inputs, 'useTopP', 'boolean');
+        const thinkingBudget = getInputOrData(data, inputs, 'thinkingBudget', 'number');
         const { messages } = getChatGoogleNodeMessages(inputs);
         let prompt = await Promise.all(messages.map(async (message) => {
             if (message.type === 'user' || message.type === 'assistant') {
@@ -326,7 +365,7 @@ export const ChatGoogleNodeImpl = {
                             parameters: Object.keys(tool.parameters.properties).length === 0
                                 ? undefined
                                 : {
-                                    type: SchemaType.OBJECT,
+                                    type: Type.OBJECT,
                                     properties: mapValues(tool.parameters.properties, (p) => ({
                                         // gemini doesn't support union property types, it uses openapi style not jsonschema, what a mess
                                         type: Array.isArray(p.type) ? p.type.filter((t) => t !== 'null')[0] : p.type,
@@ -350,6 +389,18 @@ export const ChatGoogleNodeImpl = {
                 throw new Error('Google Application Credentials or Google API Key is not defined.');
             }
         }
+        const headersFromData = (data.headers ?? []).reduce((acc, header) => {
+            acc[header.key] = header.value;
+            return acc;
+        }, {});
+        const additionalHeaders = data.useHeadersInput
+            ? coerceTypeOptional(inputs['headers'], 'object') ??
+                headersFromData
+            : headersFromData;
+        const allAdditionalHeaders = cleanHeaders({
+            ...context.settings.chatNodeHeaders,
+            ...additionalHeaders,
+        });
         try {
             return await retry(async () => {
                 const options = {
@@ -361,6 +412,8 @@ export const ChatGoogleNodeImpl = {
                     systemPrompt,
                     topK: undefined,
                     tools,
+                    thinkingBudget,
+                    additionalHeaders: allAdditionalHeaders,
                 };
                 const cacheKey = JSON.stringify(options);
                 if (data.cache) {
@@ -386,6 +439,8 @@ export const ChatGoogleNodeImpl = {
                         apiKey,
                         systemPrompt,
                         tools,
+                        thinkingBudget,
+                        additionalHeaders: allAdditionalHeaders,
                     });
                 }
                 else {
@@ -404,6 +459,14 @@ export const ChatGoogleNodeImpl = {
                 }
                 const responseParts = [];
                 const functionCalls = [];
+                let throttleLastCalledTime = Date.now();
+                const onPartialOutput = (output) => {
+                    const now = Date.now();
+                    if (now - throttleLastCalledTime > (context.settings.throttleChatNode ?? 100)) {
+                        context.onPartialOutputs?.(output);
+                        throttleLastCalledTime = now;
+                    }
+                };
                 for await (const chunk of chunks) {
                     if (chunk.completion) {
                         responseParts.push(chunk.completion);
@@ -423,8 +486,10 @@ export const ChatGoogleNodeImpl = {
                             })),
                         };
                     }
-                    context.onPartialOutputs?.(output);
+                    onPartialOutput?.(output);
                 }
+                // Call one last time manually to ensure the last output is sent
+                context.onPartialOutputs?.(output);
                 const endTime = Date.now();
                 output['all-messages'] = {
                     type: 'chat-message[]',

package/dist/esm/plugins/huggingface/nodes/ChatHuggingFace.js

@@ -1,6 +1,6 @@
 import { nanoid } from 'nanoid/non-secure';
 import {} from '../../../index.js';
-import { HfInference, HfInferenceEndpoint } from '@huggingface/inference';
+import { InferenceClient } from '@huggingface/inference';
 import { getInputOrData } from '../../../utils/inputs.js';
 import { coerceType } from '../../../utils/coerceType.js';
 import { dedent } from '../../../utils/misc.js';
@@ -206,7 +206,9 @@ export const ChatHuggingFaceNodeImpl = {
         const repetitionPenalty = getInputOrData(data, inputData, 'repetitionPenalty', 'number');
         const topP = getInputOrData(data, inputData, 'topP', 'number');
         const topK = getInputOrData(data, inputData, 'topK', 'number');
-        const hf = endpoint ? new HfInferenceEndpoint(endpoint, accessToken) : new HfInference(accessToken);
+        const hf = endpoint
+            ? new InferenceClient(accessToken, { endpointUrl: endpoint })
+            : new InferenceClient(accessToken);
         const generationStream = hf.textGenerationStream({
             inputs: prompt,
             model,

package/dist/esm/plugins/huggingface/nodes/TextToImageHuggingFace.js

@@ -1,6 +1,6 @@
 import { nanoid } from 'nanoid/non-secure';
 import {} from '../../../index.js';
-import { HfInference, HfInferenceEndpoint } from '@huggingface/inference';
+import { InferenceClient } from '@huggingface/inference';
 import { dedent } from 'ts-dedent';
 import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
 import { getInputOrData } from '../../../utils/inputs.js';
@@ -163,7 +163,9 @@ export const TextToImageHuggingFaceNodeImpl = {
         const negativePrompt = getInputOrData(data, inputData, 'negativePrompt') || undefined;
         const guidanceScale = getInputOrData(data, inputData, 'guidanceScale', 'number');
         const numInferenceSteps = getInputOrData(data, inputData, 'numInferenceSteps', 'number');
-        const hf = endpoint ? new HfInferenceEndpoint(endpoint, accessToken) : new HfInference(accessToken);
+        const hf = endpoint
+            ? new InferenceClient(accessToken, { endpointUrl: endpoint })
+            : new InferenceClient(accessToken);
         const image = await hf.textToImage({
             inputs: prompt,
             model,
@@ -174,7 +176,7 @@ export const TextToImageHuggingFaceNodeImpl = {
                 guidance_scale: guidanceScale,
                 num_inference_steps: numInferenceSteps,
             },
-        });
+        }, { outputType: "blob" });
         return {
             ['output']: {
                 type: 'image',

package/dist/esm/utils/interpolation.js

@@ -1,6 +1,9 @@
 import { dedent } from './misc.js';
-export const TOKEN_MATCH_REGEX = /\{\{(?!\{)([^{}\s][^{}]*[^{}\s]|[^{}\s])\}\}(?!\})/g;
-export const ESCAPED_TOKEN_REGEX = /\{{3}([^{}]+)\}{3}/g;
+import { get as lodashGet } from 'lodash-es';
+// Simpler regex allowing spaces, relies on trim() later
+export const TOKEN_MATCH_REGEX = /\{\{([^}]+?)\}\}/g;
+export const ESCAPED_TOKEN_REGEX = /\{\{\{([^}]+?)\}\}\}/g;
+export const ESCAPED_ESCAPED_TOKEN_REGEX = /\\\{\\\{([^}]+?)\\\}\\\}/g;
 const processingFunctions = {
     indent: (input, spaces = 0) => {
         const indent = ' '.repeat(spaces);
@@ -62,7 +65,99 @@ const processingFunctions = {
         return lines.join('\n');
     },
 };
-// Parse processing instructions like "indent 2" or "quote" into function name and parameter
+// Helper function to check and potentially unwrap a DataValue-like object
+export function unwrapPotentialDataValue(value) {
+    if (typeof value === 'object' &&
+        value !== null &&
+        typeof value.type === 'string' &&
+        Object.prototype.hasOwnProperty.call(value, 'value') // More robust check for 'value' property
+    ) {
+        return value.value;
+    }
+    return value;
+}
+// Renamed from resolveExpression, now exported and returns raw value
+export function resolveExpressionRawValue(source, expression, sourceType) {
+    if (!source) {
+        return undefined;
+    }
+    // Regex to capture the main key and the optional path starting with . or [
+    // Allows for spaces around the key, path, ., and []
+    // Key: Group 1; Path: Group 2
+    const match = expression.trim().match(/^([^[.\s]+)\s*(.*)$/);
+    let key;
+    let path;
+    // Check if match is successful AND group 1 (the key) was captured
+    if (match && typeof match[1] === 'string') {
+        key = match[1];
+        const rawPath = match[2]; // Group 2 (the path part, might start with . or [)
+        // Clean and assign path only if rawPath is not empty
+        if (rawPath) {
+            // Clean path: Trim whitespace, then remove spaces around separators '.', '[', ']'
+            // Preserve the leading '.' or '[' as lodashGet handles them.
+            path = rawPath.trim().replace(/\s*(\.|\[|\])\s*/g, '$1');
+        }
+        else {
+            path = undefined;
+        }
+    }
+    else {
+        // If match failed or group 1 wasn't captured (fallback)
+        // Assume the entire expression is the key and there's no path
+        key = expression.trim();
+        path = undefined;
+    }
+    if (!key) {
+        // If key is empty after trimming, it's invalid.
+        return undefined;
+    }
+    const topLevelValue = source[key];
+    if (topLevelValue === undefined) {
+        return undefined; // Key not found in source
+    }
+    // Get the base value by potentially unwrapping the top-level value using the shared helper
+    const baseValue = unwrapPotentialDataValue(topLevelValue);
+    // If there's a path, try to resolve it using lodashGet on the baseValue
+    let finalValue;
+    if (path) {
+        try {
+            finalValue = lodashGet(baseValue, path);
+            // IMPORTANT: After getting a potentially nested value via path,
+            // we might *still* have a DataValue (if the context stores them nested).
+            // Unwrap again to be safe.
+            finalValue = unwrapPotentialDataValue(finalValue);
+        }
+        catch (error) {
+            console.warn(`Error accessing path "${path}" in ${sourceType} value for key "${key}":`, error);
+            return undefined; // Error during path access
+        }
+    }
+    else {
+        finalValue = baseValue; // No path, use the (potentially unwrapped) base value
+    }
+    // Return the raw final value
+    return finalValue;
+}
+// New function: Resolves and converts to string format suitable for TextNode
+export function resolveExpressionToString(source, expression, sourceType) {
+    const finalValue = resolveExpressionRawValue(source, expression, sourceType);
+    if (finalValue === undefined) {
+        return undefined;
+    }
+    // Convert the final value to a string for TextNode context
+    if (typeof finalValue === 'object' && finalValue !== null) {
+        try {
+            return JSON.stringify(finalValue);
+        }
+        catch (error) {
+            console.warn(`Error stringifying object/array in ${sourceType} for expression "${expression}":`, error);
+            return '[object Object]'; // Fallback
+        }
+    }
+    // For primitives
+    return String(finalValue);
+}
+// Helper function to parse processing instructions like "indent 2" or "quote" into function name and parameter
 function parseProcessing(instruction) {
     const parts = instruction.trim().split(/\s+/);
     return {
@@ -83,29 +178,72 @@ function applyProcessing(value, processingChain) {
         return processingFunc(result, param);
     }, value);
 }
-export function interpolate(baseString, values) {
-    return baseString
-        .replace(TOKEN_MATCH_REGEX, (_m, p1) => {
-        const [token, ...processing] = p1.split('|');
-        const value = values[token.trim()];
-        if (value === undefined)
+export function interpolate(template, variables, graphInputValues, contextValues) {
+    return template
+        .replace(ESCAPED_TOKEN_REGEX, (_match, expression) => {
+        // Replace with \{\{expression\}\} to escape
+        return `\\{\\{${expression}\\}\\}`; // Escaped token
+    })
+        .replace(/\{\{((?:@graphInputs|@context)\..*?|[^}]+?)\}\}/g, (_match, expressionWithMaybeProcessing) => {
+        const parts = expressionWithMaybeProcessing.split('|').map((s) => s.trim());
+        const expression = parts[0]; // The variable name or path, e.g., @context.foo.bar or myVar
+        const processingChain = parts.slice(1).join('|'); // e.g., indent 2 | quote
+        let resolvedValue;
+        if (expression.startsWith('@graphInputs.')) {
+            // Use the new string-converting function
+            resolvedValue = resolveExpressionToString(graphInputValues, expression.substring('@graphInputs.'.length), 'graphInputs');
+        }
+        else if (expression.startsWith('@context.')) {
+            // Use the new string-converting function
+            resolvedValue = resolveExpressionToString(contextValues, expression.substring('@context.'.length), 'context');
+        }
+        else {
+            const simpleVar = variables[expression];
+            if (simpleVar !== undefined) {
+                // Simple variables might be DataValue or raw strings
+                resolvedValue = String(unwrapPotentialDataValue(simpleVar) ?? '');
+            }
+            else {
+                resolvedValue = undefined; // Variable not found
+            }
+        }
+        if (resolvedValue === undefined) {
+            // Return an empty string if the variable is not found or resolves to undefined
+            console.warn(`Interpolation variable or path "${expression}" not found or resolved to undefined.`);
             return '';
-        if (processing.length > 0) {
-            return applyProcessing(value, p1);
         }
-        return value;
+        // Apply processing if any instructions exist
+        if (processingChain) {
+            return applyProcessing(resolvedValue, processingChain);
+        }
+        return resolvedValue;
     })
-        .replace(ESCAPED_TOKEN_REGEX, (_m, p1) => {
-        return `{{${p1}}}`;
+        .replace(ESCAPED_ESCAPED_TOKEN_REGEX, (_match, expression) => {
+        // Replace with {{expression}} to unescape
+        return `{{${expression}}}`; // Unescaped token
     });
 }
 // Extract all unique variable names from a template string
+// Ignores variables starting with @graphInputs. or @context., as they are treated as special references.
 export function extractInterpolationVariables(template) {
-    const matches = template.matchAll(TOKEN_MATCH_REGEX);
+    const matches = template
+        .replace(ESCAPED_TOKEN_REGEX, (_match, content) => {
+        // Replace escaped tokens with the escaped escaped version so they're not matched
+        return `\\{\\{${content}\\}\\}`;
+    })
+        .matchAll(TOKEN_MATCH_REGEX);
     const variables = new Set();
     for (const match of matches) {
-        const [token] = match[1].split('|');
-        variables.add(token.trim());
+        if (match[1]) {
+            const [tokenPart] = match[1].split('|');
+            if (tokenPart) {
+                const token = tokenPart.trim();
+                // Filter out special prefixes
+                if (!token.startsWith('@graphInputs.') && !token.startsWith('@context.')) {
+                    variables.add(token);
+                }
+            }
+        }
     }
     return Array.from(variables);
 }

package/dist/esm/utils/openai.js

@@ -188,6 +188,30 @@ export const openaiModels = {
         },
         displayName: 'GPT-4o Audio (Preview)',
     },
+    'gpt-4.1': {
+        maxTokens: 1_047_576,
+        cost: {
+            prompt: 2e-6,
+            completion: 8e-6,
+        },
+        displayName: 'GPT-4.1',
+    },
+    o3: {
+        maxTokens: 200_000,
+        cost: {
+            prompt: 10e-6,
+            completion: 40e-6,
+        },
+        displayName: 'o3',
+    },
+    'o4-mini': {
+        maxTokens: 200_000,
+        cost: {
+            prompt: 1.1e-6,
+            completion: 4.4e-6,
+        },
+        displayName: 'o4-mini',
+    },
     'local-model': {
         maxTokens: Number.MAX_SAFE_INTEGER,
         cost: {

package/dist/types/api/createProcessor.d.ts

@@ -1,5 +1,5 @@
 import type { PascalCase } from 'type-fest';
-import { type AttachedData, type AudioProvider, type DataValue, type DatasetProvider, type ExternalFunction, type NativeApi, type NodeRegistration, type ProcessContext, type ProcessEvents, type Project, type RivetEventStreamFilterSpec, type Settings } from '../index.js';
+import { type AttachedData, type AudioProvider, type DataValue, type DatasetProvider, type ExternalFunction, type MCPProvider, type NativeApi, type NodeRegistration, type ProcessContext, type ProcessEvents, type Project, type RivetEventStreamFilterSpec, type Settings } from '../index.js';
 import { GraphProcessor } from '../model/GraphProcessor.js';
 import type { Tokenizer } from '../integrations/Tokenizer.js';
 import { type LooseDataValue } from './looseDataValue.js';
@@ -12,6 +12,7 @@ export type RunGraphOptions = {
     nativeApi?: NativeApi;
     datasetProvider?: DatasetProvider;
     audioProvider?: AudioProvider;
+    mcpProvider?: MCPProvider;
     externalFunctions?: {
         [key: string]: ExternalFunction;
     };
@@ -19,7 +20,7 @@ export type RunGraphOptions = {
         [key: string]: (data: DataValue | undefined) => void;
     };
     abortSignal?: AbortSignal;
-    registry?: NodeRegistration;
+    registry?: NodeRegistration<any, any>;
     includeTrace?: boolean;
     getChatNodeEndpoint?: ProcessContext['getChatNodeEndpoint'];
     tokenizer?: Tokenizer;

package/dist/types/api/streaming.d.ts

@@ -1,4 +1,4 @@
-import { type NodeId, type Inputs, type Outputs, type GraphOutputs, type GraphProcessor } from '../index.js';
+import { type NodeId, type Inputs, type Outputs, type GraphOutputs, type GraphProcessor, type DataValue, type RunGraphOptions, type GraphEvents } from '../index.js';
 export type RivetEventStreamFilterSpec = {
     /** Stream partial output deltas for the specified node IDs or node titles. */
     partialOutputs?: string[] | true;
@@ -16,6 +16,8 @@ export type RivetEventStreamFilterSpec = {
     nodeStart?: string[] | true;
     /** Stream node finish events for the specified nodeIDs or node titles. */
     nodeFinish?: string[] | true;
+    /** Optional list of user events (comma separated list) to stream as part of the output. */
+    userStreamEvents?: string | undefined;
 };
 /** Map of all possible event names to their data for streaming events. */
 export type RivetEventStreamEvent = {
@@ -38,6 +40,9 @@ export type RivetEventStreamEvent = {
     done: {
         graphOutput: GraphOutputs;
     };
+    event: {
+        graphEvent: GraphEvents;
+    };
     error: {
         error: string;
     };
@@ -49,6 +54,7 @@ export type RivetEventStreamEventInfo = {
 }[keyof RivetEventStreamEvent];
 /** A simplified way to listen and stream processor events, including filtering. */
 export declare function getProcessorEvents(processor: GraphProcessor, spec: RivetEventStreamFilterSpec): AsyncGenerator<RivetEventStreamEventInfo, void>;
+export declare const createOnStreamUserEvents: (eventList: string | undefined, handleUserEvent: (event: string, data: DataValue | undefined) => Promise<void>) => RunGraphOptions["onUserEvent"];
 /**
  * Creates a ReadableStream for processor events, following the Server-Sent Events protocol.
  * https://developer.mozilla.org/en-US/docs/Web/API/EventSource

package/dist/types/exports.d.ts

@@ -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/types/integrations/CodeRunner.d.ts

@@ -1,4 +1,5 @@
 import type { Inputs, Outputs } from '../index.js';
+import type { DataValue } from '../model/DataValue.js';
 export interface CodeRunnerOptions {
     includeRequire: boolean;
     includeFetch: boolean;
@@ -8,11 +9,11 @@ export interface CodeRunnerOptions {
 }
 /** An object that can run arbitrary code (evals it). */
 export interface CodeRunner {
-    runCode: (code: string, inputs: Inputs, options: CodeRunnerOptions) => Promise<Outputs>;
+    runCode: (code: string, inputs: Inputs, options: CodeRunnerOptions, graphInputs?: Record<string, DataValue>, contextValues?: Record<string, DataValue>) => Promise<Outputs>;
 }
 export declare class IsomorphicCodeRunner implements CodeRunner {
-    runCode(code: string, inputs: Inputs, options: CodeRunnerOptions): Promise<Outputs>;
+    runCode(code: string, inputs: Inputs, options: CodeRunnerOptions, graphInputs?: Record<string, DataValue>, contextValues?: Record<string, DataValue>): Promise<Outputs>;
 }
 export declare class NotAllowedCodeRunner implements CodeRunner {
-    runCode(_code: string, _inputs: Inputs, _options: CodeRunnerOptions): Promise<Outputs>;
+    runCode(_code: string, _inputs: Inputs, _options: CodeRunnerOptions, _graphInputs?: Record<string, DataValue>, _contextValues?: Record<string, DataValue>): Promise<Outputs>;
 }

package/dist/types/integrations/mcp/MCPBase.d.ts

@@ -0,0 +1,20 @@
+import type { EditorDefinition } from '../../model/EditorDefinition.js';
+import type { ChartNode, NodeInputDefinition } from '../../model/NodeBase.js';
+import type { RivetUIContext } from '../../model/RivetUIContext.js';
+import type { MCP } from './MCPProvider.js';
+export interface MCPBaseNodeData {
+    name: string;
+    version: string;
+    transportType: MCP.TransportType;
+    serverUrl?: string;
+    serverId?: string;
+    headers: string;
+    useHeadersInput?: boolean;
+    useNameInput?: boolean;
+    useVersionInput?: boolean;
+    useServerUrlInput?: boolean;
+    useServerIdInput?: boolean;
+}
+export type MCPBaseNode = ChartNode<'mcpBase', MCPBaseNodeData>;
+export declare const getMCPBaseInputs: (data: MCPBaseNodeData) => NodeInputDefinition[];
+export declare const getMCPBaseEditors: (context: RivetUIContext, data: MCPBaseNodeData) => Promise<EditorDefinition<MCPBaseNode>[]>;