@alpic80/rivet-core 1.19.1-aidon.1

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

@@ -0,0 +1,101 @@
+import { NodeImpl } from '../NodeImpl.js';
+import { coerceType, dedent, getInputOrData, handleEscapeCharacters, newId } from '../../utils/index.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+export class SplitNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: newId(),
+            type: 'split',
+            title: 'Split Text',
+            visualData: { x: 0, y: 0, width: 250 },
+            data: {
+                delimiter: ',',
+                regex: false,
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputs = [
+            {
+                id: 'string',
+                title: 'String',
+                dataType: 'string',
+            },
+        ];
+        if (this.data.useDelimiterInput) {
+            inputs.push({
+                id: 'delimiter',
+                title: 'Delimiter',
+                dataType: 'string',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'splitString',
+                title: 'Split',
+                dataType: 'string[]',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Splits a string by the provided delimiter.
+      `,
+            infoBoxTitle: 'Split Text Node',
+            contextMenuTitle: 'Split Text',
+            group: ['Text'],
+        };
+    }
+    getEditors() {
+        return [
+            {
+                type: 'toggle',
+                label: 'Regex',
+                dataKey: 'regex',
+            },
+            {
+                type: 'code',
+                label: 'Delimiter',
+                language: 'plaintext',
+                dataKey: 'delimiter',
+                useInputToggleDataKey: 'useDelimiterInput',
+            },
+        ];
+    }
+    getBody() {
+        if (this.data.useDelimiterInput) {
+            return '(Delimiter from input)';
+        }
+        const normalized = handleEscapeCharacters(this.data.delimiter);
+        if (normalized === '\n') {
+            return '(New line)';
+        }
+        if (normalized === '\r\n') {
+            return '(New line (windows))';
+        }
+        if (normalized === '\t') {
+            return '(Tab)';
+        }
+        if (normalized === ' ') {
+            return '(Space)';
+        }
+        return normalized;
+    }
+    async process(inputs, context) {
+        const delimiter = getInputOrData(this.data, inputs, 'delimiter');
+        const normalizedDelimiter = this.data.regex ? new RegExp(delimiter) : handleEscapeCharacters(delimiter);
+        const stringToSplit = coerceType(inputs['string'], 'string');
+        const splitString = stringToSplit.split(normalizedDelimiter);
+        return {
+            ['splitString']: {
+                type: 'string[]',
+                value: splitString,
+            },
+        };
+    }
+}
+export const splitNode = nodeDefinition(SplitNodeImpl, 'Split String');

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

@@ -0,0 +1,181 @@
+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 '../../index.js';
+import { dedent } from 'ts-dedent';
+import { getError } from '../../utils/errors.js';
+import { match } from 'ts-pattern';
+export class SubGraphNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'subGraph',
+            title: 'Subgraph',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 300,
+            },
+            data: {
+                graphId: '',
+                useErrorOutput: false,
+                useAsGraphPartialOutput: false,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions(_connections, _nodes, project) {
+        const graph = project.graphs[this.data.graphId];
+        if (!graph) {
+            return [];
+        }
+        const inputNodes = graph.nodes.filter((node) => node.type === 'graphInput');
+        const inputIds = [...new Set(inputNodes.map((node) => node.data.id))].sort();
+        return inputIds.map((id) => ({
+            id: id,
+            title: id,
+            dataType: inputNodes.find((node) => node.data.id === id).data.dataType,
+        }));
+    }
+    getGraphOutputs(project) {
+        const graph = project.graphs[this.data.graphId];
+        if (!graph) {
+            return [];
+        }
+        const outputNodes = graph.nodes.filter((node) => node.type === 'graphOutput');
+        const outputIds = [...new Set(outputNodes.map((node) => node.data.id))].sort();
+        const outputs = outputIds.map((id) => ({
+            id: id,
+            title: id,
+            dataType: outputNodes.find((node) => node.data.id === id).data.dataType,
+        }));
+        return outputs;
+    }
+    getOutputDefinitions(_connections, _nodes, project) {
+        const outputs = [];
+        outputs.push(...this.getGraphOutputs(project));
+        if (this.data.useErrorOutput) {
+            outputs.push({
+                id: 'error',
+                title: 'Error',
+                dataType: 'string',
+            });
+        }
+        return outputs;
+    }
+    getEditors(context) {
+        const definitions = [
+            {
+                type: 'graphSelector',
+                label: 'Graph',
+                dataKey: 'graphId',
+            },
+            {
+                type: 'toggle',
+                label: 'Use Error Output',
+                dataKey: 'useErrorOutput',
+            },
+        ];
+        if (this.data.graphId) {
+            const graph = context.project.graphs[this.data.graphId];
+            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 another graph. Inputs and outputs are defined by Graph Input and Graph Output nodes within the subgraph.
+      `,
+            infoBoxTitle: 'Subgraph Node',
+            contextMenuTitle: 'Subgraph',
+            group: ['Advanced'],
+        };
+    }
+    async process(inputs, context) {
+        const { project } = context;
+        if (!project) {
+            throw new Error('SubGraphNode requires a project to be set in the context.');
+        }
+        const graph = project.graphs[this.data.graphId];
+        if (!graph) {
+            throw new Error(`SubGraphNode requires a graph with id ${this.data.graphId} to be present in the project.`);
+        }
+        const inputNodes = graph.nodes.filter((node) => node.type === 'graphInput');
+        const inputIds = [...new Set(inputNodes.map((node) => node.data.id))].sort();
+        const inputData = inputIds.reduce((obj, id) => {
+            if (inputs[id] != null) {
+                return {
+                    ...obj,
+                    [id]: inputs[id],
+                };
+            }
+            if (this.data.inputData?.[id] != null) {
+                return {
+                    ...obj,
+                    [id]: this.data.inputData[id],
+                };
+            }
+            return obj;
+        }, {});
+        const subGraphProcessor = context.createSubProcessor(this.data.graphId, { signal: context.signal });
+        try {
+            const startTime = Date.now();
+            const outputs = await subGraphProcessor.processGraph(context, inputData, context.contextValues);
+            const duration = Date.now() - startTime;
+            if (this.data.useErrorOutput) {
+                outputs['error'] = {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                };
+            }
+            if (outputs['duration'] == null) {
+                outputs['duration'] = {
+                    type: 'number',
+                    value: duration,
+                };
+            }
+            return outputs;
+        }
+        catch (err) {
+            if (!this.data.useErrorOutput) {
+                throw err;
+            }
+            const outputs = this.getGraphOutputs(context.project).reduce((obj, output) => ({
+                ...obj,
+                [output.id]: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            }), {});
+            outputs['error'] = {
+                type: 'string',
+                value: getError(err).message,
+            };
+            return outputs;
+        }
+    }
+}
+export const subGraphNode = nodeDefinition(SubGraphNodeImpl, 'Subgraph');

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

@@ -0,0 +1,97 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../DataValue.js';
+import {} from '../../index.js';
+import { dedent } from 'ts-dedent';
+import { coerceTypeOptional } from '../../utils/coerceType.js';
+import { interpolate } from '../../utils/interpolation.js';
+export class TextNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'text',
+            title: 'Text',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 300,
+            },
+            data: {
+                text: '{{input}}',
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        // Extract inputs from text, everything like {{input}}
+        const inputNames = [...new Set(this.chartNode.data.text.match(/\{\{([^}]+)\}\}/g))];
+        return (inputNames?.map((inputName) => {
+            return {
+                type: 'string',
+                // id and title should not have the {{ and }}
+                id: inputName.slice(2, -2),
+                title: inputName.slice(2, -2),
+                dataType: 'string',
+                required: false,
+            };
+        }) ?? []);
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'output',
+                title: 'Output',
+                dataType: 'string',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'code',
+                label: 'Text',
+                dataKey: 'text',
+                language: 'prompt-interpolation-markdown',
+                theme: 'prompt-interpolation',
+            },
+        ];
+    }
+    getBody() {
+        const truncated = this.data.text.split('\n').slice(0, 15).join('\n').trim();
+        return {
+            type: 'colorized',
+            language: 'prompt-interpolation-markdown',
+            theme: 'prompt-interpolation',
+            text: truncated,
+        };
+    }
+    async process(inputs) {
+        const inputMap = Object.keys(inputs).reduce((acc, key) => {
+            const stringValue = coerceTypeOptional(inputs[key], 'string') ?? '';
+            acc[key] = stringValue;
+            return acc;
+        }, {});
+        const outputValue = interpolate(this.chartNode.data.text, inputMap);
+        return {
+            output: {
+                type: 'string',
+                value: outputValue,
+            },
+        };
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Outputs a string of text. It can also interpolate values using <span style="color: var(--primary)">{{tags}}</span>.
+
+        The inputs are dynamic based on the interpolation tags.
+      `,
+            contextMenuTitle: 'Text',
+            infoBoxTitle: 'Text Node',
+            group: ['Common', 'Text'],
+        };
+    }
+}
+export const textNode = nodeDefinition(TextNodeImpl, 'Text');

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

@@ -0,0 +1,78 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../GraphProcessor.js';
+import {} from '../../index.js';
+import { dedent } from 'ts-dedent';
+import { coerceType } from '../../utils/coerceType.js';
+export class ToJsonNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'toJson',
+            title: 'To JSON',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 175,
+            },
+            data: {
+                indented: true,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        return [
+            {
+                id: 'data',
+                title: 'Data',
+                dataType: 'any',
+                required: true,
+            },
+        ];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'json',
+                title: 'JSON',
+                dataType: 'string',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'toggle',
+                label: 'Indented',
+                dataKey: 'indented',
+            },
+        ];
+    }
+    getBody() {
+        return this.data.indented ? 'Indented' : 'Not indented';
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Turns the input value into its JSON equivalent (stringifies the value).
+      `,
+            infoBoxTitle: 'To JSON Node',
+            contextMenuTitle: 'To JSON',
+            group: ['Text'],
+        };
+    }
+    async process(inputs) {
+        const data = coerceType(inputs['data'], 'any');
+        const toJson = this.data.indented ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+        return {
+            ['json']: {
+                type: 'string',
+                value: toJson,
+            },
+        };
+    }
+}
+export const toJsonNode = nodeDefinition(ToJsonNodeImpl, 'To JSON');

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

@@ -0,0 +1,68 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+// @ts-ignore
+import yaml from 'yaml';
+import {} from '../GraphProcessor.js';
+import { coerceType } from '../../utils/index.js';
+import { dedent } from 'ts-dedent';
+import { nodeDefinition } from '../NodeDefinition.js';
+export class ToYamlNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'toYaml',
+            title: 'To YAML',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 175,
+            },
+            data: {},
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        return [
+            {
+                id: 'object',
+                title: 'Object',
+                dataType: 'object',
+                required: true,
+            },
+        ];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'yaml',
+                title: 'YAML',
+                dataType: 'string',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Turns the input object into YAML text.
+      `,
+            infoBoxTitle: 'To YAML Node',
+            contextMenuTitle: 'To YAML',
+            group: ['Text'],
+        };
+    }
+    async process(inputs) {
+        const object = coerceType(inputs['object'], 'object');
+        const toYaml = yaml.stringify(object, null, {
+            indent: 2,
+            aliasDuplicateObjects: false,
+        });
+        return {
+            ['yaml']: {
+                type: 'string',
+                value: toYaml,
+            },
+        };
+    }
+}
+export const toYamlNode = nodeDefinition(ToYamlNodeImpl, 'To YAML');

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

@@ -0,0 +1,120 @@
+import {} from '../../model/NodeBase.js';
+import { NodeImpl } from '../../model/NodeImpl.js';
+import { nanoid } from 'nanoid/non-secure';
+import {} from '../../index.js';
+import { dedent } from 'ts-dedent';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { coerceType } from '../../utils/coerceType.js';
+import { getInputOrData } from '../../utils/index.js';
+export class TrimChatMessagesNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'trimChatMessages',
+            title: 'Trim Chat Messages',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 200,
+            },
+            data: {
+                maxTokenCount: 4096,
+                removeFromBeginning: true,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = [
+            {
+                id: 'input',
+                title: 'Input',
+                dataType: 'chat-message[]',
+            },
+        ];
+        if (this.data.useMaxTokenCountInput) {
+            inputs.push({
+                id: 'maxTokenCount',
+                title: 'Max Token Count',
+                dataType: 'number',
+            });
+        }
+        if (this.data.useRemoveFromBeginningInput) {
+            inputs.push({
+                id: 'removeFromBeginning',
+                title: 'Remove From Beginning',
+                dataType: 'boolean',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'trimmed',
+                title: 'Trimmed',
+                dataType: 'chat-message[]',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'number',
+                label: 'Max Token Count',
+                dataKey: 'maxTokenCount',
+                useInputToggleDataKey: 'useMaxTokenCountInput',
+            },
+            {
+                type: 'toggle',
+                label: 'Remove From Beginning',
+                dataKey: 'removeFromBeginning',
+                useInputToggleDataKey: 'useRemoveFromBeginningInput',
+            },
+        ];
+    }
+    getBody() {
+        return dedent `
+      Max Token Count: ${this.data.useMaxTokenCountInput ? '(From Input)' : this.data.maxTokenCount}
+      Remove From Beginning: ${this.data.useRemoveFromBeginningInput ? '(From Input)' : this.data.removeFromBeginning ? 'Yes' : 'No'}
+    `;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Takes an array of chat messages, and slices messages from the beginning or the end of the list until the total length of the messages is under the configured token length.
+
+        Useful for setting up infinite message chains that stay under the LLM context limit.
+      `,
+            infoBoxTitle: 'Trim Chat Messages Node',
+            contextMenuTitle: 'Trim Chat Messages',
+            group: ['AI'],
+        };
+    }
+    async process(inputs, context) {
+        const input = coerceType(inputs['input'], 'chat-message[]');
+        const maxTokenCount = getInputOrData(this.data, inputs, 'maxTokenCount', 'number');
+        const removeFromBeginning = getInputOrData(this.data, inputs, 'removeFromBeginning', 'boolean');
+        const trimmedMessages = [...input];
+        const tokenizerInfo = {
+            node: this.chartNode,
+        };
+        let tokenCount = await context.tokenizer.getTokenCountForMessages(trimmedMessages, undefined, tokenizerInfo);
+        while (tokenCount > maxTokenCount) {
+            if (removeFromBeginning) {
+                trimmedMessages.shift();
+            }
+            else {
+                trimmedMessages.pop();
+            }
+            tokenCount = await context.tokenizer.getTokenCountForMessages(trimmedMessages, undefined, tokenizerInfo);
+        }
+        return {
+            ['trimmed']: {
+                type: 'chat-message[]',
+                value: trimmedMessages,
+            },
+        };
+    }
+}
+export const trimChatMessagesNode = nodeDefinition(TrimChatMessagesNodeImpl, 'Trim Chat Messages');