@alpic80/rivet-core 1.19.1-aidon.1

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

@@ -0,0 +1,100 @@
+import {} from '../../../index.js';
+import { newId, getInputOrData, dedent } from '../../../utils/index.js';
+import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
+import { handleOpenAIError } from '../handleOpenaiError.js';
+export const GetOpenAIFileNodeImpl = {
+    create() {
+        return {
+            id: newId(),
+            type: 'openaiGetFile',
+            data: {
+                useFileIdInput: true,
+            },
+            title: 'Get OpenAI File',
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 300,
+            },
+        };
+    },
+    getUIData() {
+        return {
+            group: 'OpenAI',
+            contextMenuTitle: 'Get OpenAI File',
+            infoBoxTitle: 'Get OpenAI File Node',
+            infoBoxBody: 'Get a specific file from OpenAI.',
+        };
+    },
+    getInputDefinitions(data) {
+        const inputs = [];
+        if (data.useFileIdInput) {
+            inputs.push({
+                id: 'fileId',
+                dataType: 'string',
+                title: 'File ID',
+                coerced: true,
+                defaultValue: '',
+                description: 'The ID of the file to retrieve.',
+                required: true,
+            });
+        }
+        return inputs;
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'file',
+                dataType: 'object',
+                title: 'File',
+                description: 'The retrieved file object.',
+            },
+        ];
+    },
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                dataKey: 'fileId',
+                useInputToggleDataKey: 'useFileIdInput',
+                label: 'File ID',
+            },
+        ];
+    },
+    getBody(data) {
+        return dedent `
+      File ID: ${data.fileId ?? 'Unknown'}
+    `;
+    },
+    async process(data, inputData, context) {
+        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/files/${fileId}`;
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${context.settings.openAiKey}`,
+                'OpenAI-Organization': context.settings.openAiOrganization ?? '',
+            },
+        });
+        if (response.status === 404) {
+            return {
+                ['file']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            };
+        }
+        await handleOpenAIError(response);
+        const body = await response.json();
+        return {
+            ['file']: {
+                type: 'object',
+                value: body,
+            },
+        };
+    },
+};
+export const getOpenAIFileNode = pluginNodeDefinition(GetOpenAIFileNodeImpl, 'Get OpenAI File');

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

@@ -0,0 +1,108 @@
+import {} from '../../../index.js';
+import { newId, dedent } from '../../../utils/index.js';
+import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
+export const GetThreadNodeImpl = {
+    create() {
+        return {
+            id: newId(),
+            type: 'openaiGetThread',
+            data: {
+                threadId: '',
+                useThreadIdInput: true,
+            },
+            title: 'Get Thread',
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 225,
+            },
+        };
+    },
+    getUIData() {
+        return {
+            group: 'OpenAI',
+            contextMenuTitle: 'Get Thread',
+            infoBoxTitle: 'Get Thread Node',
+            infoBoxBody: 'Retrieve an existing thread from OpenAI assistants.',
+        };
+    },
+    getInputDefinitions(data) {
+        const inputs = [];
+        if (data.useThreadIdInput) {
+            inputs.push({
+                id: 'threadId',
+                dataType: 'string',
+                title: 'Thread ID',
+                description: 'The ID of the thread to retrieve.',
+                required: true,
+            });
+        }
+        return inputs;
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'thread',
+                dataType: 'object',
+                title: 'Thread',
+                description: 'The retrieved thread object. If the thread does not exist, this port will not be ran. You can use an If node to test whether the thread exists.',
+            },
+        ];
+    },
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                dataKey: 'threadId',
+                useInputToggleDataKey: 'useThreadIdInput',
+                label: 'Thread ID',
+                autoFocus: true,
+            },
+        ];
+    },
+    getBody(data) {
+        return dedent `
+      ${data.useThreadIdInput ? '(Thread ID from input)' : `Thread ID: ${data.threadId}`}
+    `;
+    },
+    async process(data, inputData, context) {
+        let threadId = data.threadId;
+        if (data.useThreadIdInput) {
+            threadId = inputData['threadId']?.value;
+            if (!threadId) {
+                throw new Error('Thread ID is required.');
+            }
+        }
+        if (!context.settings.openAiKey) {
+            throw new Error('OpenAI key is not set.');
+        }
+        const response = await fetch(`https://api.openai.com/v1/threads/${threadId}`, {
+            method: 'GET',
+            headers: {
+                'OpenAI-Beta': 'assistants=v1',
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${context.settings.openAiKey}`,
+                'OpenAI-Organization': context.settings.openAiOrganization ?? '',
+            },
+        });
+        if (response.status === 404) {
+            return {
+                ['thread']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            };
+        }
+        if (!response.ok) {
+            throw new Error('Failed to get thread.');
+        }
+        const body = (await response.json());
+        return {
+            ['thread']: {
+                type: 'object',
+                value: body,
+            },
+        };
+    },
+};
+export const getThreadNode = pluginNodeDefinition(GetThreadNodeImpl, 'Get Thread');

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

@@ -0,0 +1,202 @@
+import {} from '../../../index.js';
+import { newId, getInputOrData, dedent } from '../../../utils/index.js';
+import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
+import { handleOpenAIError } from '../handleOpenaiError.js';
+export const ListAssistantsNodeImpl = {
+    create() {
+        return {
+            id: newId(),
+            type: 'openaiListAssistants',
+            data: {
+                limit: 20,
+                useLimitInput: false,
+                order: 'asc',
+                useOrderInput: false,
+                after: '',
+                useAfterInput: false,
+                before: '',
+                useBeforeInput: false,
+            },
+            title: 'List Assistants',
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 300,
+            },
+        };
+    },
+    getUIData() {
+        return {
+            group: 'OpenAI',
+            contextMenuTitle: 'List Assistants',
+            infoBoxTitle: 'List Assistants Node',
+            infoBoxBody: 'List assistants from OpenAI.',
+        };
+    },
+    getInputDefinitions(data) {
+        const inputs = [];
+        if (data.useLimitInput) {
+            inputs.push({
+                id: 'limit',
+                dataType: 'number',
+                title: 'Limit',
+                coerced: true,
+                defaultValue: 20,
+                description: 'A limit on the number of objects to be returned.',
+                required: false,
+            });
+        }
+        if (data.useOrderInput) {
+            inputs.push({
+                id: 'order',
+                dataType: 'string',
+                title: 'Order',
+                coerced: true,
+                defaultValue: 'asc',
+                description: 'Sort order by the created_at timestamp of the objects.',
+                required: false,
+            });
+        }
+        if (data.useAfterInput) {
+            inputs.push({
+                id: 'after',
+                dataType: 'string',
+                title: 'After',
+                coerced: true,
+                defaultValue: '',
+                description: 'A cursor for use in pagination.',
+                required: false,
+            });
+        }
+        if (data.useBeforeInput) {
+            inputs.push({
+                id: 'before',
+                dataType: 'string',
+                title: 'Before',
+                coerced: true,
+                defaultValue: '',
+                description: 'A cursor for use in pagination.',
+                required: false,
+            });
+        }
+        return inputs;
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'assistants',
+                dataType: 'object[]',
+                title: 'Assistants',
+                description: 'The list of assistants.',
+            },
+            {
+                id: 'first_id',
+                dataType: 'string',
+                title: 'First ID',
+                description: 'The ID of the first assistant in the list.',
+            },
+            {
+                id: 'last_id',
+                dataType: 'string',
+                title: 'Last ID',
+                description: 'The ID of the last assistant in the list.',
+            },
+            {
+                id: 'has_more',
+                dataType: 'boolean',
+                title: 'Has More',
+                description: 'Whether there are more assistants to be retrieved.',
+            },
+        ];
+    },
+    getEditors() {
+        return [
+            {
+                type: 'number',
+                dataKey: 'limit',
+                useInputToggleDataKey: 'useLimitInput',
+                label: 'Limit',
+                defaultValue: 20,
+                min: 1,
+                max: 100,
+            },
+            {
+                type: 'dropdown',
+                dataKey: 'order',
+                useInputToggleDataKey: 'useOrderInput',
+                label: 'Order',
+                options: [
+                    { value: 'asc', label: 'Ascending' },
+                    { value: 'desc', label: 'Descending' },
+                ],
+                defaultValue: 'asc',
+            },
+            {
+                type: 'string',
+                dataKey: 'after',
+                useInputToggleDataKey: 'useAfterInput',
+                label: 'After',
+                placeholder: 'Enter after cursor',
+            },
+            {
+                type: 'string',
+                dataKey: 'before',
+                useInputToggleDataKey: 'useBeforeInput',
+                label: 'Before',
+                placeholder: 'Enter before cursor',
+            },
+        ];
+    },
+    getBody(data) {
+        return dedent `
+      Limit: ${data.useLimitInput ? '(Limit From Input)' : data.limit}, ${data.useOrderInput ? '(Order From Input)' : data.order === 'asc' ? 'Ascending' : 'Descending'}
+${data.useAfterInput || data.after?.trim() ? `After: ${data.useAfterInput ? '(After From Input)' : data.after}\n` : ''}${data.useBeforeInput || data.before?.trim()
+            ? `Before: ${data.useBeforeInput ? '(Before From Input)' : data.before}\n`
+            : ''}
+    `;
+    },
+    async process(data, inputData, context) {
+        const requestQuery = {
+            limit: getInputOrData(data, inputData, 'limit', 'number').toString(),
+            order: getInputOrData(data, inputData, 'order'),
+            after: getInputOrData(data, inputData, 'after') || undefined, // Mutually exclusive with before, so set to undefined if empty string
+            before: getInputOrData(data, inputData, 'before') || undefined,
+        };
+        const queryParams = Object.entries(requestQuery).filter(([, value]) => value !== undefined);
+        if (!context.settings.openAiKey) {
+            throw new Error('OpenAI key is not set.');
+        }
+        const query = new URLSearchParams(queryParams);
+        const url = `https://api.openai.com/v1/assistants?${query.toString()}`;
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                'OpenAI-Beta': 'assistants=v1',
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${context.settings.openAiKey}`,
+                'OpenAI-Organization': context.settings.openAiOrganization ?? '',
+            },
+        });
+        await handleOpenAIError(response);
+        const body = (await response.json());
+        return {
+            ['assistants']: {
+                type: 'object[]',
+                value: body.data,
+            },
+            ['first_id']: {
+                type: 'string',
+                value: body.first_id,
+            },
+            ['last_id']: {
+                type: 'string',
+                value: body.last_id,
+            },
+            ['has_more']: {
+                type: 'boolean',
+                value: body.has_more,
+            },
+        };
+    },
+};
+export const listAssistantsNode = pluginNodeDefinition(ListAssistantsNodeImpl, 'List Assistants');

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

@@ -0,0 +1,94 @@
+import {} from '../../../index.js';
+import { newId, getInputOrData, dedent } from '../../../utils/index.js';
+import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
+import { handleOpenAIError } from '../handleOpenaiError.js';
+import { openAIFilePurposeOptions } from '../../../utils/openai.js';
+export const ListOpenAIFilesNodeImpl = {
+    create() {
+        return {
+            id: newId(),
+            type: 'openaiListFiles',
+            data: {
+                purpose: 'assistants',
+            },
+            title: 'List OpenAI Files',
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 300,
+            },
+        };
+    },
+    getUIData() {
+        return {
+            group: 'OpenAI',
+            contextMenuTitle: 'List OpenAI Files',
+            infoBoxTitle: 'List OpenAI Files Node',
+            infoBoxBody: 'List files from OpenAI.',
+        };
+    },
+    getInputDefinitions(data) {
+        const inputs = [];
+        if (data.usePurposeInput) {
+            inputs.push({
+                id: 'purpose',
+                dataType: 'string',
+                title: 'Purpose',
+                coerced: true,
+                defaultValue: '',
+                description: 'Retrieve only files with the specified purpose.',
+            });
+        }
+        return inputs;
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'files',
+                dataType: 'object[]',
+                title: 'Files',
+                description: 'The list of files.',
+            },
+        ];
+    },
+    getEditors() {
+        return [
+            {
+                type: 'dropdown',
+                dataKey: 'purpose',
+                useInputToggleDataKey: 'usePurposeInput',
+                label: 'Purpose',
+                options: openAIFilePurposeOptions,
+                defaultValue: 'assistants',
+            },
+        ];
+    },
+    getBody(data) {
+        return dedent `
+      Purpose: ${openAIFilePurposeOptions.find(({ value }) => value === data.purpose)?.label ?? 'Unknown'}
+    `;
+    },
+    async process(data, inputData, context) {
+        const purpose = getInputOrData(data, inputData, 'purpose');
+        if (!context.settings.openAiKey) {
+            throw new Error('OpenAI key is not set.');
+        }
+        const url = `https://api.openai.com/v1/files?purpose=${purpose}`;
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${context.settings.openAiKey}`,
+                'OpenAI-Organization': context.settings.openAiOrganization ?? '',
+            },
+        });
+        await handleOpenAIError(response);
+        const body = (await response.json());
+        return {
+            ['files']: {
+                type: 'object[]',
+                value: body.data,
+            },
+        };
+    },
+};
+export const listOpenAIFilesNode = pluginNodeDefinition(ListOpenAIFilesNodeImpl, 'List OpenAI Files');