@alpic80/rivet-core 1.19.1-aidon.1

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

@@ -0,0 +1,89 @@
+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 { dedent } from 'ts-dedent';
+export class PopNodeImpl extends NodeImpl {
+    static create() {
+        const baseNode = {
+            type: 'pop',
+            title: 'Pop',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 200,
+            },
+            data: {},
+        };
+        return baseNode;
+    }
+    getInputDefinitions() {
+        return [
+            {
+                dataType: 'any[]',
+                id: 'array',
+                title: 'Array',
+                coerced: false,
+            },
+        ];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'any',
+                id: 'lastItem',
+                title: this.data.fromFront ? 'First' : 'Last',
+            },
+            {
+                dataType: 'any',
+                id: 'restOfArray',
+                title: 'Rest',
+            },
+        ];
+    }
+    getEditors(_context) {
+        return [
+            {
+                label: 'Pop from front',
+                type: 'toggle',
+                dataKey: 'fromFront',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Pops the last value off the input array and outputs the new array and the popped value.
+
+        Can also be used to just extract the last value from an array.
+      `,
+            infoBoxTitle: 'Pop Node',
+            contextMenuTitle: 'Pop',
+            group: ['Lists'],
+        };
+    }
+    getBody(_context) {
+        return this.data.fromFront ? 'From front' : 'From back';
+    }
+    async process(inputs) {
+        const inputArray = inputs['array']?.value;
+        if (!Array.isArray(inputArray) || inputArray.length === 0) {
+            throw new Error('Input array is empty or not an array');
+        }
+        const lastItem = this.data.fromFront ? inputArray[0] : inputArray[inputArray.length - 1];
+        const rest = this.data.fromFront ? inputArray.slice(1) : inputArray.slice(0, inputArray.length - 1);
+        return {
+            ['lastItem']: {
+                type: 'any',
+                value: lastItem,
+            },
+            ['restOfArray']: {
+                type: 'any[]',
+                value: rest,
+            },
+        };
+    }
+}
+export const popNode = nodeDefinition(PopNodeImpl, 'Pop');

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

@@ -0,0 +1,227 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../../index.js';
+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 { match } from 'ts-pattern';
+export class PromptNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'prompt',
+            title: 'Prompt',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                type: 'user',
+                useTypeInput: false,
+                promptText: '{{input}}',
+                enableFunctionCall: false,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        let inputs = [];
+        if (this.data.enableFunctionCall) {
+            inputs.push({
+                id: 'function-call',
+                title: 'Function Call',
+                dataType: 'object',
+            });
+        }
+        if (this.data.useTypeInput) {
+            inputs.push({
+                id: 'type',
+                title: 'Type',
+                dataType: 'string',
+            });
+        }
+        if (this.data.useNameInput) {
+            inputs.push({
+                id: 'name',
+                title: 'Name/ID',
+                dataType: 'string',
+            });
+        }
+        // Extract inputs from promptText, everything like {{input}}
+        const inputNames = [...new Set(this.chartNode.data.promptText.match(/\{\{([^}]+)\}\}/g))];
+        inputs = [
+            ...inputs,
+            ...(inputNames?.map((inputName) => {
+                return {
+                    // id and title should not have the {{ and }}
+                    id: inputName.slice(2, -2),
+                    title: inputName.slice(2, -2),
+                    dataType: 'string',
+                    required: false,
+                };
+            }) ?? []),
+        ];
+        return inputs;
+    }
+    getOutputDefinitions() {
+        const outputs = [
+            {
+                id: 'output',
+                title: 'Output',
+                dataType: 'chat-message',
+            },
+        ];
+        if (this.chartNode.data.computeTokenCount) {
+            outputs.push({
+                id: 'tokenCount',
+                title: 'Token Count',
+                dataType: 'number',
+            });
+        }
+        return outputs;
+    }
+    getEditors() {
+        return [
+            {
+                type: 'dropdown',
+                label: 'Type',
+                options: [
+                    { value: 'system', label: 'System' },
+                    { value: 'user', label: 'User' },
+                    { value: 'assistant', label: 'Assistant' },
+                    { value: 'function', label: 'Function' },
+                ],
+                dataKey: 'type',
+                useInputToggleDataKey: 'useTypeInput',
+            },
+            {
+                type: 'string',
+                label: 'Name',
+                dataKey: 'name',
+                useInputToggleDataKey: 'useNameInput',
+                hideIf: (data) => data.type !== 'function',
+                helperMessage: 'For OpenAI, this is the tool call ID. Otherwise, it is the name of the function that is outputting the message.',
+            },
+            {
+                type: 'toggle',
+                label: 'Enable Function Call',
+                dataKey: 'enableFunctionCall',
+                hideIf: (data) => data.type !== 'assistant',
+            },
+            {
+                type: 'toggle',
+                label: 'Compute Token Count',
+                dataKey: 'computeTokenCount',
+            },
+            {
+                type: 'code',
+                label: 'Prompt Text',
+                dataKey: 'promptText',
+                language: 'prompt-interpolation-markdown',
+                theme: 'prompt-interpolation',
+            },
+        ];
+    }
+    getBody() {
+        return [
+            {
+                type: 'markdown',
+                text: dedent `
+          _${typeDisplay[this.data.type]}${this.data.name ? ` (${this.data.name})` : ''}_
+      `,
+            },
+            {
+                type: 'colorized',
+                text: this.data.promptText.split('\n').slice(0, 15).join('\n').trim(),
+                language: 'prompt-interpolation-markdown',
+                theme: 'prompt-interpolation',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Outputs a chat message, which is a string of text with an attached "type" saying who sent the message (User, Assistant, System) and optionally an attached "name".
+
+        Also provides the same <span style="color: var(--primary)">{{interpolation}}</span> capabilities as a Text node.
+
+        Can change one chat message type into another chat message type. For example, changing a User message into a System message.
+      `,
+            infoBoxTitle: 'Prompt Node',
+            contextMenuTitle: 'Prompt',
+            group: ['Text'],
+        };
+    }
+    async process(inputs, context) {
+        const inputMap = mapValues(inputs, (input) => coerceType(input, 'string'));
+        const outputValue = interpolate(this.chartNode.data.promptText, inputMap);
+        const type = getInputOrData(this.data, inputs, 'type', 'string');
+        if (['assistant', 'system', 'user', 'function'].includes(type) === false) {
+            throw new Error(`Invalid type: ${type}`);
+        }
+        const message = match(type)
+            .with('system', (type) => ({
+            type,
+            message: outputValue,
+        }))
+            .with('user', (type) => ({
+            type,
+            message: outputValue,
+        }))
+            .with('assistant', (type) => {
+            let functionCall = this.data.enableFunctionCall
+                ? coerceTypeOptional(inputs['function-call'], 'object')
+                : undefined;
+            // If no name is specified, ignore the function call
+            if (!functionCall?.name || !functionCall?.arguments) {
+                functionCall = undefined;
+            }
+            // GPT is weird - the arguments should be a stringified JSON object https://platform.openai.com/docs/api-reference/chat/create
+            if (functionCall?.arguments && typeof functionCall.arguments !== 'string') {
+                functionCall.arguments = JSON.stringify(functionCall.arguments);
+            }
+            return {
+                type,
+                message: outputValue,
+                function_call: functionCall,
+                function_calls: functionCall ? [functionCall] : undefined,
+            };
+        })
+            .with('function', (type) => ({
+            type,
+            message: outputValue,
+            name: getInputOrData(this.data, inputs, 'name', 'string'),
+        }))
+            .otherwise(() => {
+            throw new Error(`Invalid chat-message type: ${type}`);
+        });
+        const outputs = {
+            ['output']: {
+                type: 'chat-message',
+                value: message,
+            },
+        };
+        if (this.chartNode.data.computeTokenCount) {
+            const tokenCount = await context.tokenizer.getTokenCountForMessages([message], undefined, {
+                node: this.chartNode,
+            });
+            outputs['tokenCount'] = {
+                type: 'number',
+                value: tokenCount,
+            };
+        }
+        return outputs;
+    }
+}
+export const promptNode = nodeDefinition(PromptNodeImpl, 'Prompt');
+const typeDisplay = {
+    assistant: 'Assistant',
+    system: 'System',
+    user: 'User',
+    function: 'Function',
+};

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

@@ -0,0 +1,86 @@
+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 '../ProcessContext.js';
+import { dedent } from 'ts-dedent';
+import {} from '../../index.js';
+export class RaceInputsNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'raceInputs',
+            title: 'Race Inputs',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 300,
+            },
+            data: {},
+        };
+        return chartNode;
+    }
+    #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;
+    }
+    getInputDefinitions(connections) {
+        const inputs = [];
+        const inputCount = this.#getInputPortCount(connections);
+        for (let i = 1; i <= inputCount; i++) {
+            inputs.push({
+                dataType: 'any',
+                id: `input${i}`,
+                title: `Input ${i}`,
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'result',
+                title: 'Result',
+                dataType: 'any',
+            },
+        ];
+    }
+    getEditors() {
+        return [];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Takes in multiple inputs and outputs the value of the first one to finish. The other inputs are cancelled.
+      `,
+            infoBoxTitle: 'Race Inputs Node',
+            contextMenuTitle: 'Race Inputs',
+            group: ['Logic'],
+        };
+    }
+    async process(inputs, context) {
+        // 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) {
+            return {
+                ['result']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            };
+        }
+        return {
+            ['result']: value[1],
+        };
+    }
+}
+export const raceInputsNode = nodeDefinition(RaceInputsNodeImpl, 'Race Inputs');

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

@@ -0,0 +1,84 @@
+import {} from '../NodeBase.js';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../DataValue.js';
+import { nanoid } from 'nanoid/non-secure';
+import {} from '../GraphProcessor.js';
+import { coerceType } from '../../utils/coerceType.js';
+import {} from '../ProcessContext.js';
+import { dedent } from 'ts-dedent';
+import {} from '../EditorDefinition.js';
+import {} from '../NodeBodySpec.js';
+export class RaiseEventNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: nanoid(),
+            type: 'raiseEvent',
+            title: 'Raise Event',
+            visualData: { x: 0, y: 0, width: 150 },
+            data: {
+                eventName: 'toast',
+                useEventNameInput: false,
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [];
+        if (this.chartNode.data.useEventNameInput) {
+            inputDefinitions.push({
+                id: 'eventName',
+                title: 'Event Name',
+                dataType: 'string',
+            });
+        }
+        inputDefinitions.push({
+            id: 'data',
+            title: 'Data',
+            dataType: 'any',
+        });
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'result',
+                title: 'Result',
+                dataType: 'any',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                label: 'Event Name',
+                dataKey: 'eventName',
+                useInputToggleDataKey: 'useEventNameInput',
+            },
+        ];
+    }
+    getBody() {
+        return this.data.useEventNameInput ? '(Using Input)' : this.data.eventName;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Raises an event that the host project or a 'Wait For Event' node can listen for.
+      `,
+            infoBoxTitle: 'Raise Event Node',
+            contextMenuTitle: 'Raise Event',
+            group: ['Advanced'],
+        };
+    }
+    async process(inputs, context) {
+        const eventName = this.chartNode.data.useEventNameInput
+            ? coerceType(inputs['eventName'], 'string')
+            : this.chartNode.data.eventName;
+        const eventData = inputs['data'];
+        context.raiseEvent(eventName, eventData);
+        return {
+            result: eventData,
+        };
+    }
+}
+export const raiseEventNode = nodeDefinition(RaiseEventNodeImpl, 'Raise Event');

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

@@ -0,0 +1,106 @@
+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 { coerceTypeOptional } from '../../utils/coerceType.js';
+export class RandomNumberNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'randomNumber',
+            title: 'RNG',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 150,
+            },
+            data: {
+                min: 0,
+                max: 1,
+                integers: false,
+                maxInclusive: false,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = [];
+        if (this.data.useMinInput) {
+            inputs.push({
+                dataType: 'number',
+                id: 'min',
+                title: 'Min',
+            });
+        }
+        if (this.data.useMaxInput) {
+            inputs.push({
+                dataType: 'number',
+                id: 'max',
+                title: 'Max',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'number',
+                id: 'value',
+                title: 'Value',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            { type: 'number', label: 'Min', dataKey: 'min', useInputToggleDataKey: 'useMinInput' },
+            { type: 'number', label: 'Max', dataKey: 'max', useInputToggleDataKey: 'useMaxInput' },
+            { type: 'toggle', label: 'Integers', dataKey: 'integers' },
+            { type: 'toggle', label: 'Max Inclusive', dataKey: 'maxInclusive' },
+        ];
+    }
+    getBody() {
+        return dedent `
+      Min: ${this.data.useMinInput ? '(Input)' : this.data.min ?? 0}
+      Max: ${this.data.useMaxInput ? '(Input)' : this.data.max ?? 1}
+      ${this.data.integers ? 'Integers' : 'Floats'}
+      ${this.data.maxInclusive ? 'Max Inclusive' : 'Max Exclusive'}
+    `;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Outputs a random number between the configured min and max values.
+
+        Can be configured to output only integers, and whether the max value is inclusive or exclusive.
+      `,
+            infoBoxTitle: 'RNG Node',
+            contextMenuTitle: 'RNG',
+            group: ['Numbers'],
+        };
+    }
+    async process(inputs) {
+        const min = this.data.useMinInput
+            ? coerceTypeOptional(inputs['min'], 'number') ?? this.data.min ?? 0
+            : this.data.min ?? 0;
+        let max = this.data.useMaxInput
+            ? coerceTypeOptional(inputs['max'], 'number') ?? this.data.max ?? 1
+            : this.data.max ?? 1;
+        if (this.data.integers && this.data.maxInclusive) {
+            max += 1;
+        }
+        let value = Math.random() * (max - min) + min;
+        if (this.data.integers) {
+            value = Math.floor(value);
+        }
+        return {
+            ['value']: {
+                type: 'number',
+                value,
+            },
+        };
+    }
+}
+export const randomNumberNode = nodeDefinition(RandomNumberNodeImpl, 'Random Number');