@alpic80/rivet-core 1.19.1-aidon.3 → 1.24.0-aidon.1

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

@@ -3,7 +3,7 @@ import { NodeImpl } from '../../model/NodeImpl.js';
 import { nanoid } from 'nanoid/non-secure';
 import { coerceType } from '../../utils/coerceType.js';
 import { dedent } from 'ts-dedent';
-import { openAiModelOptions, openaiModels } from '../../utils/openai.js';
+import { openAiModelOptions } from '../../utils/openai.js';
 import {} from '../../index.js';
 import { nodeDefinition } from '../NodeDefinition.js';
 export class ChunkNodeImpl extends NodeImpl {
@@ -18,7 +18,7 @@ export class ChunkNodeImpl extends NodeImpl {
                 width: 200,
             },
             data: {
-                model: 'gpt-3.5-turbo',
+                model: 'gpt-4o',
                 useModelInput: false,
                 numTokensPerChunk: 1024,
                 overlap: 0,

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

@@ -33,6 +33,11 @@ export class CodeNodeImpl extends NodeImpl {
         `,
                 inputNames: 'input1',
                 outputNames: 'output1',
+                allowFetch: false,
+                allowRequire: false,
+                allowRivet: false,
+                allowProcess: false,
+                allowConsole: false,
             },
         };
         return chartNode;
@@ -90,6 +95,33 @@ export class CodeNodeImpl extends NodeImpl {
                 label: 'Outputs',
                 dataKey: 'outputNames',
             },
+            {
+                type: 'toggle',
+                label: 'Allow using `fetch`',
+                dataKey: 'allowFetch',
+            },
+            {
+                type: 'toggle',
+                label: 'Allow using `require`',
+                dataKey: 'allowRequire',
+                helperMessage: 'This is only available when using the Node executor.',
+            },
+            {
+                type: 'toggle',
+                label: 'Allow using `Rivet`',
+                dataKey: 'allowRivet',
+            },
+            {
+                type: 'toggle',
+                label: 'Allow using `process`',
+                dataKey: 'allowProcess',
+                helperMessage: 'This is only available when using the Node executor.',
+            },
+            {
+                type: 'toggle',
+                label: 'Allow using `console`',
+                dataKey: 'allowConsole',
+            },
         ];
     }
     getBody() {
@@ -117,10 +149,14 @@ export class CodeNodeImpl extends NodeImpl {
             group: ['Advanced'],
         };
     }
-    async process(inputs) {
-        // eslint-disable-next-line no-new-func
-        const codeFunction = new Function('inputs', this.chartNode.data.code);
-        const outputs = codeFunction(inputs);
+    async process(inputs, context) {
+        const outputs = await context.codeRunner.runCode(this.data.code, inputs, {
+            includeFetch: this.data.allowFetch ?? false,
+            includeRequire: this.data.allowRequire ?? false,
+            includeRivet: this.data.allowRivet ?? false,
+            includeProcess: this.data.allowProcess ?? false,
+            includeConsole: this.data.allowConsole ?? false,
+        });
         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/CronNode.js

@@ -0,0 +1,248 @@
+import { nanoid } from 'nanoid';
+import { NodeImpl } from '../NodeImpl.js';
+import { dedent } from 'ts-dedent';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { coerceType, coerceTypeOptional } from '../../utils/coerceType.js';
+import * as cronParser from 'cron-parser';
+export class CronNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'cron',
+            title: 'Cron',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 200,
+            },
+            data: {
+                targetGraph: undefined,
+                scheduleType: 'interval',
+                schedule: '5 minutes',
+                executeImmediately: true,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = [];
+        inputs.push({
+            id: 'trigger',
+            title: 'Trigger',
+            dataType: 'boolean',
+            description: 'Starts the scheduled job when true.',
+        });
+        if (this.data.useTargetGraphInput) {
+            inputs.push({
+                id: 'targetGraph',
+                title: 'Target Graph',
+                dataType: 'string',
+                description: 'The subgraph to execute on schedule',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'output',
+                title: 'Last Output',
+                dataType: 'any',
+                description: 'The last output from the subgraph execution.',
+            },
+            {
+                id: 'iteration',
+                title: 'Iteration',
+                dataType: 'number',
+                description: 'The current iteration number.',
+            },
+            {
+                id: 'completed',
+                title: 'Completed',
+                dataType: 'boolean',
+                description: 'True when the job has completed.',
+            },
+            {
+                id: 'nextRun',
+                title: 'Next Run',
+                dataType: 'string',
+                description: 'The scheduled time for the next execution.',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Executes a subgraph on a schedule. Supports:
+        - Natural language (e.g., "every 5 minutes", "daily at 3pm")
+        - Cron expressions (e.g., "0 * * * *")
+        - Simple intervals (e.g., "5 minutes", "1 hour")
+      `,
+            infoBoxTitle: 'Cron Node',
+            contextMenuTitle: 'Cron',
+            group: ['Advanced'],
+        };
+    }
+    getEditors() {
+        return [
+            {
+                type: 'toggle',
+                dataKey: 'executeImmediately',
+                label: 'Execute Immediately',
+                helperMessage: 'Starts the job immediately when the node is run, in addition to the schedule',
+            },
+            {
+                type: 'graphSelector',
+                dataKey: 'targetGraph',
+                useInputToggleDataKey: 'useTargetGraphInput',
+                label: 'Target Graph',
+                helperMessage: 'The subgraph to execute on schedule',
+            },
+            {
+                type: 'dropdown',
+                dataKey: 'scheduleType',
+                label: 'Schedule Type',
+                options: [
+                    { label: 'Cron Expression', value: 'cron' },
+                    { label: 'Simple Interval', value: 'interval' },
+                ],
+                helperMessage: 'How to specify the schedule',
+            },
+            {
+                type: 'string',
+                dataKey: 'schedule',
+                label: 'Schedule',
+                helperMessage: dedent `
+          Examples:
+          Cron: "*/5 * * * *", "0 15 * * *"
+          Interval: "5 minutes", "1 hour", "7 days"
+        `,
+            },
+        ];
+    }
+    parseSchedule() {
+        const { scheduleType, schedule } = this.data;
+        if (scheduleType === 'cron') {
+            return { type: 'cron', expression: schedule };
+        }
+        // Parse interval
+        const match = schedule.match(/^(\d+)\s*(second|seconds|minute|minutes|hour|hours|day|days|week|weeks)$/i);
+        if (!match) {
+            throw new Error('Invalid interval format. Expected: "number unit" (e.g., "5 minutes")');
+        }
+        const value = parseInt(match[1], 10);
+        let unit = match[2].toLowerCase();
+        // Normalize unit to plural
+        if (unit.endsWith('s')) {
+            unit = unit;
+        }
+        else {
+            unit = `${unit}s`;
+        }
+        return { type: 'interval', value, unit };
+    }
+    getNextRunTime(schedule) {
+        const now = new Date();
+        if (schedule.type === 'interval') {
+            const { value, unit } = schedule;
+            const next = new Date(now);
+            switch (unit) {
+                case 'seconds':
+                    next.setSeconds(now.getSeconds() + value);
+                    break;
+                case 'minutes':
+                    next.setMinutes(now.getMinutes() + value);
+                    break;
+                case 'hours':
+                    next.setHours(now.getHours() + value);
+                    break;
+                case 'days':
+                    next.setDate(now.getDate() + value);
+                    break;
+                case 'weeks':
+                    next.setDate(now.getDate() + value * 7);
+                    break;
+            }
+            return next;
+        }
+        if (schedule.type === 'cron') {
+            const cron = cronParser.parseExpression(schedule.expression, { currentDate: now });
+            const next = cron.next().toDate();
+            return next;
+        }
+        throw new Error('Invalid schedule type');
+    }
+    getBody(context) {
+        if (!this.data.targetGraph && !this.data.useTargetGraphInput) {
+            return 'No target graph selected';
+        }
+        const graphName = this.data.useTargetGraphInput
+            ? 'graph from input'
+            : context.project.graphs[this.data.targetGraph]?.metadata?.name ?? 'Unknown Graph';
+        return `Executes ${graphName}\n${this.data.schedule}`;
+    }
+    async process(inputs, context) {
+        if (inputs['trigger'] !== undefined) {
+            const trigger = coerceTypeOptional(inputs['trigger'], 'boolean');
+            if (!trigger) {
+                return {
+                    ['completed']: { type: 'boolean', value: false },
+                    ['iteration']: { type: 'number', value: 0 },
+                };
+            }
+        }
+        if (!this.data.targetGraph) {
+            throw new Error('No target graph selected');
+        }
+        let iteration = 0;
+        const schedule = this.parseSchedule();
+        let lastOutputs = {};
+        let didExecuteFirstTime = !this.data.executeImmediately;
+        while (!context.signal.aborted) {
+            const nextRun = didExecuteFirstTime ? this.getNextRunTime(schedule) : new Date();
+            const delay = nextRun.getTime() - Date.now();
+            didExecuteFirstTime = true;
+            // Emit the next run time
+            const outputs = {
+                ['output']: lastOutputs
+                    ? { type: 'object', value: lastOutputs }
+                    : {
+                        type: 'any',
+                        value: null,
+                    },
+                ['iteration']: { type: 'number', value: iteration },
+                ['completed']: { type: 'boolean', value: false },
+                ['nextRun']: { type: 'string', value: nextRun.toISOString() },
+            };
+            if (delay > 0) {
+                await new Promise((resolve) => {
+                    context.signal.addEventListener('abort', resolve, { once: true });
+                    setTimeout(resolve, delay);
+                });
+            }
+            if (context.signal.aborted) {
+                throw new Error('Aborted');
+            }
+            iteration++;
+            const subprocessor = context.createSubProcessor(this.data.targetGraph, { signal: context.signal });
+            lastOutputs = await subprocessor.processGraph(context, lastOutputs, context.contextValues);
+            // Check for break signal
+            const breakSignal = coerceTypeOptional(lastOutputs['break'], 'boolean');
+            if (breakSignal === true) {
+                return {
+                    ...outputs,
+                    ['completed']: { type: 'boolean', value: true },
+                };
+            }
+        }
+        return {
+            ['output']: lastOutputs
+                ? { type: 'object', value: lastOutputs }
+                : { type: 'any', value: null },
+            ['iteration']: { type: 'number', value: iteration },
+            ['completed']: { type: 'boolean', value: true },
+            ['nextRun']: { type: 'string', value: new Date().toISOString() },
+        };
+    }
+}
+export const cronNode = nodeDefinition(CronNodeImpl, 'Cron');

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

@@ -7,7 +7,7 @@ export class DelegateFunctionCallNodeImpl extends NodeImpl {
     static create() {
         const chartNode = {
             type: 'delegateFunctionCall',
-            title: 'Delegate Function Call',
+            title: 'Delegate Tool Call',
             id: nanoid(),
             visualData: {
                 x: 0,
@@ -17,6 +17,7 @@ export class DelegateFunctionCallNodeImpl extends NodeImpl {
             data: {
                 handlers: [],
                 unknownHandler: undefined,
+                autoDelegate: true,
             },
         };
         return chartNode;
@@ -26,10 +27,10 @@ export class DelegateFunctionCallNodeImpl extends NodeImpl {
         inputs.push({
             id: 'function-call',
             dataType: 'object',
-            title: 'Function Call',
+            title: 'Tool Call',
             coerced: true,
             required: true,
-            description: 'The function call to delegate to a subgraph.',
+            description: 'The tool call to delegate to a subgraph.',
         });
         return inputs;
     }
@@ -39,7 +40,7 @@ export class DelegateFunctionCallNodeImpl extends NodeImpl {
             id: 'output',
             dataType: 'string',
             title: 'Output',
-            description: 'The output of the function call.',
+            description: 'The output of the tool call.',
         });
         outputs.push({
             id: 'message',
@@ -52,30 +53,40 @@ export class DelegateFunctionCallNodeImpl extends NodeImpl {
     static getUIData() {
         return {
             infoBoxBody: dedent `
-        Handles a function call by delegating it to a different subgraph depending on the function call.
+        Handles a tool call by delegating it to a different subgraph depending on the tool call.
       `,
-            infoBoxTitle: 'Delegate Function Call Node',
-            contextMenuTitle: 'Delegate Function Call',
+            infoBoxTitle: 'Delegate Tool Call Node',
+            contextMenuTitle: 'Delegate Tool Call',
             group: ['Advanced'],
         };
     }
     getEditors() {
         return [
+            {
+                type: 'toggle',
+                label: 'Auto Delegate',
+                dataKey: 'autoDelegate',
+                helperMessage: 'Automatically delegates tool calls to the subgraph containing the same name as the tool.',
+            },
             {
                 type: 'custom',
                 customEditorId: 'ToolCallHandlers',
                 label: 'Handlers',
                 dataKey: 'handlers',
+                hideIf: (data) => data.autoDelegate,
             },
             {
                 type: 'graphSelector',
                 dataKey: 'unknownHandler',
                 label: 'Unknown Handler',
-                helperMessage: 'The subgraph to delegate to if the function call does not match any handlers.',
+                helperMessage: 'The subgraph to delegate to if the tool call does not match any handlers.',
             },
         ];
     }
     getBody(context) {
+        if (this.data.autoDelegate) {
+            return 'Auto Delegate To Subgraphs';
+        }
         if (this.data.handlers.length === 0) {
             return 'No handlers defined';
         }
@@ -88,13 +99,27 @@ export class DelegateFunctionCallNodeImpl extends NodeImpl {
     }
     async process(inputs, context) {
         const functionCall = coerceType(inputs['function-call'], 'object');
-        let handler = this.data.handlers.find((handler) => handler.key === functionCall.name);
+        let handler;
+        if (this.data.autoDelegate) {
+            const matchingGraph = Object.values(context.project.graphs).find((graph) => graph.metadata?.name?.includes(functionCall.name));
+            if (matchingGraph) {
+                handler = { key: undefined, value: matchingGraph.metadata.id };
+            }
+        }
+        else {
+            handler = this.data.handlers.find((handler) => handler.key === functionCall.name);
+        }
         if (!handler) {
             if (this.data.unknownHandler) {
                 handler = { key: undefined, value: this.data.unknownHandler };
             }
             else {
-                throw new Error(`No handler found for function call: ${functionCall.name}`);
+                if (this.data.autoDelegate) {
+                    throw new Error(`No handler found for tool call: ${functionCall.name}, no graph containing the name "${functionCall.name}" was found.`);
+                }
+                else {
+                    throw new Error(`No handler found for tool call: ${functionCall.name}`);
+                }
             }
         }
         const subgraphInputs = {
@@ -107,7 +132,7 @@ export class DelegateFunctionCallNodeImpl extends NodeImpl {
                 value: functionCall.arguments,
             },
         };
-        for (const [argName, argument] of Object.entries(functionCall.arguments)) {
+        for (const [argName, argument] of Object.entries(functionCall.arguments ?? {})) {
             subgraphInputs[argName] = {
                 type: 'any',
                 value: argument,
@@ -133,4 +158,4 @@ export class DelegateFunctionCallNodeImpl extends NodeImpl {
         };
     }
 }
-export const delegateFunctionCallNode = nodeDefinition(DelegateFunctionCallNodeImpl, 'Delegate Function Call');
+export const delegateFunctionCallNode = nodeDefinition(DelegateFunctionCallNodeImpl, 'Delegate Tool Call');

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

@@ -35,7 +35,7 @@ export class DestructureNodeImpl extends NodeImpl {
         ];
     }
     getOutputDefinitions() {
-        return this.chartNode.data.paths.map((path, index) => ({
+        return this.data.paths.map((path, index) => ({
             id: `match_${index}`,
             title: path,
             dataType: 'any',

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

@@ -0,0 +1,183 @@
+import {} from '../NodeBase.js';
+import { NodeImpl } from '../NodeImpl.js';
+import { nanoid } from 'nanoid/non-secure';
+import {} from '../../index.js';
+import { base64ToUint8Array, expectType } from '../../utils/index.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { getInputOrData } from '../../utils/inputs.js';
+import { dedent } from '../../utils/misc.js';
+export class DocumentNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: nanoid(),
+            type: 'document',
+            title: 'Document',
+            visualData: { x: 0, y: 0, width: 300 },
+            data: {
+                useDataInput: false,
+                useMediaTypeInput: false,
+                title: '',
+                useTitleInput: false,
+                context: '',
+                useContextInput: false,
+                enableCitations: false,
+                useEnableCitationsInput: false,
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [];
+        if (this.chartNode.data.useDataInput) {
+            inputDefinitions.push({
+                id: 'data',
+                title: 'Data',
+                dataType: ['string', 'binary'],
+                coerced: false,
+                description: 'The document data. Either string or binary data loaded from a file.',
+            });
+        }
+        if (this.chartNode.data.useMediaTypeInput) {
+            inputDefinitions.push({
+                id: 'mediaType',
+                title: 'Media Type',
+                dataType: 'string',
+                coerced: false,
+                description: 'The media type of the document, such as text/plain or application/pdf.',
+            });
+        }
+        if (this.data.useTitleInput) {
+            inputDefinitions.push({
+                id: 'title',
+                title: 'Title',
+                dataType: 'string',
+                coerced: true,
+                description: 'The title of the document.',
+            });
+        }
+        if (this.data.useContextInput) {
+            inputDefinitions.push({
+                id: 'context',
+                title: 'Context',
+                dataType: 'string',
+                coerced: true,
+                description: 'The context of the document.',
+            });
+        }
+        if (this.data.useEnableCitationsInput) {
+            inputDefinitions.push({
+                id: 'enableCitations',
+                title: 'Enable Citations',
+                dataType: 'boolean',
+                coerced: true,
+                description: 'Whether to enable citations for the document.',
+            });
+        }
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'data',
+                title: 'Document Data',
+                dataType: 'document',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'fileBrowser',
+                label: 'Document File',
+                dataKey: 'data',
+                mediaTypeDataKey: 'mediaType',
+                useInputToggleDataKey: 'useDataInput',
+                accept: '*/*',
+            },
+            {
+                type: 'string',
+                label: 'Media Type',
+                dataKey: 'mediaType',
+                useInputToggleDataKey: 'useMediaTypeInput',
+            },
+            {
+                type: 'string',
+                label: 'Title',
+                dataKey: 'title',
+                useInputToggleDataKey: 'useTitleInput',
+            },
+            {
+                type: 'string',
+                label: 'Context',
+                dataKey: 'context',
+                useInputToggleDataKey: 'useContextInput',
+            },
+            {
+                type: 'toggle',
+                label: 'Enable Citations',
+                dataKey: 'enableCitations',
+                useInputToggleDataKey: 'useEnableCitationsInput',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            contextMenuTitle: 'Document',
+            group: 'Data',
+            infoBoxTitle: 'Document Node',
+            infoBoxBody: 'Defines a document for use with other nodes such as Assemble Message. Can accept text and PDF files.',
+        };
+    }
+    getBody(_context) {
+        const parts = [
+            this.data.useDataInput ? '(Data from input)' : '(Data stored in node)',
+            this.data.useMediaTypeInput
+                ? '(Media type from input)'
+                : this.data.mediaType
+                    ? `(${this.data.mediaType.trim()})`
+                    : undefined,
+            this.data.useTitleInput ? '(Title from input)' : this.data.title ? `Title: ${this.data.title}` : undefined,
+            this.data.useContextInput
+                ? '(Context from input)'
+                : this.data.context
+                    ? `Context: ${this.data.context}`
+                    : undefined,
+        ].filter((x) => x != null);
+        return dedent `
+      ${parts.join('\n')}
+    `;
+    }
+    async process(inputData, context) {
+        let data;
+        const mediaType = getInputOrData(this.data, inputData, 'mediaType', 'string') || 'text/plain';
+        const title = getInputOrData(this.data, inputData, 'title');
+        const contextInput = getInputOrData(this.data, inputData, 'context');
+        const enableCitations = getInputOrData(this.data, inputData, 'enableCitations', 'boolean');
+        if (this.chartNode.data.useDataInput) {
+            data = expectType(inputData['data'], 'binary');
+        }
+        else {
+            const dataRef = this.data.data?.refId;
+            if (!dataRef) {
+                throw new Error('No data ref');
+            }
+            const encodedData = context.project.data?.[dataRef];
+            if (!encodedData) {
+                throw new Error(`No data at ref ${dataRef}`);
+            }
+            data = base64ToUint8Array(encodedData);
+        }
+        return {
+            ['data']: {
+                type: 'document',
+                value: {
+                    data,
+                    mediaType: mediaType,
+                    title,
+                    context: contextInput,
+                    enableCitations,
+                },
+            },
+        };
+    }
+}
+export const documentNode = nodeDefinition(DocumentNodeImpl, 'Document');

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

@@ -76,10 +76,10 @@ export class ExtractJsonNodeImpl extends NodeImpl {
             // Fall back to more manual parsing
         }
         // Find the first { or [ and the last } or ], and try parsing everything in between including them.
-        let firstBracket = inputString.indexOf('{');
-        let lastBracket = inputString.lastIndexOf('}');
-        let firstSquareBracket = inputString.indexOf('[');
-        let lastSquareBracket = inputString.lastIndexOf(']');
+        const firstBracket = inputString.indexOf('{');
+        const lastBracket = inputString.lastIndexOf('}');
+        const firstSquareBracket = inputString.indexOf('[');
+        const lastSquareBracket = inputString.lastIndexOf(']');
         const firstIndex = firstBracket >= 0 && firstSquareBracket >= 0
             ? Math.min(firstBracket, firstSquareBracket)
             : firstBracket >= 0