@alpic80/rivet-core 1.19.1-aidon.1

package/dist/esm/plugins/huggingface/nodes/TextToImageHuggingFace.js

@@ -0,0 +1,189 @@
+import { nanoid } from 'nanoid/non-secure';
+import {} from '../../../index.js';
+import { HfInference, HfInferenceEndpoint } from '@huggingface/inference';
+import { dedent } from 'ts-dedent';
+import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
+import { getInputOrData } from '../../../utils/inputs.js';
+import { coerceType } from '../../../utils/coerceType.js';
+export const TextToImageHuggingFaceNodeImpl = {
+    create() {
+        return {
+            id: nanoid(),
+            type: 'textToImageHuggingFace',
+            data: {
+                model: '',
+                width: 256,
+                height: 256,
+                negativePrompt: '',
+                guidanceScale: 7,
+                numInferenceSteps: 3,
+            },
+            title: 'Text-to-Image (Hugging Face)',
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 300,
+            },
+        };
+    },
+    getUIData() {
+        return {
+            group: ['AI', 'Hugging Face'],
+            contextMenuTitle: 'Text-to-Image (Hugging Face)',
+            infoBoxTitle: 'Text-to-Image (Hugging Face) Node',
+            infoBoxBody: 'Use the Hugging Face API to generate an image from text.',
+        };
+    },
+    getInputDefinitions(data) {
+        const inputs = [];
+        inputs.push({
+            id: 'prompt',
+            dataType: 'string',
+            title: 'Prompt',
+            required: true,
+        });
+        if (data.useModelInput) {
+            inputs.push({
+                id: 'model',
+                dataType: 'string',
+                title: 'Model',
+            });
+        }
+        if (data.useEndpointInput) {
+            inputs.push({
+                id: 'endpoint',
+                dataType: 'string',
+                title: 'Endpoint',
+            });
+        }
+        if (data.useWidthInput) {
+            inputs.push({
+                id: 'width',
+                dataType: 'number',
+                title: 'Width',
+            });
+        }
+        if (data.useHeightInput) {
+            inputs.push({
+                id: 'height',
+                dataType: 'number',
+                title: 'Height',
+            });
+        }
+        if (data.useNegativePromptInput) {
+            inputs.push({
+                id: 'negativePrompt',
+                dataType: 'string',
+                title: 'Negative Prompt',
+            });
+        }
+        if (data.useGuidanceScaleInput) {
+            inputs.push({
+                id: 'guidanceScale',
+                dataType: 'number',
+                title: 'Guidance Scale',
+            });
+        }
+        if (data.useNumInferenceStepsInput) {
+            inputs.push({
+                id: 'numInferenceSteps',
+                dataType: 'number',
+                title: 'Num Inference Steps',
+            });
+        }
+        return inputs;
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'output',
+                dataType: 'string',
+                title: 'Output',
+            },
+        ];
+    },
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                label: 'Model',
+                dataKey: 'model',
+                useInputToggleDataKey: 'useModelInput',
+            },
+            {
+                type: 'number',
+                label: 'Width',
+                dataKey: 'width',
+                useInputToggleDataKey: 'useWidthInput',
+            },
+            {
+                type: 'number',
+                label: 'Height',
+                dataKey: 'height',
+                useInputToggleDataKey: 'useHeightInput',
+            },
+            {
+                type: 'string',
+                label: 'Negative Prompt',
+                dataKey: 'negativePrompt',
+                useInputToggleDataKey: 'useNegativePromptInput',
+            },
+            {
+                type: 'number',
+                label: 'Guidance Scale',
+                dataKey: 'guidanceScale',
+                useInputToggleDataKey: 'useGuidanceScaleInput',
+                min: 0,
+                max: 20,
+                step: 1,
+            },
+            {
+                type: 'number',
+                label: 'Num Inference Steps',
+                dataKey: 'numInferenceSteps',
+                useInputToggleDataKey: 'useNumInferenceStepsInput',
+                min: 0,
+                max: 20,
+                step: 1,
+            },
+        ];
+    },
+    getBody(data) {
+        return dedent `
+      Model: ${data.useModelInput ? '(Using Input)' : data.model}
+    `;
+    },
+    async process(data, inputData, context) {
+        const accessToken = context.getPluginConfig('huggingFaceAccessToken');
+        const prompt = coerceType(inputData['prompt'], 'string');
+        const endpoint = getInputOrData(data, inputData, 'endpoint');
+        const model = getInputOrData(data, inputData, 'model');
+        const width = getInputOrData(data, inputData, 'width', 'number');
+        const height = getInputOrData(data, inputData, 'height', 'number');
+        const negativePrompt = getInputOrData(data, inputData, 'negativePrompt') || undefined;
+        const guidanceScale = getInputOrData(data, inputData, 'guidanceScale', 'number');
+        const numInferenceSteps = getInputOrData(data, inputData, 'numInferenceSteps', 'number');
+        const hf = endpoint ? new HfInferenceEndpoint(endpoint, accessToken) : new HfInference(accessToken);
+        const image = await hf.textToImage({
+            inputs: prompt,
+            model,
+            parameters: {
+                width,
+                height,
+                negative_prompt: negativePrompt,
+                guidance_scale: guidanceScale,
+                num_inference_steps: numInferenceSteps,
+            },
+        });
+        return {
+            ['output']: {
+                type: 'image',
+                value: {
+                    mediaType: 'image/png',
+                    data: new Uint8Array(await image.arrayBuffer()),
+                },
+            },
+        };
+    },
+};
+export const textToImageHuggingFaceNode = pluginNodeDefinition(TextToImageHuggingFaceNodeImpl, 'Text-to-Image (Hugging Face)');

package/dist/esm/plugins/huggingface/plugin.js

@@ -0,0 +1,26 @@
+import {} from '../../index.js';
+import { chatHuggingFaceNode } from './nodes/ChatHuggingFace.js';
+import { textToImageHuggingFaceNode } from './nodes/TextToImageHuggingFace.js';
+export const huggingFacePlugin = {
+    id: 'huggingface',
+    name: 'Hugging Face',
+    configSpec: {
+        huggingFaceAccessToken: {
+            type: 'secret',
+            label: 'Hugging Face Access Token',
+            description: 'Your access token for the Hugging Face API.',
+            pullEnvironmentVariable: 'HUGGING_FACE_ACCESS_TOKEN',
+            helperText: 'Create at https://huggingface.co/settings/tokens',
+        },
+    },
+    contextMenuGroups: [
+        {
+            id: 'huggingFace',
+            label: 'Hugging Face',
+        },
+    ],
+    register(register) {
+        register(chatHuggingFaceNode);
+        register(textToImageHuggingFaceNode);
+    },
+};

package/dist/esm/plugins/openai/handleOpenaiError.js

@@ -0,0 +1,17 @@
+export async function handleOpenAIError(response) {
+    if (!response.ok) {
+        let errorBody;
+        try {
+            errorBody = await response.json();
+        }
+        catch (err) {
+            throw new Error(`OpenAI request failed, no JSON body. Status code: ${response.status}`);
+        }
+        if (errorBody?.error?.message) {
+            throw new Error(errorBody.error.message);
+        }
+        else {
+            throw new Error(`OpenAI request failed with body. Status code: ${response.status}: ${JSON.stringify(errorBody)}`);
+        }
+    }
+}

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

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

package/dist/esm/plugins/openai/nodes/AttachAssistantFileNode.js

@@ -0,0 +1,123 @@
+import {} from '../../../index.js';
+import { dedent, newId, getInputOrData } from '../../../utils/index.js';
+import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
+import { handleOpenAIError } from '../handleOpenaiError.js';
+export const AttachAssistantFileNodeImpl = {
+    create() {
+        return {
+            id: newId(),
+            type: 'openaiAttachAssistantFile',
+            data: {
+                useAssistantIdInput: true,
+                useFileIdInput: true,
+            },
+            title: 'Attach Assistant File',
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 225,
+            },
+        };
+    },
+    getUIData() {
+        return {
+            group: 'OpenAI',
+            contextMenuTitle: 'Attach Assistant File',
+            infoBoxTitle: 'Attach Assistant File Node',
+            infoBoxBody: 'Attach a file to an OpenAI assistant.',
+        };
+    },
+    getInputDefinitions(data) {
+        const inputs = [];
+        if (data.useAssistantIdInput) {
+            inputs.push({
+                id: 'assistantId',
+                dataType: 'string',
+                title: 'Assistant ID',
+                coerced: true,
+                defaultValue: '',
+                description: 'The ID of the assistant to attach the file to.',
+                required: true,
+            });
+        }
+        if (data.useFileIdInput) {
+            inputs.push({
+                id: 'fileId',
+                dataType: 'string',
+                title: 'File ID',
+                coerced: true,
+                defaultValue: '',
+                description: 'The ID of the file to attach.',
+                required: true,
+            });
+        }
+        return inputs;
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'fileId',
+                dataType: 'string',
+                title: 'File ID',
+                description: 'The ID of the attached file.',
+            },
+        ];
+    },
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                dataKey: 'assistantId',
+                useInputToggleDataKey: 'useAssistantIdInput',
+                label: 'Assistant ID',
+            },
+            {
+                type: 'string',
+                dataKey: 'fileId',
+                useInputToggleDataKey: 'useFileIdInput',
+                label: 'File ID',
+            },
+        ];
+    },
+    getBody(data) {
+        return dedent `
+      Assistant ID: ${data.useAssistantIdInput ? '(From Input)' : data.assistantId}
+      File ID: ${data.useFileIdInput ? '(From Input)' : data.fileId}
+    `;
+    },
+    async process(data, inputData, context) {
+        const assistantId = getInputOrData(data, inputData, 'assistantId');
+        const fileId = getInputOrData(data, inputData, 'fileId');
+        if (!context.settings.openAiKey) {
+            throw new Error('OpenAI key is not set.');
+        }
+        const url = `https://api.openai.com/v1/assistants/${assistantId}/files`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'OpenAI-Beta': 'assistants=v1',
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${context.settings.openAiKey}`,
+                'OpenAI-Organization': context.settings.openAiOrganization ?? '',
+            },
+            body: JSON.stringify({ file_id: fileId }),
+        });
+        if (response.status === 404) {
+            return {
+                ['fileId']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            };
+        }
+        await handleOpenAIError(response);
+        const body = (await response.json());
+        return {
+            ['fileId']: {
+                type: 'string',
+                value: body.id,
+            },
+        };
+    },
+};
+export const attachAssistantFileNode = pluginNodeDefinition(AttachAssistantFileNodeImpl, 'Attach Assistant File');

package/dist/esm/plugins/openai/nodes/CreateAssistantNode.js

@@ -0,0 +1,289 @@
+import {} from '../../../index.js';
+import { openAiModelOptions } from '../../../utils/openai.js';
+import { dedent, newId, coerceTypeOptional, getInputOrData } from '../../../utils/index.js';
+import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
+import { handleOpenAIError } from '../handleOpenaiError.js';
+export const CreateAssistantNodeImpl = {
+    create() {
+        return {
+            id: newId(),
+            type: 'openaiCreateAssistant',
+            data: {
+                assistantId: '',
+                useAssistantIdInput: false,
+                model: '',
+                useModelInput: false,
+                name: '',
+                useNameInput: false,
+                description: '',
+                useDescriptionInput: false,
+                instructions: '',
+                useInstructionsInput: false,
+                tools: [],
+                file_ids: [],
+                useFileIdsInput: false,
+                metadata: [],
+                useMetadataInput: false,
+            },
+            title: 'Create Assistant',
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 300,
+            },
+        };
+    },
+    getUIData() {
+        return {
+            group: 'OpenAI',
+            contextMenuTitle: 'Create Assistant',
+            infoBoxTitle: 'Create Assistant Node',
+            infoBoxBody: 'Create a new assistant for OpenAI.',
+        };
+    },
+    getInputDefinitions(data) {
+        const inputs = [];
+        if (data.useAssistantIdInput) {
+            inputs.push({
+                id: 'assistantId',
+                dataType: 'string',
+                title: 'Assistant ID',
+                coerced: true,
+                defaultValue: '',
+                description: 'The ID of the assistant to modify. Leave empty to create a new assistant.',
+            });
+        }
+        if (data.useModelInput) {
+            inputs.push({
+                id: 'model',
+                dataType: 'string',
+                title: 'Model',
+                coerced: true,
+                defaultValue: '',
+                description: 'ID of the model to use.',
+                required: false,
+            });
+        }
+        if (data.useNameInput) {
+            inputs.push({
+                id: 'name',
+                dataType: 'string',
+                title: 'Name',
+                coerced: true,
+                defaultValue: '',
+                description: 'The name of the assistant.',
+                required: false,
+            });
+        }
+        if (data.useDescriptionInput) {
+            inputs.push({
+                id: 'description',
+                dataType: 'string',
+                title: 'Description',
+                coerced: true,
+                defaultValue: '',
+                description: 'The description of the assistant.',
+                required: false,
+            });
+        }
+        if (data.useInstructionsInput) {
+            inputs.push({
+                id: 'instructions',
+                dataType: 'string',
+                title: 'Instructions',
+                coerced: true,
+                defaultValue: '',
+                description: 'The system instructions that the assistant uses.',
+                required: false,
+            });
+        }
+        inputs.push({
+            id: 'functions',
+            dataType: 'object[]',
+            title: 'Functions',
+            coerced: true,
+            defaultValue: [],
+            description: 'A list of GPT functions enabled on the assistant.',
+            required: false,
+        });
+        if (data.useFileIdsInput) {
+            inputs.push({
+                id: 'file_ids',
+                dataType: 'string[]',
+                title: 'File IDs',
+                coerced: true,
+                defaultValue: [],
+                description: 'A list of file IDs attached to this assistant.',
+                required: false,
+            });
+        }
+        if (data.useMetadataInput) {
+            inputs.push({
+                id: 'metadata',
+                dataType: 'object',
+                title: 'Metadata',
+                coerced: true,
+                defaultValue: {},
+                description: 'Metadata to attach to the assistant.',
+                required: false,
+            });
+        }
+        return inputs;
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'assistantId',
+                dataType: 'string',
+                title: 'Assistant ID',
+                description: 'The ID of the created assistant.',
+            },
+            {
+                id: 'assistant',
+                dataType: 'object',
+                title: 'Assistant',
+                description: 'The full created assistant object.',
+            },
+        ];
+    },
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                dataKey: 'assistantId',
+                useInputToggleDataKey: 'useAssistantIdInput',
+                label: 'Existing Assistant ID',
+                placeholder: 'Existing assistant ID',
+                helperMessage: 'Leave empty to create a new assistant.',
+            },
+            {
+                type: 'dropdown',
+                dataKey: 'model',
+                useInputToggleDataKey: 'useModelInput',
+                label: 'Model',
+                options: openAiModelOptions,
+                defaultValue: 'gpt-4-turbo',
+            },
+            {
+                type: 'string',
+                dataKey: 'name',
+                useInputToggleDataKey: 'useNameInput',
+                label: 'Name',
+                placeholder: 'Enter assistant name',
+                maxLength: 256,
+                autoFocus: true,
+            },
+            {
+                type: 'string',
+                dataKey: 'description',
+                useInputToggleDataKey: 'useDescriptionInput',
+                label: 'Description',
+                placeholder: 'Enter assistant description',
+                maxLength: 512,
+            },
+            {
+                type: 'code',
+                dataKey: 'instructions',
+                useInputToggleDataKey: 'useInstructionsInput',
+                label: 'Instructions',
+                language: 'markdown',
+            },
+            {
+                type: 'toggle',
+                dataKey: 'useCodeInterpreterTool',
+                label: 'Code Interpreter Tool Enabled',
+            },
+            {
+                type: 'toggle',
+                dataKey: 'useRetrievalTool',
+                label: 'Retrieval Tool Enabled',
+            },
+            {
+                type: 'stringList',
+                dataKey: 'file_ids',
+                useInputToggleDataKey: 'useFileIdsInput',
+                label: 'File IDs',
+            },
+            {
+                type: 'keyValuePair',
+                dataKey: 'metadata',
+                useInputToggleDataKey: 'useMetadataInput',
+                label: 'Metadata',
+                keyPlaceholder: 'Key',
+                valuePlaceholder: 'Value',
+            },
+        ];
+    },
+    getBody(data) {
+        return dedent `
+      Model: ${data.useModelInput ? '(Model From Input)' : data.model}
+      Name: ${data.useNameInput ? '(Name From Input)' : data.name}
+      Description: ${data.useDescriptionInput ? '(Description From Input)' : data.description}
+      File IDs: ${data.useFileIdsInput ? '(File IDs From Input)' : JSON.stringify(data.file_ids)}
+      Metadata: ${data.useMetadataInput
+            ? '(Metadata From Input)'
+            : data.metadata.map(({ key, value }) => `${key}=${value}`).join(', ')}
+
+      ${data.useInstructionsInput ? '(Instructions From Input)' : data.instructions}
+    `;
+    },
+    async process(data, inputData, context) {
+        const assistantId = getInputOrData(data, inputData, 'assistantId');
+        let metadata = data.metadata.reduce((acc, { key, value }) => {
+            acc[key] = value;
+            return acc;
+        }, {});
+        if (data.useMetadataInput && inputData['metadata']) {
+            metadata = coerceTypeOptional(inputData['metadata'], 'object');
+        }
+        const functionTools = coerceTypeOptional(inputData['functions'], 'gpt-function[]');
+        const tools = [...(functionTools?.map((f) => ({ type: 'function', function: f })) ?? [])];
+        if (data.useCodeInterpreterTool) {
+            tools.push({ type: 'code_interpreter' });
+        }
+        if (data.useRetrievalTool) {
+            tools.push({ type: 'retrieval' });
+        }
+        const requestBody = {
+            model: getInputOrData(data, inputData, 'model'),
+            name: getInputOrData(data, inputData, 'name'),
+            description: getInputOrData(data, inputData, 'description'),
+            instructions: getInputOrData(data, inputData, 'instructions'),
+            tools,
+            file_ids: getInputOrData(data, inputData, 'file_ids', 'string[]'),
+            metadata,
+        };
+        if (!requestBody.model?.trim() || !requestBody.name?.trim()) {
+            throw new Error('Model and name are required.');
+        }
+        if (!context.settings.openAiKey) {
+            throw new Error('OpenAI key is not set.');
+        }
+        const url = assistantId.trim()
+            ? `https://api.openai.com/v1/assistants/${assistantId}`
+            : 'https://api.openai.com/v1/assistants';
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'OpenAI-Beta': 'assistants=v1',
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${context.settings.openAiKey}`,
+                'OpenAI-Organization': context.settings.openAiOrganization ?? '',
+            },
+            body: JSON.stringify(requestBody),
+        });
+        await handleOpenAIError(response);
+        const body = await response.json();
+        return {
+            ['assistantId']: {
+                type: 'string',
+                value: body.id,
+            },
+            ['assistant']: {
+                type: 'object',
+                value: body,
+            },
+        };
+    },
+};
+export const createAssistantNode = pluginNodeDefinition(CreateAssistantNodeImpl, 'Create Assistant');