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

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/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/ImageToMDNode.js

@@ -0,0 +1,116 @@
+import { uint8ArrayToBase64 } from '../../index.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../GraphProcessor.js';
+import { dedent } from 'ts-dedent';
+import { expectType } from '../../utils/expectType.js';
+export class ImageToMDNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'imagetoMD',
+            title: 'Image To Markdown',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 175,
+            },
+            data: {
+                useDataInput: false,
+                mediaType: 'image/png',
+                useMediaTypeInput: false,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [];
+        if (this.chartNode.data.useDataInput) {
+            inputDefinitions.push({
+                id: 'data',
+                title: 'Data',
+                dataType: 'image',
+                coerced: false,
+            });
+        }
+        if (this.chartNode.data.useMediaTypeInput) {
+            inputDefinitions.push({
+                id: 'mediaType',
+                title: 'Media Type',
+                dataType: 'string',
+            });
+        }
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'imageMarkdown',
+                title: 'Image',
+                dataType: 'string',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'dropdown',
+                label: 'Media Type',
+                dataKey: 'mediaType',
+                options: [
+                    { value: 'image/png', label: 'PNG' },
+                    { value: 'image/jpeg', label: 'JPEG' },
+                    { value: 'image/gif', label: 'GIF' },
+                ],
+                useInputToggleDataKey: 'useMediaTypeInput',
+            },
+            {
+                type: 'imageBrowser',
+                label: 'Image',
+                dataKey: 'data',
+                useInputToggleDataKey: 'useDataInput',
+                mediaTypeDataKey: 'mediaType',
+            },
+        ];
+    }
+    getBody() {
+        return this.data.mediaType;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Turns the input value (image byte array) into its Markdown equivalent.
+      `,
+            infoBoxTitle: 'Image to Markdown Node',
+            contextMenuTitle: 'Image to Markdown',
+            group: ['Data'],
+        };
+    }
+    async process(inputData, context) {
+        let data;
+        if (this.chartNode.data.useDataInput) {
+            const imageData = expectType(inputData['data'], 'image');
+            data = (await uint8ArrayToBase64(imageData.data));
+        }
+        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 = encodedData;
+        }
+        data = `![Image](data:image/png;base64,${data})`;
+        return {
+            ['imageMarkdown']: {
+                type: 'string',
+                value: data,
+            },
+        };
+    }
+}
+export const imageToMDNode = nodeDefinition(ImageToMDNodeImpl, 'Image To Markdown');

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/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}`);