@alpic80/rivet-core 1.19.1-aidon.1

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

@@ -0,0 +1,166 @@
+import {} from '../../model/NodeBase.js';
+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 {} from '../../index.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+export class ChunkNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'chunk',
+            title: 'Chunk',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 200,
+            },
+            data: {
+                model: 'gpt-3.5-turbo',
+                useModelInput: false,
+                numTokensPerChunk: 1024,
+                overlap: 0,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = [
+            {
+                id: 'input',
+                title: 'Input',
+                dataType: 'string',
+            },
+        ];
+        if (this.data.useModelInput) {
+            inputs.push({
+                id: 'model',
+                title: 'Model',
+                dataType: 'string',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'chunks',
+                title: 'Chunks',
+                dataType: 'string[]',
+            },
+            {
+                id: 'first',
+                title: 'First',
+                dataType: 'string',
+            },
+            {
+                id: 'last',
+                title: 'Last',
+                dataType: 'string',
+            },
+            {
+                id: 'indexes',
+                title: 'Indexes',
+                dataType: 'number[]',
+            },
+            {
+                id: 'count',
+                title: 'Count',
+                dataType: 'number',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'dropdown',
+                label: 'Model',
+                dataKey: 'model',
+                options: openAiModelOptions,
+                useInputToggleDataKey: 'useModelInput',
+            },
+            {
+                type: 'number',
+                label: 'Number of tokens per chunk',
+                dataKey: 'numTokensPerChunk',
+                min: 1,
+                max: 32768,
+                step: 1,
+            },
+            {
+                type: 'number',
+                label: 'Overlap (in %)',
+                dataKey: 'overlap',
+                min: 0,
+                max: 100,
+                step: 1,
+            },
+        ];
+    }
+    getBody() {
+        return dedent `
+      Model: ${this.data.model}
+      Token Count: ${this.data.numTokensPerChunk.toLocaleString()}
+      ${this.data.overlap ? `Overlap: ${this.data.overlap}%` : ''}
+    `;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+          Splits the input text into an array of chunks based on an approximate GPT token count per chunk.
+
+          The "overlap" setting allows you to partially overlap the chunks for redundancy.
+
+          Can also be used for string length truncation by only using the \`First\` or \`Last\` outputs of the node.
+        `,
+            infoBoxTitle: 'Chunk Node',
+            contextMenuTitle: 'Chunk',
+            group: ['Text'],
+        };
+    }
+    async process(inputs, context) {
+        const input = coerceType(inputs['input'], 'string');
+        const overlapPercent = this.chartNode.data.overlap / 100;
+        const chunked = await chunkStringByTokenCount(context.tokenizer, {
+            node: this.chartNode,
+            endpoint: undefined,
+            model: this.data.model,
+        }, input, this.chartNode.data.numTokensPerChunk, overlapPercent);
+        return {
+            ['chunks']: {
+                type: 'string[]',
+                value: chunked,
+            },
+            ['first']: {
+                type: 'string',
+                value: chunked[0],
+            },
+            ['last']: {
+                type: 'string',
+                value: chunked.at(-1),
+            },
+            ['indexes']: {
+                type: 'number[]',
+                value: chunked.map((_, i) => i + 1),
+            },
+            ['count']: {
+                type: 'number',
+                value: chunked.length,
+            },
+        };
+    }
+}
+export const chunkNode = nodeDefinition(ChunkNodeImpl, 'Chunk');
+export async function chunkStringByTokenCount(tokenizer, tokenizerInfo, input, targetTokenCount, overlapPercent) {
+    overlapPercent = Number.isNaN(overlapPercent) ? 0 : Math.max(0, Math.min(1, overlapPercent));
+    const chunks = [];
+    const guess = Math.floor(targetTokenCount * (input.length / (await tokenizer.getTokenCountForString(input, tokenizerInfo))));
+    let remaining = input;
+    while (remaining.length > 0) {
+        chunks.push(remaining.slice(0, guess));
+        remaining = remaining.slice(guess - Math.floor(guess * overlapPercent));
+    }
+    return chunks;
+}

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

@@ -0,0 +1,104 @@
+import { NodeImpl } from '../NodeImpl.js';
+import {} from '../NodeBase.js';
+import { unwrapDataValue } from '../DataValue.js';
+import { nanoid } from 'nanoid/non-secure';
+import {} from '../GraphProcessor.js';
+import { dedent } from 'ts-dedent';
+import { nodeDefinition } from '../NodeDefinition.js';
+export class CoalesceNodeImpl extends NodeImpl {
+    static create = () => {
+        const chartNode = {
+            type: 'coalesce',
+            title: 'Coalesce',
+            id: nanoid(),
+            data: {},
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 150,
+            },
+        };
+        return chartNode;
+    };
+    getInputDefinitions(connections) {
+        const inputs = [];
+        const inputCount = this.#getInputPortCount(connections);
+        inputs.push({
+            dataType: 'boolean',
+            id: 'conditional',
+            title: 'Conditional',
+        });
+        for (let i = 1; i <= inputCount; i++) {
+            inputs.push({
+                dataType: 'any',
+                id: `input${i}`,
+                title: `Input ${i}`,
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'any',
+                id: 'output',
+                title: 'Output',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Takes in any number of inputs and outputs the first value that exists. Useful for consolidating branches after a Match node. This node can also "consume" the "Not Ran" value.
+      `,
+            infoBoxTitle: 'Coalesce Node',
+            contextMenuTitle: 'Coalesce',
+            group: ['Logic'],
+        };
+    }
+    #getInputPortCount(connections) {
+        const inputNodeId = this.chartNode.id;
+        const inputConnections = connections.filter((connection) => connection.inputNodeId === inputNodeId && connection.inputId.startsWith('input'));
+        let maxInputNumber = 0;
+        for (const connection of inputConnections) {
+            const messageNumber = parseInt(connection.inputId.replace('input', ''), 10);
+            if (messageNumber > maxInputNumber) {
+                maxInputNumber = messageNumber;
+            }
+        }
+        return maxInputNumber + 1;
+    }
+    async process(inputData) {
+        const conditional = inputData['conditional'];
+        // This lets the coalesce actually be control-flow-excluded itself, because otherwise
+        // the input control-flow-excluded are consumed.
+        if (conditional?.type === 'control-flow-excluded') {
+            return {
+                ['output']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            };
+        }
+        const inputCount = Object.keys(inputData).filter((key) => key.startsWith('input')).length;
+        const okInputValues = [];
+        for (let i = 1; i <= inputCount; i++) {
+            const inputValue = inputData[`input${i}`];
+            if (inputValue && inputValue.type !== 'control-flow-excluded' && unwrapDataValue(inputValue) != null) {
+                okInputValues.push(inputValue);
+            }
+        }
+        if (okInputValues.length === 0) {
+            return {
+                ['output']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            };
+        }
+        return {
+            ['output']: okInputValues[0],
+        };
+    }
+}
+export const coalesceNode = nodeDefinition(CoalesceNodeImpl, 'Coalesce');

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

@@ -0,0 +1,136 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import {} from '../DataValue.js';
+import { dedent } from 'ts-dedent';
+import {} from '../EditorDefinition.js';
+import {} from '../NodeBodySpec.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+const maskInput = (name) => name.trim().replace(/[^a-zA-Z0-9_]/g, '_');
+const asValidNames = (names) => Array(...new Set(names.map(maskInput))).filter(Boolean);
+export class CodeNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'code',
+            title: 'Code',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+            },
+            data: {
+                code: dedent `
+          // This is a code node, you can write and JS in here and it will be executed.
+          // Inputs are accessible via an object \`inputs\` and data is typed (i.e. inputs.foo.type, inputs.foo.value)
+          // Return an object with named outputs that match the output names specified in the node's config.
+          // Output values must by typed as well (e.g. { bar: { type: 'string', value: 'bar' } }
+          return {
+            output1: {
+              type: inputs.input1.type,
+              value: inputs.input1.value
+            }
+          };
+        `,
+                inputNames: 'input1',
+                outputNames: 'output1',
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputNames = this.data.inputNames
+            ? Array.isArray(this.data.inputNames)
+                ? this.data.inputNames
+                : [this.data.inputNames]
+            : [];
+        return asValidNames(inputNames).map((inputName) => {
+            return {
+                type: 'any',
+                id: inputName.trim(),
+                title: inputName.trim(),
+                dataType: 'string',
+                required: false,
+            };
+        });
+    }
+    getOutputDefinitions() {
+        const outputNames = this.data.outputNames
+            ? Array.isArray(this.data.outputNames)
+                ? this.data.outputNames
+                : [this.data.outputNames]
+            : [];
+        return asValidNames(outputNames).map((outputName) => {
+            return {
+                id: outputName.trim(),
+                title: outputName.trim(),
+                dataType: 'any',
+            };
+        });
+    }
+    getEditors() {
+        return [
+            {
+                type: 'custom',
+                customEditorId: 'CodeNodeAIAssist',
+                label: 'AI Assist',
+            },
+            {
+                type: 'code',
+                label: 'Code',
+                dataKey: 'code',
+                language: 'javascript',
+            },
+            {
+                type: 'stringList',
+                label: 'Inputs',
+                dataKey: 'inputNames',
+            },
+            {
+                type: 'stringList',
+                label: 'Outputs',
+                dataKey: 'outputNames',
+            },
+        ];
+    }
+    getBody() {
+        const trimmed = this.data.code
+            .split('\n')
+            .slice(0, 15)
+            .map((line) => (line.length > 50 ? line.slice(0, 50) + '...' : line))
+            .join('\n')
+            .trim();
+        return {
+            type: 'colorized',
+            text: trimmed,
+            language: 'javascript',
+            fontSize: 12,
+            fontFamily: 'monospace',
+        };
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Executes a piece of JavaScript code. See the Rivet Documentation for more information on how to write code for the Code Node.
+      `,
+            infoBoxTitle: 'Code Node',
+            contextMenuTitle: 'Code',
+            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);
+        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.');
+        }
+        const missingOutputs = this.getOutputDefinitions().filter((output) => !(output.id in outputs));
+        if (missingOutputs.length > 0) {
+            throw new Error(`Code node must return an object with output values for all outputs. To not run an output, return { "type": "control-flow-excluded", "value": undefiend }. To return undefined, return { "type": "any", "value": undefined }. Missing: ${missingOutputs
+                .map((output) => output.id)
+                .join(', ')}`);
+        }
+        return outputs;
+    }
+}
+export const codeNode = nodeDefinition(CodeNodeImpl, 'Code');

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

@@ -0,0 +1,69 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import {} from '../DataValue.js';
+import { dedent } from 'ts-dedent';
+import {} from '../EditorDefinition.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+export class CommentNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'comment',
+            title: 'Comment',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 600,
+            },
+            data: {
+                text: '',
+                height: 600,
+                color: 'rgba(255,255,255,1)',
+                backgroundColor: 'rgba(0,0,0,0.05)',
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        return [];
+    }
+    getOutputDefinitions() {
+        return [];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'color',
+                label: 'Color',
+                dataKey: 'color',
+            },
+            {
+                type: 'color',
+                label: 'Background Color',
+                dataKey: 'backgroundColor',
+            },
+            {
+                type: 'code',
+                label: 'Text',
+                dataKey: 'text',
+                language: 'markdown',
+                theme: 'vs-dark',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        A comment node is a node that does nothing. It is useful for adding notes to a graph.
+      `,
+            infoBoxTitle: 'Comment Node',
+            contextMenuTitle: 'Comment',
+            group: ['Advanced'],
+        };
+    }
+    async process() {
+        return {};
+    }
+}
+export const commentNode = nodeDefinition(CommentNodeImpl, 'Comment');

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

@@ -0,0 +1,138 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import {} from '../GraphProcessor.js';
+import {} from '../../index.js';
+import { isEqual } from 'lodash-es';
+import { match } from 'ts-pattern';
+import { dedent } from 'ts-dedent';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { coerceType, coerceTypeOptional } from '../../utils/coerceType.js';
+export class CompareNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'compare',
+            title: 'Compare',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 160,
+            },
+            data: {
+                comparisonFunction: '==',
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = [
+            {
+                dataType: 'any',
+                id: 'a',
+                title: 'A',
+            },
+            {
+                dataType: 'any',
+                id: 'b',
+                title: 'B',
+            },
+        ];
+        if (this.data.useComparisonFunctionInput) {
+            inputs.push({
+                dataType: 'string',
+                id: 'comparisonFunction',
+                title: 'Comparison Function',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'boolean',
+                id: 'output',
+                title: 'Output',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'dropdown',
+                label: 'Comparison Function',
+                dataKey: 'comparisonFunction',
+                options: [
+                    { label: '==', value: '==' },
+                    { label: '!=', value: '!=' },
+                    { label: '<', value: '<' },
+                    { label: '<=', value: '<=' },
+                    { label: '>', value: '>' },
+                    { label: '>=', value: '>=' },
+                    { label: 'and', value: 'and' },
+                    { label: 'or', value: 'or' },
+                    { label: 'xor', value: 'xor' },
+                    { label: 'nand', value: 'nand' },
+                    { label: 'nor', value: 'nor' },
+                    { label: 'xnor', value: 'xnor' },
+                ],
+                useInputToggleDataKey: 'useComparisonFunctionInput',
+            },
+        ];
+    }
+    getBody() {
+        return this.data.useComparisonFunctionInput ? 'A (Comparison Function) B' : `A ${this.data.comparisonFunction} B`;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Compares two values using the configured operator and outputs the result.
+
+        If the data types of the values do not match, then the B value is converted to the type of the A value.
+      `,
+            infoBoxTitle: 'Compare Node',
+            contextMenuTitle: 'Compare',
+            group: ['Logic'],
+        };
+    }
+    async process(inputs) {
+        const comparisonFunction = (this.data.useComparisonFunctionInput
+            ? coerceType(inputs['comparisonFunction'], 'string')
+            : this.data.comparisonFunction);
+        const inputA = inputs['a'];
+        const inputB = inputs['b'];
+        if (!inputA) {
+            return {
+                ['output']: {
+                    type: 'boolean',
+                    value: match(comparisonFunction)
+                        .with('==', () => !inputB)
+                        .with('!=', () => !!inputB)
+                        .otherwise(() => false),
+                },
+            };
+        }
+        const value1 = inputA.value;
+        const value2 = inputB?.type !== inputA.type ? coerceTypeOptional(inputB, inputA.type) : inputB.value;
+        return {
+            ['output']: {
+                type: 'boolean',
+                value: match(comparisonFunction)
+                    .with('==', () => isEqual(value1, value2))
+                    .with('!=', () => !isEqual(value1, value2))
+                    .with('<', () => value1 < value2)
+                    .with('>', () => value1 > value2)
+                    .with('<=', () => value1 <= value2)
+                    .with('>=', () => value1 >= value2)
+                    .with('and', () => !!(value1 && value2))
+                    .with('or', () => !!(value1 || value2))
+                    .with('xor', () => !!(value1 ? !value2 : value2))
+                    .with('nand', () => !(value1 && value2))
+                    .with('nor', () => !(value1 || value2))
+                    .with('xnor', () => !(value1 ? !value2 : value2))
+                    .exhaustive(),
+            },
+        };
+    }
+}
+export const compareNode = nodeDefinition(CompareNodeImpl, 'Compare');