@alpic80/rivet-core 1.19.1-aidon.1

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

@@ -0,0 +1,99 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import {} from '../DataValue.js';
+import {} from '../GraphProcessor.js';
+import {} from '../ProcessContext.js';
+import { dedent } from 'ts-dedent';
+import {} from '../EditorDefinition.js';
+import {} from '../NodeBodySpec.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+export class ContextNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'context',
+            title: 'Context',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 300,
+            },
+            data: {
+                id: 'input',
+                dataType: 'string',
+                defaultValue: undefined,
+                useDefaultValueInput: false,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        if (this.data.useDefaultValueInput) {
+            return [
+                {
+                    id: 'default',
+                    title: 'Default Value',
+                    dataType: this.chartNode.data.dataType,
+                },
+            ];
+        }
+        return [];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'data',
+                title: this.data.id,
+                dataType: this.chartNode.data.dataType,
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            { type: 'string', label: 'ID', dataKey: 'id' },
+            { type: 'dataTypeSelector', label: 'Data Type', dataKey: 'dataType' },
+            {
+                type: 'anyData',
+                label: 'Default Value',
+                dataKey: 'defaultValue',
+                useInputToggleDataKey: 'useDefaultValueInput',
+            },
+        ];
+    }
+    getBody() {
+        return dedent `
+      ${this.data.id}
+      Type: ${this.data.dataType}
+    `;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Retrieves a value from the graph's context using a configured id. The context serves as a "global graph input", allowing the same values to be accessible from any graph or subgraph.
+      `,
+            infoBoxTitle: 'Context Node',
+            contextMenuTitle: 'Context',
+            group: ['Advanced'],
+        };
+    }
+    async process(inputs, context) {
+        const contextValue = context.contextValues[this.data.id];
+        if (contextValue !== undefined) {
+            return {
+                ['data']: contextValue,
+            };
+        }
+        let defaultValue;
+        if (this.data.useDefaultValueInput) {
+            defaultValue = inputs['default'];
+        }
+        else {
+            defaultValue = { type: this.data.dataType, value: this.data.defaultValue };
+        }
+        return {
+            ['data']: defaultValue,
+        };
+    }
+}
+export const contextNode = nodeDefinition(ContextNodeImpl, 'Context');

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

@@ -0,0 +1,71 @@
+import { NodeImpl } from '../NodeImpl.js';
+import { coerceTypeOptional, dedent, newId } from '../../utils/index.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+export class CreateDatasetNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: newId(),
+            type: 'createDataset',
+            title: 'Create Dataset',
+            visualData: { x: 0, y: 0, width: 250 },
+            data: {},
+        };
+    }
+    getInputDefinitions() {
+        return [
+            {
+                id: 'datasetId',
+                title: 'Dataset ID',
+                dataType: 'string',
+            },
+            {
+                id: 'datasetName',
+                title: 'Dataset Name',
+                dataType: 'string',
+            },
+        ];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'datasetId_out',
+                title: 'Dataset ID',
+                dataType: 'string',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Creates a new dataset with the provided ID and name. If the dataset already exists, it does nothing.
+      `,
+            infoBoxTitle: 'Create Dataset Node',
+            contextMenuTitle: 'Create Dataset',
+            group: ['Input/Output'],
+        };
+    }
+    async process(inputs, context) {
+        const { datasetProvider } = context;
+        if (datasetProvider == null) {
+            throw new Error('datasetProvider is required');
+        }
+        const datasetId = coerceTypeOptional(inputs['datasetId'], 'string') || newId();
+        const datasetName = coerceTypeOptional(inputs['datasetName'], 'string') || datasetId;
+        const existingDataset = await datasetProvider.getDatasetMetadata(datasetId);
+        if (!existingDataset) {
+            await datasetProvider.putDatasetMetadata({
+                id: datasetId,
+                name: datasetName,
+                description: '',
+                projectId: context.project.metadata.id,
+            });
+        }
+        return {
+            ['datasetId_out']: {
+                type: 'string',
+                value: datasetId || datasetName,
+            },
+        };
+    }
+}
+export const createDatasetNode = nodeDefinition(CreateDatasetNodeImpl, 'Create Dataset');

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

@@ -0,0 +1,97 @@
+import { NodeImpl } from '../NodeImpl.js';
+import { coerceType, dedent, getInputOrData, newId } from '../../utils/index.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+export class DatasetNearestNeighborsNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: newId(),
+            type: 'datasetNearestNeighbors',
+            title: 'KNN Dataset',
+            visualData: { x: 0, y: 0, width: 250 },
+            data: {
+                datasetId: '',
+                k: 5,
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputs = [
+            {
+                id: 'embedding',
+                title: 'Embedding',
+                dataType: 'object',
+            },
+        ];
+        if (this.data.useDatasetIdInput) {
+            inputs.push({
+                id: 'datasetId',
+                title: 'Dataset ID',
+                dataType: 'string',
+            });
+        }
+        if (this.data.useKInput) {
+            inputs.push({
+                id: 'k',
+                title: 'K',
+                dataType: 'number',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'nearestNeighbors',
+                title: 'Nearest Neighbors',
+                dataType: 'object[]',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Finds the k nearest neighbors in the dataset with the provided ID, given an embedding.
+      `,
+            infoBoxTitle: 'KNN Dataset Node',
+            contextMenuTitle: 'KNN Dataset',
+            group: ['Input/Output'],
+        };
+    }
+    getEditors() {
+        return [
+            {
+                type: 'datasetSelector',
+                label: 'Dataset',
+                dataKey: 'datasetId',
+                useInputToggleDataKey: 'useDatasetIdInput',
+            },
+            {
+                type: 'number',
+                label: 'K',
+                dataKey: 'k',
+                useInputToggleDataKey: 'useKInput',
+            },
+        ];
+    }
+    async process(inputs, context) {
+        const { datasetProvider } = context;
+        if (datasetProvider == null) {
+            throw new Error('datasetProvider is required');
+        }
+        const datasetId = getInputOrData(this.data, inputs, 'datasetId');
+        const k = getInputOrData(this.data, inputs, 'k', 'number');
+        const embedding = coerceType(inputs['embedding'], 'vector');
+        const nearestNeighbors = await datasetProvider.knnDatasetRows(datasetId, k, embedding);
+        return {
+            ['nearestNeighbors']: {
+                type: 'object[]',
+                value: nearestNeighbors.map((neighbor) => ({
+                    id: neighbor.id,
+                    distance: neighbor.distance,
+                    data: neighbor.data,
+                })),
+            },
+        };
+    }
+}
+export const datasetNearestNeighborsNode = nodeDefinition(DatasetNearestNeighborsNodeImpl, 'Dataset Nearest Neighbors');

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

@@ -0,0 +1,105 @@
+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 { getInputOrData } from '../../utils/inputs.js';
+export class DelayNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'delay',
+            title: 'Delay',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 175,
+            },
+            data: {
+                delay: 0,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions(connections) {
+        const inputs = [];
+        const inputCount = this.#getInputPortCount(connections);
+        if (this.data.useDelayInput) {
+            inputs.push({
+                dataType: 'number',
+                id: 'delay',
+                title: 'Delay (ms)',
+            });
+        }
+        for (let i = 1; i <= inputCount; i++) {
+            inputs.push({
+                dataType: 'any',
+                id: `input${i}`,
+                title: `Input ${i}`,
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions(connections) {
+        const outputs = [];
+        const inputCount = this.#getInputPortCount(connections);
+        for (let i = 1; i <= inputCount - 1; i++) {
+            outputs.push({
+                dataType: 'any',
+                id: `output${i}`,
+                title: `Output ${i}`,
+            });
+        }
+        return outputs;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Delays the execution and then passes the input value to the output without any modifications.
+      `,
+            infoBoxTitle: 'Delay Node',
+            contextMenuTitle: 'Delay',
+            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;
+    }
+    getEditors() {
+        return [
+            {
+                type: 'number',
+                label: 'Delay (ms)',
+                dataKey: 'delay',
+                useInputToggleDataKey: 'useDelayInput',
+                defaultValue: 0,
+            },
+        ];
+    }
+    getBody() {
+        return `Delay ${this.data.useDelayInput ? '(Input ms)' : `${this.chartNode.data.delay}ms`}`;
+    }
+    async process(inputData) {
+        const delayAmount = getInputOrData(this.data, inputData, 'delay', 'number');
+        await new Promise((resolve) => setTimeout(resolve, delayAmount));
+        const inputCount = Object.keys(inputData).filter((key) => key.startsWith('input')).length;
+        const outputs = {};
+        for (let i = 1; i <= inputCount; i++) {
+            const input = inputData[`input${i}`];
+            outputs[`output${i}`] = input;
+        }
+        return outputs;
+    }
+}
+export const delayNode = nodeDefinition(DelayNodeImpl, 'Delay');

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

@@ -0,0 +1,136 @@
+import { nanoid } from 'nanoid';
+import { NodeImpl } from '../NodeImpl.js';
+import { dedent } from 'ts-dedent';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { coerceType, coerceTypeOptional } from '../../utils/coerceType.js';
+export class DelegateFunctionCallNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'delegateFunctionCall',
+            title: 'Delegate Function Call',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 325,
+            },
+            data: {
+                handlers: [],
+                unknownHandler: undefined,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = [];
+        inputs.push({
+            id: 'function-call',
+            dataType: 'object',
+            title: 'Function Call',
+            coerced: true,
+            required: true,
+            description: 'The function call to delegate to a subgraph.',
+        });
+        return inputs;
+    }
+    getOutputDefinitions() {
+        const outputs = [];
+        outputs.push({
+            id: 'output',
+            dataType: 'string',
+            title: 'Output',
+            description: 'The output of the function call.',
+        });
+        outputs.push({
+            id: 'message',
+            dataType: 'object',
+            title: 'Message Output',
+            description: 'Maps the output for use directly with an Assemble Prompt node and GPT.',
+        });
+        return outputs;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Handles a function call by delegating it to a different subgraph depending on the function call.
+      `,
+            infoBoxTitle: 'Delegate Function Call Node',
+            contextMenuTitle: 'Delegate Function Call',
+            group: ['Advanced'],
+        };
+    }
+    getEditors() {
+        return [
+            {
+                type: 'custom',
+                customEditorId: 'ToolCallHandlers',
+                label: 'Handlers',
+                dataKey: 'handlers',
+            },
+            {
+                type: 'graphSelector',
+                dataKey: 'unknownHandler',
+                label: 'Unknown Handler',
+                helperMessage: 'The subgraph to delegate to if the function call does not match any handlers.',
+            },
+        ];
+    }
+    getBody(context) {
+        if (this.data.handlers.length === 0) {
+            return 'No handlers defined';
+        }
+        const lines = ['Handlers:'];
+        this.data.handlers.forEach(({ key, value }) => {
+            const subgraphName = context.project.graphs[value]?.metadata.name ?? 'Unknown Subgraph';
+            lines.push(`    ${key || '(MISSING!)'} -> ${subgraphName}`);
+        });
+        return lines.join('\n');
+    }
+    async process(inputs, context) {
+        const functionCall = coerceType(inputs['function-call'], 'object');
+        let handler = this.data.handlers.find((handler) => handler.key === functionCall.name);
+        if (!handler) {
+            if (this.data.unknownHandler) {
+                handler = { key: undefined, value: this.data.unknownHandler };
+            }
+            else {
+                throw new Error(`No handler found for function call: ${functionCall.name}`);
+            }
+        }
+        const subgraphInputs = {
+            _function_name: {
+                type: 'string',
+                value: functionCall.name,
+            },
+            _arguments: {
+                type: 'object',
+                value: functionCall.arguments,
+            },
+        };
+        for (const [argName, argument] of Object.entries(functionCall.arguments)) {
+            subgraphInputs[argName] = {
+                type: 'any',
+                value: argument,
+            };
+        }
+        const handlerGraphId = handler.value;
+        const subprocessor = context.createSubProcessor(handlerGraphId, { signal: context.signal });
+        const outputs = await subprocessor.processGraph(context, subgraphInputs, context.contextValues);
+        const outputString = coerceTypeOptional(outputs.output, 'string') ?? '';
+        return {
+            ['output']: {
+                type: 'string',
+                value: outputString,
+            },
+            ['message']: {
+                type: 'chat-message',
+                value: {
+                    type: 'function',
+                    message: outputString,
+                    name: functionCall.id ?? '',
+                },
+            },
+        };
+    }
+}
+export const delegateFunctionCallNode = nodeDefinition(DelegateFunctionCallNodeImpl, 'Delegate Function Call');

package/dist/esm/model/nodes/DestructureNode.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 '../DataValue.js';
+import { JSONPath } from 'jsonpath-plus';
+import {} from '../../index.js';
+import { dedent } from 'ts-dedent';
+import { coerceTypeOptional } from '../../utils/coerceType.js';
+export class DestructureNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'destructure',
+            title: 'Destructure',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                paths: ['$.value'],
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        return [
+            {
+                id: 'object',
+                title: 'Object',
+                dataType: 'object',
+                required: true,
+            },
+        ];
+    }
+    getOutputDefinitions() {
+        return this.chartNode.data.paths.map((path, index) => ({
+            id: `match_${index}`,
+            title: path,
+            dataType: 'any',
+        }));
+    }
+    getEditors() {
+        return [
+            {
+                type: 'stringList',
+                label: 'Paths',
+                dataKey: 'paths',
+                helperMessage: 'One or more JSONPath expressions. Each expression will correspond to an output port of the node.',
+            },
+        ];
+    }
+    getBody() {
+        return '';
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Destructures the input value by extracting values at the specified paths. The paths use JSONPath notation to navigate through the value.
+      `,
+            infoBoxTitle: 'Destructure Node',
+            contextMenuTitle: 'Destructure',
+            group: ['Objects'],
+        };
+    }
+    async process(inputs) {
+        const inputObject = coerceTypeOptional(inputs['object'], 'object');
+        const output = {};
+        this.data.paths.forEach((path, index) => {
+            let match;
+            try {
+                match = JSONPath({ json: inputObject ?? null, path: path.trim(), wrap: false });
+            }
+            catch (err) {
+                match = undefined;
+            }
+            output[`match_${index}`] = {
+                type: 'any',
+                value: match,
+            };
+        });
+        return output;
+    }
+}
+export const destructureNode = nodeDefinition(DestructureNodeImpl, 'Destructure');