@alpic80/rivet-core 1.19.1-aidon.1

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

@@ -0,0 +1,115 @@
+import { NodeImpl } from '../NodeImpl.js';
+import { nanoid } from 'nanoid/non-secure';
+import { dedent } from 'ts-dedent';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { getInputOrData, coerceTypeOptional, newId, coerceType } from '../../utils/index.js';
+import { arrayizeDataValue, unwrapDataValue } from '../DataValue.js';
+export class AppendToDatasetNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: nanoid(),
+            type: 'appendToDataset',
+            title: 'Append to Dataset',
+            visualData: { x: 0, y: 0, width: 250 },
+            data: {
+                datasetId: '',
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [];
+        inputDefinitions.push({
+            id: 'data',
+            dataType: 'string[]',
+            title: 'Data',
+            description: 'The data to append to the dataset. May be a string or array of strings. If an array, each element will be a column in the dataset.',
+        });
+        inputDefinitions.push({
+            id: 'id',
+            dataType: 'string',
+            title: 'ID',
+            description: 'The ID of the row to append. If not provided, a random ID will be generated. If an existing ID is provided, the row will be overwritten.',
+        });
+        inputDefinitions.push({
+            id: 'embedding',
+            dataType: 'vector',
+            title: 'Embedding',
+            description: 'The vector embedding to store with the row.',
+        });
+        if (this.data.useDatasetIdInput) {
+            inputDefinitions.push({
+                id: 'datasetId',
+                title: 'Dataset ID',
+                dataType: 'string',
+                description: 'The ID of the dataset to append to.',
+            });
+        }
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'dataset',
+                title: 'Dataset',
+                dataType: 'object', // technically string[][]...
+            },
+            {
+                id: 'id_out',
+                title: 'ID',
+                dataType: 'string',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Appends a row of data to the specified dataset.
+      `,
+            infoBoxTitle: 'Append to Dataset Node',
+            contextMenuTitle: 'Append to Dataset',
+            group: ['Input/Output'],
+        };
+    }
+    getEditors() {
+        return [
+            {
+                type: 'datasetSelector',
+                label: 'Dataset',
+                dataKey: 'datasetId',
+                useInputToggleDataKey: 'useDatasetIdInput',
+            },
+        ];
+    }
+    async process(inputs, context) {
+        const { datasetProvider } = context;
+        if (datasetProvider == null) {
+            throw new Error('datasetProvider is required');
+        }
+        const datasetId = getInputOrData(this.data, inputs, 'datasetId', 'string');
+        const dataId = coerceTypeOptional(inputs['id'], 'string') || newId();
+        const embedding = coerceTypeOptional(inputs['embedding'], 'vector');
+        const dataInput = inputs['data'];
+        if (!dataInput) {
+            throw new Error('data input is required');
+        }
+        const data = arrayizeDataValue(unwrapDataValue(dataInput));
+        const stringData = data.map((d) => coerceType(d, 'string'));
+        const newData = {
+            id: dataId,
+            data: stringData,
+            embedding,
+        };
+        await datasetProvider.putDatasetRow(datasetId, newData);
+        return {
+            ['dataset']: {
+                type: 'object',
+                value: newData,
+            },
+            ['id_out']: {
+                type: 'string',
+                value: datasetId,
+            },
+        };
+    }
+}
+export const appendToDatasetNode = nodeDefinition(AppendToDatasetNodeImpl, 'Append To Dataset');

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

@@ -0,0 +1,144 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import {} from '../GraphProcessor.js';
+import { entries } from '../../utils/typeSafety.js';
+import { flattenDeep } from 'lodash-es';
+import { dedent } from 'ts-dedent';
+import {} from '../EditorDefinition.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+export class ArrayNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'array',
+            title: 'Array',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 200,
+            },
+            data: {
+                flatten: true,
+                flattenDeep: false,
+            },
+        };
+        return chartNode;
+    }
+    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}`,
+                description: 'An input to create the array from. If an array, will be flattened if the "Flatten" option is enabled.',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'any[]',
+                id: 'output',
+                title: 'Output',
+                description: 'The array created from the inputs.',
+            },
+            {
+                dataType: 'number[]',
+                id: 'indices',
+                title: 'Indices',
+                description: 'The indices of the array. I.e. [0, 1, 2, 3, etc]. Useful for zipping with the output array to get the indexes.',
+            },
+            {
+                dataType: 'number',
+                id: 'length',
+                title: 'Length',
+                description: 'The length of the output array.',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            { type: 'toggle', label: 'Flatten', dataKey: 'flatten' },
+            {
+                type: 'toggle',
+                label: 'Deep',
+                dataKey: 'flattenDeep',
+            },
+        ];
+    }
+    #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 inputNumber = parseInt(connection.inputId.replace('input', ''));
+            if (inputNumber > maxInputNumber) {
+                maxInputNumber = inputNumber;
+            }
+        }
+        return maxInputNumber + 1;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Creates an array from the input values. By default, flattens any arrays which are inputs into a single array. Can be configured to keep the arrays separate, or deeply flatten arrays.
+
+        Useful for both creating and merging arrays.
+
+        The number of inputs is dynamic based on the number of connections.
+      `,
+            infoBoxTitle: 'Array Node',
+            contextMenuTitle: 'Array',
+            group: ['Lists'],
+        };
+    }
+    getBody() {
+        return dedent `
+      ${this.data.flatten ? (this.data.flattenDeep ? 'Flatten (Deep)' : 'Flatten') : 'No Flatten'}
+    `;
+    }
+    async process(inputs) {
+        const outputArray = [];
+        for (const [key, input] of entries(inputs)) {
+            if (key.startsWith('input')) {
+                if (this.data.flatten) {
+                    if (Array.isArray(input?.value)) {
+                        for (const value of input?.value ?? []) {
+                            if (this.data.flattenDeep) {
+                                outputArray.push(...(Array.isArray(value) ? flattenDeep(value) : [value]));
+                            }
+                            else {
+                                outputArray.push(value);
+                            }
+                        }
+                    }
+                    else {
+                        outputArray.push(input?.value);
+                    }
+                }
+                else {
+                    outputArray.push(input?.value);
+                }
+            }
+        }
+        return {
+            ['output']: {
+                type: 'any[]',
+                value: outputArray,
+            },
+            ['indices']: {
+                type: 'number[]',
+                value: outputArray.map((_, index) => index),
+            },
+            ['length']: {
+                type: 'number',
+                value: outputArray.length,
+            },
+        };
+    }
+}
+export const arrayNode = nodeDefinition(ArrayNodeImpl, 'Array');

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

@@ -0,0 +1,199 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { arrayizeDataValue, unwrapDataValue } from '../DataValue.js';
+import {} from '../GraphProcessor.js';
+import { orderBy } from 'lodash-es';
+import { coerceTypeOptional, dedent, getInputOrData } from '../../utils/index.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { match } from 'ts-pattern';
+const messageTypeToTitle = {
+    assistant: 'Assistant',
+    function: 'Function Tool Call',
+    system: 'System',
+    user: 'User',
+};
+export class AssembleMessageNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'assembleMessage',
+            title: 'Assemble Message',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                type: 'user',
+                useTypeInput: false,
+                toolCallId: '',
+                useToolCallIdInput: false,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions(connections) {
+        const inputs = [];
+        const messageCount = this.#getInputPortCount(connections);
+        if (this.data.useTypeInput) {
+            inputs.push({
+                dataType: 'string',
+                id: 'type',
+                title: 'Type',
+                description: 'The type of message to assemble.',
+            });
+        }
+        if (this.data.useToolCallIdInput) {
+            inputs.push({
+                dataType: 'string',
+                id: 'toolCallId',
+                title: 'Tool Call ID',
+                description: 'The ID of the tool call to associate with the message.',
+            });
+        }
+        for (let i = 1; i <= messageCount; i++) {
+            inputs.push({
+                dataType: ['string', 'image', 'string[]', 'image[]', 'object', 'object[]'],
+                id: `part${i}`,
+                title: `Part ${i}`,
+                description: 'A part of the message to assemble.',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'chat-message',
+                id: 'message',
+                title: 'Message',
+                description: 'The assembled message.',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'dropdown',
+                label: 'Type',
+                dataKey: 'type',
+                options: [
+                    { value: 'system', label: 'System' },
+                    { value: 'user', label: 'User' },
+                    { value: 'assistant', label: 'Assistant' },
+                    { value: 'function', label: 'Function' },
+                ],
+                defaultValue: 'user',
+                useInputToggleDataKey: 'useTypeInput',
+            },
+            {
+                type: 'string',
+                label: 'Tool Call ID',
+                dataKey: 'toolCallId',
+                useInputToggleDataKey: 'useToolCallIdInput',
+                hideIf: (data) => data.type !== 'function',
+            },
+        ];
+    }
+    #getInputPortCount(connections) {
+        const inputNodeId = this.chartNode.id;
+        const messageConnections = connections.filter((connection) => connection.inputNodeId === inputNodeId && connection.inputId.startsWith('part'));
+        let maxMessageNumber = 0;
+        for (const connection of messageConnections) {
+            const messageNumber = parseInt(connection.inputId.replace('part', ''));
+            if (messageNumber > maxMessageNumber) {
+                maxMessageNumber = messageNumber;
+            }
+        }
+        return maxMessageNumber + 1;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Assembles a single chat message from multiple parts. This is similar to a Prompt node, but works with multimodal
+        models, as you can include both text and images in the message.
+      `,
+            infoBoxTitle: 'Assemble Message Node',
+            contextMenuTitle: 'Assemble Message',
+            group: 'AI',
+        };
+    }
+    getBody(_context) {
+        return dedent `
+      ${this.data.useTypeInput ? '(Type From Input)' : messageTypeToTitle[this.data.type]}
+      ${this.data.useTypeInput || this.data.type === 'function'
+            ? `Tool Call ID: ${this.data.useToolCallIdInput ? '(From Input)' : this.data.toolCallId}`
+            : ``}
+    `;
+    }
+    async process(inputs) {
+        const output = {};
+        const type = getInputOrData(this.data, inputs, 'type');
+        const outMessage = match(type)
+            .with('system', (type) => ({
+            type,
+            message: [],
+        }))
+            .with('user', (type) => ({
+            type,
+            message: [],
+        }))
+            .with('assistant', (type) => ({
+            type,
+            message: [],
+            function_call: undefined, // Not supported yet in Assemble Message node
+            function_calls: undefined, // Not supported yet in Assemble Message node
+        }))
+            .with('function', (type) => ({
+            type,
+            message: [],
+            name: getInputOrData(this.data, inputs, 'toolCallId'),
+        }))
+            .otherwise(() => {
+            throw new Error(`Invalid type: ${type}`);
+        });
+        const inputParts = orderBy(Object.entries(inputs).filter(([key]) => key.startsWith('part')), ([key]) => key, 'asc');
+        for (const [, inputPart] of inputParts) {
+            if (!inputPart || inputPart.type === 'control-flow-excluded' || !inputPart.value) {
+                continue;
+            }
+            const inPart = arrayizeDataValue(unwrapDataValue(inputPart));
+            for (const message of inPart) {
+                if (message.type === 'string') {
+                    outMessage.message.push(message.value);
+                }
+                else if (message.type === 'image') {
+                    outMessage.message.push({
+                        type: 'image',
+                        data: message.value.data,
+                        mediaType: message.value.mediaType,
+                    });
+                }
+                else if (message.type === 'object') {
+                    if (message.value &&
+                        'type' in message.value &&
+                        message.value.type === 'url_reference' &&
+                        typeof message.value.url === 'string') {
+                        outMessage.message.push({
+                            type: 'url',
+                            url: message.value.url,
+                        });
+                    }
+                }
+                else {
+                    const coerced = coerceTypeOptional(message, 'string');
+                    if (coerced) {
+                        outMessage.message.push(coerced);
+                    }
+                }
+            }
+        }
+        output['message'] = {
+            type: 'chat-message',
+            value: outMessage,
+        };
+        return output;
+    }
+}
+export const assembleMessageNode = nodeDefinition(AssembleMessageNodeImpl, 'Assemble Prompt');

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

@@ -0,0 +1,129 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { arrayizeDataValue, unwrapDataValue } from '../DataValue.js';
+import {} from '../GraphProcessor.js';
+import { coerceType } from '../../utils/coerceType.js';
+import { orderBy } from 'lodash-es';
+import { dedent } from 'ts-dedent';
+import { nodeDefinition } from '../NodeDefinition.js';
+export class AssemblePromptNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'assemblePrompt',
+            title: 'Assemble Prompt',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {},
+        };
+        return chartNode;
+    }
+    getInputDefinitions(connections) {
+        const inputs = [];
+        const messageCount = this.#getMessagePortCount(connections);
+        for (let i = 1; i <= messageCount; i++) {
+            inputs.push({
+                dataType: ['chat-message', 'chat-message[]'],
+                id: `message${i}`,
+                title: `Message ${i}`,
+                description: 'A message, or messages, to include in the full prompt.',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        const outputs = [
+            {
+                dataType: 'chat-message[]',
+                id: 'prompt',
+                title: 'Prompt',
+                description: 'The assembled prompt, a list of chat messages.',
+            },
+        ];
+        if (this.data.computeTokenCount) {
+            outputs.push({
+                dataType: 'number',
+                id: 'tokenCount',
+                title: 'Token Count',
+                description: 'The number of tokens in the full output prompt.',
+            });
+        }
+        return outputs;
+    }
+    #getMessagePortCount(connections) {
+        const inputNodeId = this.chartNode.id;
+        const messageConnections = connections.filter((connection) => connection.inputNodeId === inputNodeId && connection.inputId.startsWith('message'));
+        let maxMessageNumber = 0;
+        for (const connection of messageConnections) {
+            const messageNumber = parseInt(connection.inputId.replace('message', ''));
+            if (messageNumber > maxMessageNumber) {
+                maxMessageNumber = messageNumber;
+            }
+        }
+        return maxMessageNumber + 1;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Assembles an array of chat messages for use with a Chat node. The inputs can be strings or chat messages.
+
+        The number of inputs is dynamic based on the number of connections.
+
+        Strings are converted to User type chat messages.
+      `,
+            infoBoxTitle: 'Assemble Prompt Node',
+            contextMenuTitle: 'Assemble Prompt',
+            group: ['AI'],
+        };
+    }
+    getEditors(_context) {
+        return [
+            {
+                type: 'toggle',
+                label: 'Compute Token Count',
+                dataKey: 'computeTokenCount',
+            },
+        ];
+    }
+    async process(inputs, context) {
+        const output = {};
+        const outMessages = [];
+        const inputMessages = orderBy(Object.entries(inputs).filter(([key]) => key.startsWith('message')), ([key]) => key, 'asc');
+        for (const [, inputMessage] of inputMessages) {
+            if (!inputMessage || inputMessage.type === 'control-flow-excluded' || !inputMessage.value) {
+                continue;
+            }
+            const inMessages = arrayizeDataValue(unwrapDataValue(inputMessage));
+            for (const message of inMessages) {
+                if (message.type === 'chat-message') {
+                    outMessages.push(message.value);
+                }
+                else {
+                    const coerced = coerceType(message, 'chat-message');
+                    if (coerced) {
+                        outMessages.push(coerced);
+                    }
+                }
+            }
+        }
+        output['prompt'] = {
+            type: 'chat-message[]',
+            value: outMessages,
+        };
+        if (this.data.computeTokenCount) {
+            const tokenCount = await context.tokenizer.getTokenCountForMessages(outMessages, undefined, {
+                node: this.chartNode,
+            });
+            output['tokenCount'] = {
+                type: 'number',
+                value: tokenCount,
+            };
+        }
+        return output;
+    }
+}
+export const assemblePromptNode = nodeDefinition(AssemblePromptNodeImpl, 'Assemble Prompt');

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

@@ -0,0 +1,101 @@
+import {} from '../NodeBase.js';
+import { NodeImpl } from '../NodeImpl.js';
+import { nanoid } from 'nanoid/non-secure';
+import {} from '../../index.js';
+import { base64ToUint8Array, expectType } from '../../utils/index.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { getInputOrData } from '../../utils/inputs.js';
+export class AudioNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: nanoid(),
+            type: 'audio',
+            title: 'Audio',
+            visualData: { x: 0, y: 0, width: 300 },
+            data: {
+                useDataInput: false,
+                useMediaTypeInput: false,
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [];
+        if (this.chartNode.data.useDataInput) {
+            inputDefinitions.push({
+                id: 'data',
+                title: 'Data',
+                dataType: 'string',
+                coerced: false,
+            });
+        }
+        if (this.chartNode.data.useMediaTypeInput) {
+            inputDefinitions.push({
+                id: 'mediaType',
+                title: 'Media Type',
+                dataType: 'string',
+                coerced: false,
+            });
+        }
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'data',
+                title: 'Audio Data',
+                dataType: 'audio',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'fileBrowser',
+                label: 'Audio File',
+                dataKey: 'data',
+                mediaTypeDataKey: 'mediaType',
+                useInputToggleDataKey: 'useDataInput',
+                accept: 'audio/*',
+            },
+            {
+                type: 'string',
+                label: 'Media Type',
+                dataKey: 'mediaType',
+                useInputToggleDataKey: 'useMediaTypeInput',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            contextMenuTitle: 'Audio',
+            group: 'Data',
+            infoBoxTitle: 'Audio Node',
+            infoBoxBody: 'Defines an audio sample for use with other nodes. Can convert a binary type into an audio type.',
+        };
+    }
+    async process(inputData, context) {
+        let data;
+        const mediaType = getInputOrData(this.data, inputData, 'mediaType', 'string') || 'audio/wav';
+        if (this.chartNode.data.useDataInput) {
+            data = expectType(inputData['data'], 'binary');
+        }
+        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 = base64ToUint8Array(encodedData);
+        }
+        return {
+            ['data']: {
+                type: 'audio',
+                value: { data, mediaType },
+            },
+        };
+    }
+}
+export const audioNode = nodeDefinition(AudioNodeImpl, 'Audio');