@alpic80/rivet-core 1.19.1-aidon.1

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

@@ -0,0 +1,79 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import {} from '../GraphProcessor.js';
+import {} from '../../index.js';
+import { nodeDefinition } from '../../model/NodeDefinition.js';
+import { getInputOrData } from '../../utils/index.js';
+export class UrlReferenceNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'urlReference',
+            title: 'URL Reference',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 225,
+            },
+            data: {
+                url: '',
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = [];
+        if (this.data.useUrlInput) {
+            inputs.push({
+                dataType: 'string',
+                id: 'url',
+                title: 'URL',
+                description: 'The value to convert into a URL reference.',
+                coerced: true,
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'object',
+                id: 'urlReference',
+                title: 'URL Reference',
+                description: 'A reference to a URL.',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                label: 'URL',
+                dataKey: 'url',
+                useInputToggleDataKey: 'useUrlInput',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            contextMenuTitle: 'URL Reference',
+            group: 'Data',
+            infoBoxTitle: 'URL Reference Node',
+            infoBoxBody: 'Defines a reference to a URL, or converts a string into a URL reference. Used with the Assemble Message node to define URLs for attachments/images.',
+        };
+    }
+    getBody() {
+        return this.data.useUrlInput ? '(URL Using Input)' : this.data.url;
+    }
+    async process(inputs) {
+        const url = getInputOrData(this.data, inputs, 'url', 'string');
+        return {
+            ['urlReference']: {
+                type: 'object',
+                value: { type: 'url_reference', url },
+            },
+        };
+    }
+}
+export const urlReferenceNode = nodeDefinition(UrlReferenceNodeImpl, 'URL Reference');

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

@@ -0,0 +1,111 @@
+import { NodeImpl } from '../NodeImpl.js';
+import { nanoid } from 'nanoid/non-secure';
+import { zip } from 'lodash-es';
+import {} from '../../index.js';
+import { dedent } from 'ts-dedent';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { coerceType } from '../../utils/coerceType.js';
+export class UserInputNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'userInput',
+            title: 'User Input',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                prompt: 'This is an example question?',
+                useInput: false,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        if (this.chartNode.data.useInput) {
+            return [
+                {
+                    dataType: 'string[]',
+                    id: 'questions',
+                    title: 'Questions',
+                },
+            ];
+        }
+        return [];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'string[]',
+                id: 'output',
+                title: 'Answers Only',
+            },
+            {
+                dataType: 'string[]',
+                id: 'questionsAndAnswers',
+                title: 'Q & A',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'code',
+                label: 'Prompt',
+                dataKey: 'prompt',
+                useInputToggleDataKey: 'useInput',
+                language: 'plain-text',
+            },
+            {
+                type: 'group',
+                label: 'Rendering',
+                editors: [
+                    {
+                        type: 'dropdown',
+                        dataKey: 'renderingFormat',
+                        label: 'Format',
+                        options: [
+                            { label: 'Preformatted', value: 'preformatted' },
+                            { label: 'Markdown', value: 'markdown' },
+                        ],
+                        defaultValue: 'markdown',
+                    },
+                ],
+            },
+        ];
+    }
+    getBody() {
+        return this.data.useInput ? '(Using input)' : this.data.prompt;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Prompts the user for input during the execution of the graph. The user's response becomes the output of this node.
+      `,
+            infoBoxTitle: 'User Input Node',
+            contextMenuTitle: 'User Input',
+            group: ['Input/Output'],
+        };
+    }
+    async process() {
+        return {
+            ['output']: undefined,
+            ['questionsAndAnswers']: undefined,
+        };
+    }
+    getOutputValuesFromUserInput(questions, answers) {
+        const questionsList = this.data.useInput
+            ? coerceType(questions['questions'], 'string[]')
+            : [this.data.prompt];
+        return {
+            ['output']: answers,
+            ['questionsAndAnswers']: {
+                type: 'string[]',
+                value: zip(questionsList, answers.value).map(([q, a]) => `${q}\n${a}`),
+            },
+        };
+    }
+}
+export const userInputNode = nodeDefinition(UserInputNodeImpl, 'User Input');

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

@@ -0,0 +1,127 @@
+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 { getIntegration } from '../../integrations/integrations.js';
+import { getInputOrData } from '../../utils/index.js';
+export class VectorNearestNeighborsNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: nanoid(),
+            type: 'vectorNearestNeighbors',
+            title: 'Vector KNN',
+            visualData: { x: 0, y: 0, width: 200 },
+            data: {
+                k: 10,
+                integration: 'pinecone',
+                collectionId: '',
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [];
+        inputDefinitions.push({
+            id: 'vector',
+            title: 'Vector',
+            dataType: 'vector',
+            required: true,
+        });
+        if (this.data.useIntegrationInput) {
+            inputDefinitions.push({
+                id: 'integration',
+                title: 'Integration',
+                dataType: 'string',
+                required: true,
+            });
+        }
+        if (this.data.useCollectionIdInput) {
+            inputDefinitions.push({
+                id: 'collectionId',
+                title: 'Collection ID',
+                dataType: 'string',
+                required: true,
+            });
+        }
+        if (this.data.useKInput) {
+            inputDefinitions.push({
+                id: 'k',
+                title: 'K',
+                dataType: 'number',
+                required: true,
+            });
+        }
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        const outputs = [
+            {
+                id: 'results',
+                title: 'Results',
+                dataType: 'any[]',
+            },
+        ];
+        return outputs;
+    }
+    getEditors() {
+        return [
+            {
+                type: 'dropdown',
+                label: 'Integration',
+                dataKey: 'integration',
+                options: [{ label: 'Pinecone', value: 'pinecone' }],
+                useInputToggleDataKey: 'useIntegrationInput',
+            },
+            {
+                type: 'number',
+                label: 'K',
+                dataKey: 'k',
+                min: 1,
+                max: 100,
+                step: 1,
+                defaultValue: 10,
+                useInputToggleDataKey: 'useKInput',
+            },
+            {
+                type: 'string',
+                label: 'Collection ID',
+                dataKey: 'collectionId',
+                useInputToggleDataKey: 'useCollectionIdInput',
+            },
+        ];
+    }
+    getBody() {
+        return dedent `
+      Integration: ${this.data.useIntegrationInput ? '(using input)' : this.data.integration}
+      K: ${this.data.useKInput ? '(using input)' : this.data.k}
+      Collection Id: ${this.data.useCollectionIdInput ? '(using input)' : this.data.collectionId}
+    `;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Performs a k-nearest neighbors search on the vectors stored in the configured vector DB integration. Takes in a vector and returns the k closest vectors and their corresponding data.
+      `,
+            infoBoxTitle: 'Vector KNN Node',
+            contextMenuTitle: 'Vector KNN',
+            group: ['Input/Output'],
+        };
+    }
+    async process(inputs, context) {
+        const integration = getInputOrData(this.data, inputs, 'integration');
+        const vectorDb = getIntegration('vectorDatabase', integration, context);
+        const indexUrl = getInputOrData(this.data, inputs, 'collectionId');
+        const k = getInputOrData(this.data, inputs, 'k', 'number');
+        if (inputs['vector']?.type !== 'vector') {
+            throw new Error(`Expected vector input, got ${inputs['vector']?.type}`);
+        }
+        const results = await vectorDb.nearestNeighbors({ type: 'string', value: indexUrl }, inputs['vector'], k);
+        return {
+            ['results']: results,
+        };
+    }
+}
+export const vectorNearestNeighborsNode = nodeDefinition(VectorNearestNeighborsNodeImpl, 'Vector KNN');

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

@@ -0,0 +1,124 @@
+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 { getIntegration } from '../../integrations/integrations.js';
+import { getInputOrData } from '../../utils/index.js';
+import { coerceTypeOptional } from '../../utils/coerceType.js';
+export class VectorStoreNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: nanoid(),
+            type: 'vectorStore',
+            title: 'Vector Store',
+            visualData: { x: 0, y: 0, width: 200 },
+            data: {
+                integration: 'pinecone',
+                collectionId: '',
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [];
+        inputDefinitions.push({
+            id: 'vector',
+            title: 'Vector',
+            dataType: 'vector',
+            required: true,
+        });
+        if (this.data.useCollectionIdInput) {
+            inputDefinitions.push({
+                id: 'collectionId',
+                title: 'Collection ID',
+                dataType: 'string',
+                required: true,
+            });
+        }
+        inputDefinitions.push({
+            id: 'data',
+            title: 'Data',
+            dataType: 'any',
+            required: true,
+        });
+        if (this.data.useIntegrationInput) {
+            inputDefinitions.push({
+                id: 'integration',
+                title: 'Integration',
+                dataType: 'string',
+                required: true,
+            });
+        }
+        inputDefinitions.push({
+            id: 'id',
+            title: 'ID',
+            dataType: 'string',
+            required: false,
+        });
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        const outputs = [
+            {
+                id: 'complete',
+                title: 'Complete',
+                dataType: 'boolean',
+            },
+        ];
+        return outputs;
+    }
+    getEditors() {
+        return [
+            {
+                type: 'dropdown',
+                label: 'Integration',
+                dataKey: 'integration',
+                options: [{ label: 'Pinecone', value: 'pinecone' }],
+                useInputToggleDataKey: 'useIntegrationInput',
+            },
+            {
+                type: 'string',
+                label: 'Collection ID',
+                dataKey: 'collectionId',
+                useInputToggleDataKey: 'useCollectionIdInput',
+            },
+        ];
+    }
+    getBody() {
+        return dedent `
+      Integration: ${this.data.useIntegrationInput ? '(using input)' : this.data.integration}
+      Collection Id: ${this.data.useCollectionIdInput ? '(using input)' : this.data.collectionId}
+    `;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Takes in a vector, as well as data to store with the vector. This data is stored in the configured vector DB integration for later retrieval.
+      `,
+            infoBoxTitle: 'Vector Store Node',
+            contextMenuTitle: 'Vector Store',
+            group: ['Input/Output'],
+        };
+    }
+    async process(inputs, context) {
+        const integration = getInputOrData(this.data, inputs, 'integration');
+        const vectorDb = getIntegration('vectorDatabase', integration, context);
+        const indexUrl = getInputOrData(this.data, inputs, 'collectionId');
+        if (inputs['vector']?.type !== 'vector') {
+            throw new Error(`Expected vector input, got ${inputs['vector']?.type}`);
+        }
+        await vectorDb.store({ type: 'string', value: indexUrl }, inputs['vector'], inputs['data'], {
+            id: coerceTypeOptional(inputs['id'], 'string'),
+        });
+        return {
+            ['complete']: {
+                type: 'boolean',
+                value: true,
+            },
+        };
+    }
+}
+export const vectorStoreNode = nodeDefinition(VectorStoreNodeImpl, 'Vector Store');

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

@@ -0,0 +1,88 @@
+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 { coerceType } from '../../utils/coerceType.js';
+import {} from '../ProcessContext.js';
+import { dedent } from 'ts-dedent';
+import {} from '../EditorDefinition.js';
+import {} from '../NodeBodySpec.js';
+export class WaitForEventNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: nanoid(),
+            type: 'waitForEvent',
+            title: 'Wait For Event',
+            visualData: { x: 0, y: 0, width: 150 },
+            data: {
+                eventName: 'continue',
+                useEventNameInput: false,
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [];
+        if (this.chartNode.data.useEventNameInput) {
+            inputDefinitions.push({
+                id: 'eventName',
+                title: 'Event Name',
+                dataType: 'string',
+            });
+        }
+        inputDefinitions.push({
+            id: 'inputData',
+            title: 'Data',
+            dataType: 'any',
+        });
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'outputData',
+                title: 'Data',
+                dataType: 'any',
+            },
+            {
+                id: 'eventData',
+                title: 'Event Data',
+                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 `
+        Waits for a specific event to be raised by a 'Raise Event' node or the host project. The event name can be configured.
+      `,
+            infoBoxTitle: 'Wait For Event Node',
+            contextMenuTitle: 'Wait For Event',
+            group: ['Advanced'],
+        };
+    }
+    async process(inputs, context) {
+        const eventName = this.chartNode.data.useEventNameInput
+            ? coerceType(inputs['eventName'], 'string')
+            : this.chartNode.data.eventName;
+        const eventData = await context.waitEvent(eventName);
+        return {
+            ['outputData']: inputs['inputData'],
+            ['eventData']: eventData,
+        };
+    }
+}
+export const waitForEventNode = nodeDefinition(WaitForEventNodeImpl, 'Wait For Event');

package/dist/esm/native/BaseDir.js

@@ -0,0 +1,32 @@
+export const baseDirs = {
+    app: 'app',
+    appCache: 'appCache',
+    appConfig: 'appConfig',
+    appData: 'appData',
+    appLocalData: 'appLocalData',
+    appLog: 'appLog',
+    audio: 'audio',
+    cache: 'cache',
+    config: 'config',
+    data: 'data',
+    desktop: 'desktop',
+    document: 'document',
+    download: 'download',
+    executable: 'executable',
+    font: 'font',
+    home: 'home',
+    localData: 'localData',
+    log: 'log',
+    picture: 'picture',
+    public: 'public',
+    resource: 'resource',
+    runtime: 'runtime',
+    temp: 'temp',
+    template: 'template',
+    video: 'video',
+};
+export function assertBaseDir(baseDir) {
+    if (!(baseDir in baseDirs)) {
+        throw new Error(`Invalid base directory: ${baseDir}`);
+    }
+}

package/dist/esm/native/BrowserNativeApi.js

@@ -0,0 +1,19 @@
+import {} from './BaseDir.js';
+import {} from './NativeApi.js';
+export class BrowserNativeApi {
+    readdir(_path, _baseDir) {
+        throw new Error('Method not implemented.');
+    }
+    readTextFile(_path, _baseDir) {
+        throw new Error('Method not implemented.');
+    }
+    readBinaryFile(_path, _baseDir) {
+        throw new Error('Method not implemented.');
+    }
+    writeTextFile(_path, _data, _baseDir) {
+        throw new Error('Method not implemented.');
+    }
+    exec(command, args, options) {
+        throw new Error('Method not supported.');
+    }
+}

package/dist/esm/native/NativeApi.js

@@ -0,0 +1 @@
+import {} from './BaseDir.js';

package/dist/esm/plugins/aidon/index.js

@@ -0,0 +1,2 @@
+import { aidonPlugin } from './plugin.js';
+export default aidonPlugin;