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

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

@@ -157,23 +157,22 @@ export class ExtractRegexNodeImpl extends NodeImpl {
                 },
             };
         }
-        const output = {
-            ['succeeded']: {
-                type: 'boolean',
-                value: true,
-            },
-            ['failed']: {
-                type: 'boolean',
-                value: false,
-            },
-        };
-        output['matches'] = outputArray;
+        const output = {};
         for (let i = 1; i < firstMatch.length; i++) {
             output[`output${i}`] = {
                 type: 'string',
                 value: firstMatch[i],
             };
         }
+        output['matches'] = outputArray;
+        output['succeeded'] = {
+            type: 'boolean',
+            value: true,
+        };
+        output['failed'] = {
+            type: 'boolean',
+            value: false,
+        };
         return output;
     }
 }

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

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

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

@@ -19,7 +19,7 @@ export class GetEmbeddingNodeImpl extends NodeImpl {
                 integration: 'openai',
                 useIntegrationInput: false,
                 model: undefined,
-                dimensions: undefined
+                dimensions: undefined,
             },
         };
     }

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

@@ -126,8 +126,9 @@ export class HttpCallNodeImpl extends NodeImpl {
             },
             {
                 type: 'toggle',
-                label: 'Whether response body is expected to be a binary',
+                label: 'Binary Output',
                 dataKey: 'isBinaryOutput',
+                helperMessage: 'Toggle on if the response is expected to be binary data',
             },
             {
                 type: 'toggle',
@@ -158,6 +159,7 @@ export class HttpCallNodeImpl extends NodeImpl {
     async process(inputs, context) {
         const method = getInputOrData(this.data, inputs, 'method', 'string');
         const url = getInputOrData(this.data, inputs, 'url', 'string');
+        // TODO: Use URL.canParse when we drop support for Node 18
         try {
             new URL(url);
         }

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

@@ -106,6 +106,11 @@ export class IfNodeImpl extends NodeImpl {
                 return isFalse;
             }
         }
+        if (ifValue.type === 'object' || ifValue.type === 'any') {
+            if (!ifValue.value) {
+                return isFalse;
+            }
+        }
         if (ifValue.type.endsWith('[]')) {
             const value = ifValue;
             if (!value.value || value.value.length === 0) {

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

@@ -7,7 +7,7 @@ import { coerceType } from '../../utils/coerceType.js';
 import {} from '../ProcessContext.js';
 import { dedent } from 'ts-dedent';
 import {} from '../../index.js';
-import { entries, values } from '../../utils/typeSafety.js';
+import { entries } from '../../utils/typeSafety.js';
 export class LoopControllerNodeImpl extends NodeImpl {
     static create() {
         const chartNode = {

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

@@ -0,0 +1,214 @@
+import {} from '../NodeBase.js';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../GraphProcessor.js';
+import {} from '../NodeGraph.js';
+import { nanoid } from 'nanoid/non-secure';
+import {} from '../Project.js';
+import {} from './GraphInputNode.js';
+import {} from './GraphOutputNode.js';
+import {} from '../DataValue.js';
+import {} from '../ProcessContext.js';
+import {} from '../EditorDefinition.js';
+import { dedent } from 'ts-dedent';
+export class LoopUntilNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'loopUntil',
+            title: 'Loop Until',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 200,
+            },
+            data: {
+                targetGraph: undefined,
+                conditionType: 'allOutputsSet',
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions(_connections, _nodes, project) {
+        const inputs = [];
+        // Get inputs from the target graph
+        const graph = project.graphs[this.data.targetGraph ?? ''];
+        if (graph) {
+            const inputNodes = graph.nodes.filter((node) => node.type === 'graphInput');
+            const inputIds = [...new Set(inputNodes.map((node) => node.data.id))].sort();
+            inputIds.forEach((id) => {
+                const inputNode = inputNodes.find((node) => node.data.id === id);
+                inputs.push({
+                    id: id,
+                    title: id,
+                    dataType: inputNode.data.dataType,
+                });
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions(_connections, _nodes, project) {
+        const outputs = [];
+        // Get outputs from the target graph
+        const graph = project.graphs[this.data.targetGraph ?? ''];
+        if (graph) {
+            const outputNodes = graph.nodes.filter((node) => node.type === 'graphOutput');
+            const outputIds = [...new Set(outputNodes.map((node) => node.data.id))].sort();
+            outputIds.forEach((id) => {
+                const outputNode = outputNodes.find((node) => node.data.id === id);
+                outputs.push({
+                    id: id,
+                    title: id,
+                    dataType: outputNode.data.dataType,
+                });
+            });
+        }
+        // Add standard loop outputs
+        outputs.push({
+            id: 'iteration',
+            title: 'Iterations',
+            dataType: 'number',
+            description: 'The number of iterations completed.',
+        }, {
+            id: 'completed',
+            title: 'Completed',
+            dataType: 'boolean',
+            description: 'True when the loop has completed.',
+        });
+        return outputs;
+    }
+    getEditors(context) {
+        const definitions = [
+            {
+                type: 'graphSelector',
+                label: 'Target Graph',
+                dataKey: 'targetGraph',
+            },
+            {
+                type: 'dropdown',
+                dataKey: 'conditionType',
+                label: 'Stop Condition',
+                options: [
+                    { label: 'All Outputs Set', value: 'allOutputsSet' },
+                    { label: 'Input Equals Value', value: 'inputEqual' },
+                ],
+                helperMessage: 'The condition that will stop the loop',
+            },
+            {
+                type: 'number',
+                dataKey: 'maxIterations',
+                label: 'Max Iterations',
+                helperMessage: 'Maximum number of iterations (optional, leave empty for unlimited)',
+                allowEmpty: true,
+            },
+        ];
+        if (this.data.conditionType === 'inputEqual') {
+            definitions.push({
+                type: 'string',
+                dataKey: 'inputToCheck',
+                label: 'Input to Check',
+                helperMessage: 'The name of the input to compare',
+            }, {
+                type: 'string',
+                dataKey: 'targetValue',
+                label: 'Target Value',
+                helperMessage: 'The value to compare against',
+            });
+        }
+        // Add dynamic editors for graph inputs
+        if (this.data.targetGraph) {
+            const graph = context.project.graphs[this.data.targetGraph];
+            if (graph) {
+                const inputNodes = graph.nodes.filter((node) => node.type === 'graphInput');
+                const inputIds = [...new Set(inputNodes.map((node) => node.data.id))].sort();
+                for (const inputId of inputIds) {
+                    const inputNode = inputNodes.find((node) => node.data.id === inputId);
+                    definitions.push({
+                        type: 'dynamic',
+                        dataKey: 'inputData',
+                        dynamicDataKey: inputNode.data.id,
+                        dataType: inputNode.data.dataType,
+                        label: inputNode.data.id,
+                        editor: inputNode.data.editor ?? 'auto',
+                    });
+                }
+            }
+        }
+        return definitions;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Executes a subgraph in a loop until a condition is met. Each iteration's outputs become
+        the inputs for the next iteration. Supports different stopping conditions and optional
+        maximum iterations.
+      `,
+            infoBoxTitle: 'Loop Until Node',
+            contextMenuTitle: 'Loop Until',
+            group: ['Logic'],
+        };
+    }
+    getBody(context) {
+        if (!this.data.targetGraph) {
+            return 'No target graph selected';
+        }
+        const graphName = context.project.graphs[this.data.targetGraph]?.metadata?.name ?? 'Unknown Graph';
+        const condition = this.data.conditionType === 'allOutputsSet'
+            ? 'all outputs are set'
+            : `${this.data.inputToCheck} equals ${this.data.targetValue}`;
+        const maxIterations = this.data.maxIterations ? `\nMax iterations: ${this.data.maxIterations}` : '';
+        return `Executes ${graphName}\nuntil ${condition}${maxIterations}`;
+    }
+    shouldBreak(outputs) {
+        if (this.data.conditionType === 'allOutputsSet') {
+            // Check if any output is control-flow-excluded
+            const anyInputIsExcluded = Object.values(outputs)
+                .filter((o) => o != null)
+                .some((output) => output.type === 'control-flow-excluded');
+            return !anyInputIsExcluded;
+        }
+        else if (this.data.conditionType === 'inputEqual' && this.data.inputToCheck && this.data.targetValue) {
+            const inputValue = outputs[this.data.inputToCheck];
+            return inputValue?.value?.toString() === this.data.targetValue;
+        }
+        return false;
+    }
+    async process(inputs, context) {
+        if (!this.data.targetGraph) {
+            throw new Error('No target graph selected');
+        }
+        let iteration = 0;
+        let currentInputs = { ...inputs };
+        // Add any default values from inputData
+        if (this.data.inputData) {
+            Object.entries(this.data.inputData).forEach(([key, value]) => {
+                if (currentInputs[key] === undefined) {
+                    currentInputs[key] = value;
+                }
+            });
+        }
+        let lastOutputs = {};
+        while (!context.signal.aborted) {
+            // Check max iterations if set
+            if (this.data.maxIterations && iteration >= this.data.maxIterations) {
+                break;
+            }
+            const subprocessor = context.createSubProcessor(this.data.targetGraph, { signal: context.signal });
+            lastOutputs = await subprocessor.processGraph(context, currentInputs, context.contextValues);
+            iteration++;
+            // Check if the condition is met
+            if (this.shouldBreak(lastOutputs)) {
+                break;
+            }
+            context.onPartialOutputs?.(lastOutputs);
+            // Use outputs as inputs for next iteration
+            currentInputs = lastOutputs;
+        }
+        return {
+            ...lastOutputs,
+            ['iteration']: { type: 'number', value: iteration },
+            ['completed']: { type: 'boolean', value: true },
+        };
+    }
+}
+export const loopUntilNode = nodeDefinition(LoopUntilNodeImpl, 'Loop Until');

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

@@ -25,7 +25,7 @@ export class ObjectNodeImpl extends NodeImpl {
         };
         return chartNode;
     }
-    getInputDefinitions(connections) {
+    getInputDefinitions() {
         // Extract inputs from text, everything like {{input}}
         const inputNames = [...new Set(this.chartNode.data.jsonTemplate.match(/\{\{([^}]+)\}\}/g))];
         return (inputNames?.map((inputName) => {

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

@@ -7,7 +7,7 @@ import { mapValues } from 'lodash-es';
 import { dedent } from 'ts-dedent';
 import { coerceType, coerceTypeOptional } from '../../utils/coerceType.js';
 import { getInputOrData } from '../../utils/index.js';
-import { interpolate } from '../../utils/interpolation.js';
+import { interpolate, extractInterpolationVariables } from '../../utils/interpolation.js';
 import { match } from 'ts-pattern';
 export class PromptNodeImpl extends NodeImpl {
     static create() {
@@ -52,15 +52,21 @@ export class PromptNodeImpl extends NodeImpl {
                 dataType: 'string',
             });
         }
+        if (this.data.useIsCacheBreakpointInput) {
+            inputs.push({
+                id: 'isCacheBreakpoint',
+                title: 'Is Cache Breakpoint',
+                dataType: 'boolean',
+            });
+        }
         // Extract inputs from promptText, everything like {{input}}
-        const inputNames = [...new Set(this.chartNode.data.promptText.match(/\{\{([^}]+)\}\}/g))];
+        const inputNames = extractInterpolationVariables(this.data.promptText);
         inputs = [
             ...inputs,
             ...(inputNames?.map((inputName) => {
                 return {
-                    // id and title should not have the {{ and }}
-                    id: inputName.slice(2, -2),
-                    title: inputName.slice(2, -2),
+                    id: inputName,
+                    title: inputName,
                     dataType: 'string',
                     required: false,
                 };
@@ -87,6 +93,11 @@ export class PromptNodeImpl extends NodeImpl {
     }
     getEditors() {
         return [
+            {
+                type: 'custom',
+                customEditorId: 'PromptNodeAiAssist',
+                label: 'Generate Using AI',
+            },
             {
                 type: 'dropdown',
                 label: 'Type',
@@ -118,6 +129,13 @@ export class PromptNodeImpl extends NodeImpl {
                 label: 'Compute Token Count',
                 dataKey: 'computeTokenCount',
             },
+            {
+                type: 'toggle',
+                label: 'Is Cache Breakpoint',
+                dataKey: 'isCacheBreakpoint',
+                helperMessage: 'For Anthropic, marks this message as a cache breakpoint - this message and every message before it will be cached using Prompt Caching.',
+                useInputToggleDataKey: 'useIsCacheBreakpointInput',
+            },
             {
                 type: 'code',
                 label: 'Prompt Text',
@@ -132,7 +150,7 @@ export class PromptNodeImpl extends NodeImpl {
             {
                 type: 'markdown',
                 text: dedent `
-          _${typeDisplay[this.data.type]}${this.data.name ? ` (${this.data.name})` : ''}_
+          _${typeDisplay[this.data.type]}${this.data.name ? ` (${this.data.name})` : ''}_ ${this.data.isCacheBreakpoint ? ' (Cache Breakpoint)' : ''}
       `,
             },
             {
@@ -161,6 +179,7 @@ export class PromptNodeImpl extends NodeImpl {
         const inputMap = mapValues(inputs, (input) => coerceType(input, 'string'));
         const outputValue = interpolate(this.chartNode.data.promptText, inputMap);
         const type = getInputOrData(this.data, inputs, 'type', 'string');
+        const isCacheBreakpoint = getInputOrData(this.data, inputs, 'isCacheBreakpoint', 'boolean');
         if (['assistant', 'system', 'user', 'function'].includes(type) === false) {
             throw new Error(`Invalid type: ${type}`);
         }
@@ -168,10 +187,12 @@ export class PromptNodeImpl extends NodeImpl {
             .with('system', (type) => ({
             type,
             message: outputValue,
+            isCacheBreakpoint,
         }))
             .with('user', (type) => ({
             type,
             message: outputValue,
+            isCacheBreakpoint,
         }))
             .with('assistant', (type) => {
             let functionCall = this.data.enableFunctionCall
@@ -190,12 +211,14 @@ export class PromptNodeImpl extends NodeImpl {
                 message: outputValue,
                 function_call: functionCall,
                 function_calls: functionCall ? [functionCall] : undefined,
+                isCacheBreakpoint,
             };
         })
             .with('function', (type) => ({
             type,
             message: outputValue,
             name: getInputOrData(this.data, inputs, 'name', 'string'),
+            isCacheBreakpoint,
         }))
             .otherwise(() => {
             throw new Error(`Invalid chat-message type: ${type}`);

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

@@ -3,7 +3,6 @@ import { nanoid } from 'nanoid/non-secure';
 import { NodeImpl } from '../NodeImpl.js';
 import { nodeDefinition } from '../NodeDefinition.js';
 import {} from '../GraphProcessor.js';
-import {} from '../ProcessContext.js';
 import { dedent } from 'ts-dedent';
 import {} from '../../index.js';
 export class RaceInputsNodeImpl extends NodeImpl {
@@ -67,7 +66,7 @@ export class RaceInputsNodeImpl extends NodeImpl {
             group: ['Logic'],
         };
     }
-    async process(inputs, context) {
+    async process(inputs) {
         // GraphProcessor handles most of the racing/aborting logic for us.
         const value = Object.entries(inputs).find(([key, value]) => key.startsWith('input') && value !== undefined && value.type !== 'control-flow-excluded');
         if (!value) {

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

@@ -0,0 +1,210 @@
+import {} from '../NodeBase.js';
+import {} from '../DataValue.js';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { nanoid } from 'nanoid/non-secure';
+import { getInputOrData } from '../../utils/index.js';
+import {} from '../ProcessContext.js';
+import { dedent } from 'ts-dedent';
+import { uint8ArrayToBase64 } from '../../utils/base64.js';
+export class ReadAllFilesNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: nanoid(),
+            type: 'readAllFiles',
+            title: 'Read All Files',
+            visualData: { x: 0, y: 0, width: 250 },
+            data: {
+                path: '',
+                usePathInput: false,
+                recursive: false,
+                useRecursiveInput: false,
+                filterGlobs: [],
+                useFilterGlobsInput: false,
+                ignores: [],
+                useIgnoresInput: false,
+                asBinary: false,
+                errorOnMissingFile: false,
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [];
+        if (this.chartNode.data.usePathInput) {
+            inputDefinitions.push({
+                id: 'path',
+                title: 'Path',
+                dataType: 'string',
+                required: true,
+                coerced: false,
+            });
+        }
+        if (this.chartNode.data.useRecursiveInput) {
+            inputDefinitions.push({
+                id: 'recursive',
+                title: 'Recursive',
+                dataType: 'boolean',
+                required: true,
+                coerced: false,
+            });
+        }
+        if (this.chartNode.data.useFilterGlobsInput) {
+            inputDefinitions.push({
+                id: 'filterGlobs',
+                title: 'Filter Globs',
+                dataType: 'string[]',
+                required: true,
+                coerced: false,
+            });
+        }
+        if (this.chartNode.data.useIgnoresInput) {
+            inputDefinitions.push({
+                id: 'ignores',
+                title: 'Ignores',
+                dataType: 'string[]',
+                required: true,
+                coerced: false,
+            });
+        }
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'files',
+                title: 'Files',
+                dataType: 'object[]',
+            },
+            {
+                id: 'rootPath',
+                title: 'Root Path',
+                dataType: 'string',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'directoryBrowser',
+                label: 'Path',
+                dataKey: 'path',
+                useInputToggleDataKey: 'usePathInput',
+            },
+            {
+                type: 'toggle',
+                label: 'Recursive',
+                dataKey: 'recursive',
+                useInputToggleDataKey: 'useRecursiveInput',
+            },
+            {
+                type: 'stringList',
+                label: 'Filter Globs',
+                dataKey: 'filterGlobs',
+                useInputToggleDataKey: 'useFilterGlobsInput',
+            },
+            {
+                type: 'stringList',
+                label: 'Ignores',
+                dataKey: 'ignores',
+                useInputToggleDataKey: 'useIgnoresInput',
+            },
+            {
+                type: 'toggle',
+                label: 'Read as Binary',
+                dataKey: 'asBinary',
+            },
+            {
+                type: 'toggle',
+                label: 'Error on Missing File',
+                dataKey: 'errorOnMissingFile',
+            },
+        ];
+    }
+    getBody() {
+        return dedent `
+      ${this.data.asBinary ? 'Read as Binary' : 'Read as Text'}
+      Path: ${this.data.usePathInput ? '(Input)' : this.data.path}
+      Recursive: ${this.data.useRecursiveInput ? '(Input)' : this.data.recursive}
+      Filters: ${this.data.useFilterGlobsInput
+            ? '(Input)'
+            : this.data.filterGlobs.length > 0
+                ? this.data.filterGlobs.join(', ')
+                : 'None'}
+    `;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Reads all files in the specified directory and outputs an array of objects containing each file's path and contents.
+        Each object has a 'path' (string) and 'content' (string or binary) property.
+      `,
+            infoBoxTitle: 'Read All Files Node',
+            contextMenuTitle: 'Read All Files',
+            group: ['Input/Output'],
+        };
+    }
+    async process(inputs, context) {
+        const { nativeApi } = context;
+        if (nativeApi == null) {
+            throw new Error('This node requires a native API to run.');
+        }
+        const path = getInputOrData(this.chartNode.data, inputs, 'path');
+        const recursive = getInputOrData(this.data, inputs, 'recursive', 'boolean');
+        const filterGlobs = getInputOrData(this.data, inputs, 'filterGlobs', 'string[]');
+        const ignores = getInputOrData(this.data, inputs, 'ignores', 'string[]');
+        try {
+            // First read the directory
+            const filePaths = await nativeApi.readdir(path, undefined, {
+                recursive,
+                includeDirectories: false, // We only want files since we're reading contents
+                filterGlobs,
+                relative: true, // Always use relative paths in output
+                ignores,
+            });
+            // Then read each file
+            const filePromises = filePaths.map(async (filePath) => {
+                try {
+                    if (this.data.asBinary) {
+                        const content = await nativeApi.readBinaryFile(`${path}/${filePath}`);
+                        const buffer = await content.arrayBuffer();
+                        return {
+                            path: filePath,
+                            content: (await uint8ArrayToBase64(new Uint8Array(buffer))) ?? '',
+                        };
+                    }
+                    else {
+                        const content = await nativeApi.readTextFile(`${path}/${filePath}`, undefined);
+                        return {
+                            path: filePath,
+                            content,
+                        };
+                    }
+                }
+                catch (err) {
+                    if (this.chartNode.data.errorOnMissingFile) {
+                        throw err;
+                    }
+                    return {
+                        path: filePath,
+                        content: this.data.asBinary ? new Uint8Array() : '',
+                    };
+                }
+            });
+            const files = await Promise.all(filePromises);
+            return {
+                ['files']: { type: 'object[]', value: files },
+                ['rootPath']: { type: 'string', value: path },
+            };
+        }
+        catch (err) {
+            if (this.chartNode.data.errorOnMissingFile) {
+                throw err;
+            }
+            return {
+                ['files']: { type: 'object[]', value: [] },
+                ['rootPath']: { type: 'string', value: path },
+            };
+        }
+    }
+}
+export const readAllFilesNode = nodeDefinition(ReadAllFilesNodeImpl, 'Read All Files');