@alpic80/rivet-core 1.19.1-aidon.1

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

@@ -0,0 +1,130 @@
+import {} from '../NodeBase.js';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { nanoid } from 'nanoid/non-secure';
+import {} from '../GraphProcessor.js';
+import {} from '../ProcessContext.js';
+import {} from '../../index.js';
+import { dedent } from 'ts-dedent';
+import { coerceType } from '../../utils/coerceType.js';
+import { getIntegration } from '../../integrations/integrations.js';
+export class GetEmbeddingNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: nanoid(),
+            type: 'getEmbedding',
+            title: 'Get Embedding',
+            visualData: { x: 0, y: 0, width: 250 },
+            data: {
+                integration: 'openai',
+                useIntegrationInput: false,
+                model: undefined,
+                dimensions: undefined
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [];
+        inputDefinitions.push({
+            id: 'input',
+            title: 'Input',
+            dataType: 'string',
+            required: true,
+        });
+        if (this.data.useIntegrationInput) {
+            inputDefinitions.push({
+                id: 'integration',
+                title: 'Integration',
+                dataType: 'string',
+                required: true,
+            });
+        }
+        if (this.data.useModelInput) {
+            inputDefinitions.push({
+                id: 'model',
+                title: 'Model',
+                dataType: 'string',
+                required: false,
+            });
+        }
+        if (this.data.useDimensionsInput) {
+            inputDefinitions.push({
+                id: 'dimensions',
+                title: 'Dimensions',
+                dataType: 'number',
+                required: false,
+            });
+        }
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        const outputs = [
+            {
+                id: 'embedding',
+                title: 'Embedding',
+                dataType: 'vector',
+            },
+        ];
+        return outputs;
+    }
+    getEditors() {
+        return [
+            {
+                type: 'dropdown',
+                label: 'Integration',
+                dataKey: 'integration',
+                options: [{ label: 'OpenAI', value: 'openai' }],
+                useInputToggleDataKey: 'useIntegrationInput',
+            },
+            {
+                type: 'string',
+                label: 'Model',
+                dataKey: 'model',
+                useInputToggleDataKey: 'useModelInput',
+            },
+            {
+                type: 'number',
+                label: 'Dimensions',
+                dataKey: 'dimensions',
+                useInputToggleDataKey: 'useDimensionsInput',
+            },
+        ];
+    }
+    getBody() {
+        return `Using ${this.data.useIntegrationInput ? '(input)' : this.data.integration}`;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Gets a OpenAI vector embedding for the input text provided.
+
+        Can be used with the Vector Store and Vector KNN nodes.
+      `,
+            infoBoxTitle: 'Get Embedding Node',
+            contextMenuTitle: 'Get Embedding',
+            group: ['AI'],
+        };
+    }
+    async process(inputs, context) {
+        const input = coerceType(inputs['input'], 'string');
+        const integrationName = this.data.useIntegrationInput
+            ? coerceType(inputs['integration'], 'string')
+            : this.data.integration;
+        const model = this.data.useModelInput ? coerceType(inputs['model'], 'string') : this.data.model;
+        const dimensions = this.data.useDimensionsInput
+            ? coerceType(inputs['dimensions'], 'number')
+            : this.data.dimensions;
+        const embeddingGenerator = getIntegration('embeddingGenerator', integrationName, context);
+        const embedding = await embeddingGenerator.generateEmbedding(input, {
+            model,
+            dimensions,
+        });
+        return {
+            ['embedding']: {
+                type: 'vector',
+                value: embedding,
+            },
+        };
+    }
+}
+export const getEmbeddingNode = nodeDefinition(GetEmbeddingNodeImpl, 'Get Embedding');

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

@@ -0,0 +1,139 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { isArrayDataType, isScalarDataType, scalarDefaults, } from '../DataValue.js';
+import {} from '../GraphProcessor.js';
+import { coerceType } from '../../utils/coerceType.js';
+import {} from '../ProcessContext.js';
+import { dedent } from 'ts-dedent';
+import {} from '../../index.js';
+export class GetGlobalNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'getGlobal',
+            title: 'Get Global',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 200,
+            },
+            data: {
+                id: 'variable-name',
+                dataType: 'string',
+                onDemand: true,
+                useIdInput: false,
+                wait: false,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        if (this.data.useIdInput) {
+            return [
+                {
+                    id: 'id',
+                    title: 'Variable ID',
+                    dataType: this.data.dataType,
+                },
+            ];
+        }
+        return [];
+    }
+    getOutputDefinitions() {
+        const { onDemand, dataType } = this.chartNode.data;
+        return [
+            {
+                id: 'value',
+                title: 'Value',
+                dataType: onDemand ? `fn<${dataType}>` : dataType,
+            },
+            {
+                id: 'variable_id_out',
+                title: 'Variable ID',
+                dataType: 'string',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                label: 'Variable ID',
+                dataKey: 'id',
+                useInputToggleDataKey: 'useIdInput',
+            },
+            {
+                type: 'dataTypeSelector',
+                label: 'Data Type',
+                dataKey: 'dataType',
+            },
+            {
+                type: 'toggle',
+                label: 'On Demand',
+                dataKey: 'onDemand',
+            },
+            {
+                type: 'toggle',
+                label: 'Wait',
+                dataKey: 'wait',
+            },
+        ];
+    }
+    getBody() {
+        return dedent `
+      ${this.data.useIdInput ? '(ID from input)' : this.data.id}
+      Type: ${this.data.dataType}
+      ${this.data.wait ? 'Waits for available data' : ''}
+    `;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Retrieves a global value that is shared across all graphs and subgraphs. The id of the global value is configured in this node.
+      `,
+            infoBoxTitle: 'Get Global Node',
+            contextMenuTitle: 'Get Global',
+            group: ['Advanced'],
+        };
+    }
+    async process(inputs, context) {
+        if (this.data.onDemand) {
+            if (this.data.wait) {
+                throw new Error('Cannot use onDemand and wait together');
+            }
+            return {
+                ['value']: {
+                    type: `fn<${this.data.dataType}>`,
+                    value: () => {
+                        const id = this.data.useIdInput ? coerceType(inputs['id'], 'string') : this.data.id;
+                        const value = context.getGlobal(id);
+                        if (value) {
+                            return value.value;
+                        }
+                        // Have some useful defaults before the value is set
+                        if (isArrayDataType(this.data.dataType)) {
+                            return [];
+                        }
+                        return scalarDefaults[this.data.dataType];
+                    },
+                },
+            };
+        }
+        const id = this.data.useIdInput ? coerceType(inputs['id'], 'string') : this.data.id;
+        let value = this.data.wait ? await context.waitForGlobal(id) : context.getGlobal(id);
+        // Have some useful defaults before the value is set
+        if (!value && isArrayDataType(this.data.dataType)) {
+            value = { type: this.data.dataType, value: [] };
+        }
+        if (!value && isScalarDataType(this.data.dataType)) {
+            value = { type: this.data.dataType, value: scalarDefaults[this.data.dataType] };
+        }
+        return {
+            ['value']: value,
+            ['variable_id_out']: { type: 'string', value: id },
+        };
+    }
+}
+export const getGlobalNode = nodeDefinition(GetGlobalNodeImpl, 'Get Global');

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

@@ -0,0 +1,169 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { dedent } from 'ts-dedent';
+import {} from '../EditorDefinition.js';
+import {} from '../NodeBodySpec.js';
+import { interpolate } from '../../utils/interpolation.js';
+import { keys } from '../../utils/typeSafety.js';
+import { coerceTypeOptional, coerceType } from '../../utils/coerceType.js';
+import { getInputOrData } from '../../utils/index.js';
+export class GptFunctionNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'gptFunction',
+            title: 'GPT Function',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                name: 'newFunction',
+                description: 'No description provided',
+                schema: dedent `
+          {
+            "type": "object",
+            "properties": {}
+          }`,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        let inputs = [];
+        if (this.data.useNameInput) {
+            inputs.push({
+                id: 'name',
+                title: 'Name',
+                dataType: 'string',
+                description: 'The name of the function that GPT will see as available to call',
+            });
+        }
+        if (this.data.useDescriptionInput) {
+            inputs.push({
+                id: 'description',
+                title: 'Description',
+                dataType: 'string',
+                description: 'The description of the function that GPT will see as available to call',
+            });
+        }
+        if (this.data.useSchemaInput) {
+            inputs.push({
+                id: 'schema',
+                title: 'Schema',
+                dataType: 'object',
+                description: 'The schema of the function that GPT will see as available to call',
+            });
+        }
+        // Extract inputs from promptText, everything like {{input}}
+        const inputNames = this.data.useSchemaInput ? [] : [...new Set(this.data.schema.match(/\{\{([^}]+)\}\}/g))];
+        inputs = [
+            ...inputs,
+            ...(inputNames?.map((inputName) => {
+                const name = inputName.slice(2, -2);
+                return {
+                    // id and title should not have the {{ and }}
+                    id: `input-${name}`,
+                    title: name,
+                    dataType: 'string',
+                    description: `An interpolated value in the schema named '${name}'`,
+                };
+            }) ?? []),
+        ];
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'function',
+                title: 'Function',
+                dataType: 'gpt-function',
+                description: 'The GPT function that can be called by the LLM.',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                label: 'Name',
+                dataKey: 'name',
+                useInputToggleDataKey: 'useNameInput',
+            },
+            {
+                type: 'toggle',
+                label: 'Strict',
+                dataKey: 'strict',
+                helperMessage: 'Sets the strict parameter, which determines if OpenAI Structured Outputs are used.',
+            },
+            {
+                type: 'code',
+                label: 'Description',
+                dataKey: 'description',
+                useInputToggleDataKey: 'useDescriptionInput',
+                language: 'markdown',
+                height: 100,
+            },
+            {
+                type: 'custom',
+                customEditorId: 'GptFunctionNodeJsonSchemaAiAssist',
+                label: 'AI Assist',
+            },
+            {
+                type: 'code',
+                label: 'Schema',
+                dataKey: 'schema',
+                language: 'json',
+                useInputToggleDataKey: 'useSchemaInput',
+            },
+        ];
+    }
+    getBody() {
+        return `!markdown_${this.data.name}_: ${this.data.description}`;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Defines a GPT function, which is a method that the LLM can call in its responses.
+      `,
+            infoBoxTitle: 'GPT Function Node',
+            contextMenuTitle: 'GPT Function',
+            group: ['AI'],
+        };
+    }
+    async process(inputs) {
+        const name = getInputOrData(this.data, inputs, 'name');
+        const description = getInputOrData(this.data, inputs, 'description');
+        let schema;
+        if (this.data.useSchemaInput) {
+            schema = coerceType(inputs['schema'], 'object');
+        }
+        else {
+            const inputMap = keys(inputs)
+                .filter((key) => key.startsWith('input'))
+                .reduce((acc, key) => {
+                const stringValue = coerceTypeOptional(inputs[key], 'string') ?? '';
+                const interpolationKey = key.slice('input-'.length);
+                acc[interpolationKey] = stringValue;
+                return acc;
+            }, {});
+            const interpolated = interpolate(this.data.schema, inputMap);
+            schema = JSON.parse(interpolated);
+        }
+        return {
+            ['function']: {
+                type: 'gpt-function',
+                value: {
+                    name,
+                    description,
+                    parameters: schema,
+                    strict: this.data.strict ?? false,
+                },
+            },
+        };
+    }
+}
+export const gptFunctionNode = nodeDefinition(GptFunctionNodeImpl, 'GPT Function');

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

@@ -0,0 +1,130 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { getDefaultValue, isArrayDataType } from '../DataValue.js';
+import {} from '../GraphProcessor.js';
+import {} from '../ProcessContext.js';
+import {} from '../../index.js';
+import { dedent } from 'ts-dedent';
+import { coerceTypeOptional, inferType } from '../../utils/coerceType.js';
+export class GraphInputNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'graphInput',
+            title: 'Graph Input',
+            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',
+            },
+            {
+                type: 'dropdown',
+                label: 'Editor',
+                dataKey: 'editor',
+                defaultValue: 'auto',
+                options: [
+                    { label: 'None', value: 'none' },
+                    { label: 'Auto', value: 'auto' },
+                    { label: 'String', value: 'string' },
+                    { label: 'Number', value: 'number' },
+                    { label: 'Code', value: 'code' },
+                    { label: 'Data Type', value: 'dataTypeSelector' },
+                    { label: 'String List', value: 'stringList' },
+                    { label: 'Key Value Pairs', value: 'keyValuePair' },
+                    { label: 'Toggle', value: 'toggle' },
+                ],
+                helperMessage: 'The editor to use when editing this value in the UI. Make sure this matches the data type.',
+            },
+        ];
+    }
+    getBody() {
+        return dedent `
+      ${this.data.id}
+      Type: ${this.data.dataType}
+      ${this.data.defaultValue == null ? '' : `Default: ${this.data.defaultValue}`}
+    `;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Defines an input for the graph which can be passed in when the graph is called, or defines one of the input ports when the graph is a subgraph.
+      `,
+            infoBoxTitle: 'Graph Input Node',
+            contextMenuTitle: 'Graph Input',
+            group: ['Input/Output'],
+        };
+    }
+    async process(inputs, context) {
+        let inputValue = context.graphInputs[this.data.id] == null
+            ? undefined
+            : coerceTypeOptional(context.graphInputs[this.data.id], this.data.dataType);
+        if (inputValue == null && this.data.useDefaultValueInput) {
+            inputValue = coerceTypeOptional(inputs['default'], this.data.dataType);
+        }
+        if (inputValue == null) {
+            inputValue =
+                coerceTypeOptional(inferType(this.data.defaultValue), this.data.dataType) ||
+                    getDefaultValue(this.data.dataType);
+        }
+        // Resolve undefined for array inputs to empty array
+        if (inputValue == null && isArrayDataType(this.data.dataType)) {
+            inputValue = { type: this.data.dataType, value: [] };
+        }
+        const value = {
+            type: this.data.dataType,
+            value: inputValue,
+        };
+        return { ['data']: value };
+    }
+}
+export const graphInputNode = nodeDefinition(GraphInputNodeImpl, 'Graph Input');

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

@@ -0,0 +1,104 @@
+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 '../GraphProcessor.js';
+import {} from '../ProcessContext.js';
+import { dedent } from 'ts-dedent';
+import {} from '../EditorDefinition.js';
+import {} from '../NodeBodySpec.js';
+export class GraphOutputNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'graphOutput',
+            title: 'Graph Output',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 300,
+            },
+            data: {
+                id: 'output',
+                dataType: 'string',
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        return [
+            {
+                id: 'value',
+                title: this.data.id,
+                dataType: this.chartNode.data.dataType,
+            },
+        ];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'valueOutput',
+                title: this.data.id,
+                dataType: this.chartNode.data.dataType,
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                label: 'ID',
+                dataKey: 'id',
+            },
+            {
+                type: 'dataTypeSelector',
+                label: 'Data Type',
+                dataKey: 'dataType',
+            },
+        ];
+    }
+    getBody() {
+        return dedent `
+      ${this.data.id}
+      Type: ${this.data.dataType}
+    `;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Each instance of this node represents an individual output of the graph. The value passed into this node becomes part of the overall output of the graph.
+      `,
+            infoBoxTitle: 'Graph Output Node',
+            contextMenuTitle: 'Graph Output',
+            group: ['Input/Output'],
+        };
+    }
+    async process(inputs, context) {
+        const value = inputs['value'] ?? { type: 'any', value: undefined };
+        const isExcluded = value.type === 'control-flow-excluded';
+        if (isExcluded && context.graphOutputs[this.data.id] == null) {
+            context.graphOutputs[this.data.id] = {
+                type: 'control-flow-excluded',
+                value: undefined,
+            };
+        }
+        else if ((context.graphOutputs[this.data.id] == null ||
+            context.graphOutputs[this.data.id]?.type === 'control-flow-excluded') &&
+            inputs['value']) {
+            context.graphOutputs[this.data.id] = value;
+        }
+        if (isExcluded) {
+            return {
+                ['valueOutput']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            };
+        }
+        return {
+            ['valueOutput']: context.graphOutputs[this.data.id],
+        };
+    }
+}
+export const graphOutputNode = nodeDefinition(GraphOutputNodeImpl, 'Graph Output');