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

package/dist/esm/plugins/anthropic/anthropic.js

@@ -80,12 +80,28 @@ export const anthropicModels = {
         },
         displayName: 'Claude 3.7 Sonnet',
     },
+    'claude-sonnet-4-20250514': {
+        maxTokens: 200_000,
+        cost: {
+            prompt: 3e-6,
+            completion: 3.75e-6,
+        },
+        displayName: 'Claude Sonnet 4',
+    },
+    'claude-opus-4-20250514': {
+        maxTokens: 200_000,
+        cost: {
+            prompt: 15e-6,
+            completion: 18.75e-6,
+        },
+        displayName: 'Claude Opus 4',
+    },
 };
 export const anthropicModelOptions = Object.entries(anthropicModels).map(([id, { displayName }]) => ({
     value: id,
     label: displayName,
 }));
-export async function* streamChatCompletions({ apiEndpoint, apiKey, signal, ...rest }) {
+export async function* streamChatCompletions({ apiEndpoint, apiKey, signal, additionalHeaders, ...rest }) {
     const defaultSignal = new AbortController().signal;
     const response = await fetchEventSource(`${apiEndpoint}/completions`, {
         method: 'POST',
@@ -94,6 +110,7 @@ export async function* streamChatCompletions({ apiEndpoint, apiKey, signal, ...r
             'x-api-key': apiKey,
             'anthropic-version': '2023-06-01',
             'anthropic-dangerous-direct-browser-access': 'true',
+            ...additionalHeaders,
         },
         body: JSON.stringify({
             ...rest,
@@ -125,7 +142,7 @@ export async function* streamChatCompletions({ apiEndpoint, apiKey, signal, ...r
         throw new AnthropicError(`No chunks received. Response: ${JSON.stringify(responseJson)}`, response, responseJson);
     }
 }
-export async function callMessageApi({ apiEndpoint, apiKey, signal, tools, beta, ...rest }) {
+export async function callMessageApi({ apiEndpoint, apiKey, signal, tools, beta, additionalHeaders, ...rest }) {
     const defaultSignal = new AbortController().signal;
     const response = await fetch(`${apiEndpoint}/messages`, {
         method: 'POST',
@@ -135,6 +152,7 @@ export async function callMessageApi({ apiEndpoint, apiKey, signal, tools, beta,
             'anthropic-version': '2023-06-01',
             'anthropic-dangerous-direct-browser-access': 'true',
             ...(beta ? { 'anthropic-beta': beta } : {}),
+            ...additionalHeaders,
         },
         body: JSON.stringify({
             ...rest,
@@ -149,7 +167,7 @@ export async function callMessageApi({ apiEndpoint, apiKey, signal, tools, beta,
     }
     return responseJson;
 }
-export async function* streamMessageApi({ apiEndpoint, apiKey, signal, beta, ...rest }) {
+export async function* streamMessageApi({ apiEndpoint, apiKey, signal, beta, additionalHeaders, ...rest }) {
     // Use the Messages API for Claude 3 models
     const defaultSignal = new AbortController().signal;
     const response = await fetchEventSource(`${apiEndpoint}/messages`, {
@@ -160,6 +178,7 @@ export async function* streamMessageApi({ apiEndpoint, apiKey, signal, beta, ...
             'anthropic-version': '2023-06-01',
             'anthropic-dangerous-direct-browser-access': 'true',
             ...(beta ? { 'anthropic-beta': beta } : {}),
+            ...additionalHeaders,
         },
         body: JSON.stringify({
             ...rest,

package/dist/esm/plugins/anthropic/nodes/ChatAnthropicNode.js

@@ -12,7 +12,7 @@ import { getScalarTypeOf, isArrayDataValue } from '../../../model/DataValue.js';
 import { assertNever } from '../../../utils/assertNever.js';
 import { isNotNull } from '../../../utils/genericUtilFunctions.js';
 import { uint8ArrayToBase64 } from '../../../utils/base64.js';
-import { getInputOrData } from '../../../utils/inputs.js';
+import { getInputOrData, cleanHeaders } from '../../../utils/inputs.js';
 // Temporary
 const cache = new Map();
 export const ChatAnthropicNodeImpl = {
@@ -27,7 +27,7 @@ export const ChatAnthropicNodeImpl = {
                 width: 275,
             },
             data: {
-                model: 'claude-3-7-sonnet-latest',
+                model: 'claude-sonnet-4-20250514',
                 useModelInput: false,
                 temperature: 0.5,
                 useTemperatureInput: false,
@@ -120,6 +120,14 @@ export const ChatAnthropicNodeImpl = {
                 coerced: false,
             });
         }
+        if (data.useHeadersInput) {
+            inputs.push({
+                dataType: 'object',
+                id: 'headers',
+                title: 'Headers',
+                description: 'Additional headers to send to the API.',
+            });
+        }
         return inputs;
     },
     getOutputDefinitions(data) {
@@ -267,6 +275,14 @@ export const ChatAnthropicNodeImpl = {
                         useInputToggleDataKey: 'useOverrideModelInput',
                         helperMessage: 'Overrides the AI model used for the chat node to this value.',
                     },
+                    {
+                        type: 'keyValuePair',
+                        label: 'Headers',
+                        dataKey: 'headers',
+                        useInputToggleDataKey: 'useHeadersInput',
+                        keyPlaceholder: 'Header',
+                        helperMessage: 'Additional headers to send to the API.',
+                    },
                 ],
             },
         ];
@@ -343,6 +359,18 @@ export const ChatAnthropicNodeImpl = {
             addWarning(output, message);
             maxTokens = Math.floor((modelInfo.maxTokens - tokenCountEstimate) * 0.95); // reduce max tokens by 5% to be safe, calculation is a little wrong.
         }
+        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 completionOptions = {
@@ -365,7 +393,7 @@ export const ChatAnthropicNodeImpl = {
                         ? tools.map((tool) => ({ name: tool.name, description: tool.description, input_schema: tool.parameters }))
                         : undefined,
                 };
-                const useMessageApi = model.startsWith('claude-3');
+                const useMessageApi = model.startsWith('claude-3') || model.startsWith('claude-sonnet') || model.startsWith('claude-opus');
                 const cacheKey = JSON.stringify(useMessageApi ? messageOptions : completionOptions);
                 if (data.cache) {
                     const cached = cache.get(cacheKey);
@@ -385,6 +413,7 @@ export const ChatAnthropicNodeImpl = {
                         apiKey: apiKey ?? '',
                         signal: context.signal,
                         beta: 'prompt-caching-2024-07-31',
+                        additionalHeaders: allAdditionalHeaders,
                         ...messageOptions,
                     });
                     // Process the response chunks and update the output
@@ -516,6 +545,7 @@ export const ChatAnthropicNodeImpl = {
                         apiEndpoint,
                         apiKey: apiKey ?? '',
                         signal: context.signal,
+                        additionalHeaders: allAdditionalHeaders,
                         ...completionOptions,
                     });
                     // Process the response chunks and update the output

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/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;