@alpic80/rivet-core 1.19.1-aidon.1

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

@@ -0,0 +1,176 @@
+import {} from '../../../index.js';
+import { dedent, newId, coerceTypeOptional, getInputOrData } from '../../../utils/index.js';
+import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
+import { handleOpenAIError } from '../handleOpenaiError.js';
+export const CreateThreadMessageNodeImpl = {
+    create() {
+        return {
+            id: newId(),
+            type: 'openaiCreateThreadMessage',
+            data: {
+                threadId: '',
+                useThreadIdInput: true,
+                file_ids: [],
+                useFileIdsInput: false,
+                metadata: [],
+                useMetadataInput: false,
+            },
+            title: 'Create Thread Message',
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 300,
+            },
+        };
+    },
+    getUIData() {
+        return {
+            group: 'OpenAI',
+            contextMenuTitle: 'Create Thread Message',
+            infoBoxTitle: 'Create Thread Message Node',
+            infoBoxBody: 'Create a new message for an OpenAI thread.',
+        };
+    },
+    getInputDefinitions(data) {
+        const inputs = [];
+        inputs.push({
+            id: 'content',
+            dataType: 'string',
+            title: 'Content',
+            coerced: true,
+            defaultValue: '',
+            description: 'The content of the message.',
+        });
+        if (data.useThreadIdInput) {
+            inputs.push({
+                id: 'threadId',
+                dataType: 'string',
+                title: 'Thread ID',
+                coerced: true,
+                defaultValue: '',
+                description: 'The ID of the thread to post the message to.',
+                required: true,
+            });
+        }
+        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 message.',
+                required: false,
+            });
+        }
+        if (data.useMetadataInput) {
+            inputs.push({
+                id: 'metadata',
+                dataType: 'object',
+                title: 'Metadata',
+                coerced: true,
+                defaultValue: {},
+                description: 'Metadata to attach to the message.',
+                required: false,
+            });
+        }
+        return inputs;
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'messageId',
+                dataType: 'string',
+                title: 'Message ID',
+                description: 'The ID of the created message.',
+            },
+            {
+                id: 'message',
+                dataType: 'object',
+                title: 'Message',
+                description: 'The full created message object.',
+            },
+        ];
+    },
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                dataKey: 'threadId',
+                useInputToggleDataKey: 'useThreadIdInput',
+                label: 'Thread ID',
+                placeholder: 'Enter thread ID',
+                helperMessage: 'The ID of the thread to post the message to.',
+            },
+            {
+                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 `
+      Thread ID: ${data.useThreadIdInput ? '(Thread ID From Input)' : data.threadId}${data.useFileIdsInput || data.file_ids.length > 0
+            ? `File IDs: ${data.useFileIdsInput ? '(File IDs From Input)' : JSON.stringify(data.file_ids)}\n`
+            : ''}${data.useMetadataInput || data.metadata.length > 0
+            ? `Metadata: ${data.useMetadataInput
+                ? '(Metadata From Input)'
+                : data.metadata.map(({ key, value }) => `${key}=${value}`).join(', ')}\n`
+            : ''}
+    `;
+    },
+    async process(data, inputData, context) {
+        const threadId = getInputOrData(data, inputData, 'threadId');
+        const content = coerceTypeOptional(inputData['content'], 'string') ?? '';
+        let metadata = data.metadata.reduce((acc, { key, value }) => {
+            acc[key] = value;
+            return acc;
+        }, {});
+        if (data.useMetadataInput && inputData['metadata']) {
+            metadata = coerceTypeOptional(inputData['metadata'], 'object');
+        }
+        const requestBody = {
+            role: 'user',
+            content,
+            file_ids: getInputOrData(data, inputData, 'file_ids', 'string[]'),
+            metadata,
+        };
+        if (!context.settings.openAiKey) {
+            throw new Error('OpenAI key is not set.');
+        }
+        const url = `https://api.openai.com/v1/threads/${threadId}/messages`;
+        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 {
+            ['messageId']: {
+                type: 'string',
+                value: body.id,
+            },
+            ['message']: {
+                type: 'object',
+                value: body,
+            },
+        };
+    },
+};
+export const createThreadMessageNode = pluginNodeDefinition(CreateThreadMessageNodeImpl, 'Create Thread Message');

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

@@ -0,0 +1,157 @@
+import {} from '../../../index.js';
+import { dedent, newId, coerceTypeOptional, getInputOrData } from '../../../utils/index.js';
+import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
+export const CreateThreadNodeImpl = {
+    create() {
+        return {
+            id: newId(),
+            type: 'openaiCreateThread',
+            data: {
+                metadata: [],
+                useMetadataInput: false,
+            },
+            title: 'Create Thread',
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 225,
+            },
+        };
+    },
+    getUIData() {
+        return {
+            group: 'OpenAI',
+            contextMenuTitle: 'Create Thread',
+            infoBoxTitle: 'Create Thread Node',
+            infoBoxBody: 'Create a new thread for OpenAI assistants.',
+        };
+    },
+    getInputDefinitions(data) {
+        const inputs = [];
+        if (data.useThreadIdInput) {
+            inputs.push({
+                id: 'threadId',
+                dataType: 'string',
+                title: 'Thread ID',
+                coerced: true,
+                defaultValue: '',
+                description: 'The ID of the thread to modify. If not provided, a new thread will be created.',
+                required: true,
+            });
+        }
+        inputs.push({
+            id: 'messages',
+            dataType: 'object[]',
+            title: 'Messages',
+            coerced: true,
+            defaultValue: [],
+            description: 'A list of user messages to start the thread with.',
+            required: false,
+        });
+        if (data.useMetadataInput) {
+            inputs.push({
+                id: 'metadata',
+                dataType: 'object',
+                title: 'Metadata',
+                coerced: true,
+                defaultValue: {},
+                description: 'Metadata to attach to the thread.',
+                required: false,
+            });
+        }
+        return inputs;
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'threadId',
+                dataType: 'string',
+                title: 'Thread ID',
+                description: 'The ID of the created thread.',
+            },
+            {
+                id: 'thread',
+                dataType: 'object',
+                title: 'Thread',
+                description: 'The full created thread object.',
+            },
+        ];
+    },
+    getEditors() {
+        return [
+            {
+                type: 'keyValuePair',
+                dataKey: 'metadata',
+                useInputToggleDataKey: 'useMetadataInput',
+                label: 'Metadata',
+                keyPlaceholder: 'Key',
+                valuePlaceholder: 'Value',
+            },
+        ];
+    },
+    getBody(data) {
+        return dedent `
+      ${data.threadId ? `Thread ID: ${data.threadId}` : 'Create New Thread'}
+      ${data.useMetadataInput
+            ? '(Metadata From Input)'
+            : data.metadata.map(({ key, value }) => `${key}=${value}`).join(', ')}
+    `;
+    },
+    async process(data, inputData, context) {
+        const threadId = getInputOrData(data, inputData, 'threadId') ?? '';
+        const messages = coerceTypeOptional(inputData['messages'], 'object[]') ?? [];
+        let metadata = data.metadata.reduce((acc, { key, value }) => {
+            acc[key] = value;
+            return acc;
+        }, {});
+        if (data.useMetadataInput && inputData['metadata']) {
+            metadata = coerceTypeOptional(inputData['metadata'], 'object');
+        }
+        if (!context.settings.openAiKey) {
+            throw new Error('OpenAI key is not set.');
+        }
+        const messagesFormatted = messages.map((message) => {
+            if (!('role' in message)) {
+                throw new Error('Invalid message format.');
+            }
+            if (message.role !== 'user') {
+                throw new Error('Only user messages are supported.');
+            }
+            return message;
+        });
+        const url = threadId.trim() ? `https://api.openai.com/v1/threads/${threadId}` : 'https://api.openai.com/v1/threads';
+        if (threadId && messages.length > 0) {
+            throw new Error('Cannot provide messages when modifying an existing thread.');
+        }
+        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(threadId.trim()
+                ? { metadata }
+                : {
+                    messages: messagesFormatted,
+                    metadata,
+                }),
+        });
+        if (!response.ok) {
+            throw new Error('Failed to create thread.');
+        }
+        const body = (await response.json());
+        return {
+            ['threadId']: {
+                type: 'string',
+                value: body.id,
+            },
+            ['thread']: {
+                type: 'object',
+                value: body,
+            },
+        };
+    },
+};
+export const createThreadNode = pluginNodeDefinition(CreateThreadNodeImpl, 'Create Thread');

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

@@ -0,0 +1,104 @@
+import {} from '../../../index.js';
+import { newId, dedent, getInputOrData } from '../../../utils/index.js';
+import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
+import { handleOpenAIError } from '../handleOpenaiError.js';
+export const DeleteAssistantNodeImpl = {
+    create() {
+        return {
+            id: newId(),
+            type: 'openaiDeleteAssistant',
+            data: {
+                assistantId: '',
+                useAssistantIdInput: true,
+            },
+            title: 'Delete Assistant',
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 275,
+            },
+        };
+    },
+    getUIData() {
+        return {
+            group: 'OpenAI',
+            contextMenuTitle: 'Delete Assistant',
+            infoBoxTitle: 'Delete Assistant Node',
+            infoBoxBody: 'Delete an existing assistant from OpenAI.',
+        };
+    },
+    getInputDefinitions(data) {
+        const inputs = [];
+        if (data.useAssistantIdInput) {
+            inputs.push({
+                id: 'assistantId',
+                dataType: 'string',
+                title: 'Assistant ID',
+                description: 'The ID of the assistant to delete.',
+                required: true,
+            });
+        }
+        return inputs;
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'assistantId',
+                dataType: 'string',
+                title: 'Assistant ID',
+                description: 'The ID of the deleted assistant.',
+            },
+        ];
+    },
+    getBody(data) {
+        return dedent `
+      ${data.useAssistantIdInput ? '' : `Assistant ID: ${data.assistantId}`}
+    `;
+    },
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                dataKey: 'assistantId',
+                useInputToggleDataKey: 'useAssistantIdInput',
+                label: 'Assistant ID',
+                placeholder: 'Enter assistant ID',
+            },
+        ];
+    },
+    async process(data, inputData, context) {
+        const assistantId = getInputOrData(data, inputData, 'assistantId');
+        if (!assistantId) {
+            throw new Error('Assistant ID is required.');
+        }
+        if (!context.settings.openAiKey) {
+            throw new Error('OpenAI key is not set.');
+        }
+        const response = await fetch(`https://api.openai.com/v1/assistants/${assistantId}`, {
+            method: 'DELETE',
+            headers: {
+                'OpenAI-Beta': 'assistants=v1',
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${context.settings.openAiKey}`,
+                'OpenAI-Organization': context.settings.openAiOrganization ?? '',
+            },
+        });
+        if (response.status === 404) {
+            return {
+                ['assistantId']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            };
+        }
+        await handleOpenAIError(response);
+        // Return the assistantId as output so that subsequent nodes can use it
+        return {
+            ['assistantId']: {
+                type: 'string',
+                value: assistantId,
+            },
+        };
+    },
+};
+export const deleteAssistantNode = pluginNodeDefinition(DeleteAssistantNodeImpl, 'Delete Assistant');

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

@@ -0,0 +1,97 @@
+import {} from '../../../index.js';
+import { newId, dedent, getInputOrData } from '../../../utils/index.js';
+import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
+export const DeleteThreadNodeImpl = {
+    create() {
+        return {
+            id: newId(),
+            type: 'openaiDeleteThread',
+            data: {
+                threadId: '',
+                useThreadIdInput: true,
+            },
+            title: 'Delete Thread',
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 225,
+            },
+        };
+    },
+    getUIData() {
+        return {
+            group: 'OpenAI',
+            contextMenuTitle: 'Delete Thread',
+            infoBoxTitle: 'Delete Thread Node',
+            infoBoxBody: 'Delete 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 delete.',
+                required: true,
+            });
+        }
+        return inputs;
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'threadId',
+                dataType: 'string',
+                title: 'Thread ID',
+                description: 'The ID of the deleted thread.',
+            },
+        ];
+    },
+    getBody(data) {
+        return dedent `
+      ${data.useThreadIdInput ? '' : `Thread ID: ${data.threadId}`}
+    `;
+    },
+    getEditors() {
+        return [];
+    },
+    async process(data, inputData, context) {
+        const threadId = getInputOrData(data, inputData, 'threadId');
+        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: 'DELETE',
+            headers: {
+                'OpenAI-Beta': 'assistants=v1',
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${context.settings.openAiKey}`,
+                'OpenAI-Organization': context.settings.openAiOrganization ?? '',
+            },
+        });
+        if (response.status === 404) {
+            return {
+                ['threadId']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            };
+        }
+        if (!response.ok) {
+            throw new Error('Failed to delete thread.');
+        }
+        // Return the threadId as output so that subsequent nodes can use it
+        return {
+            ['threadId']: {
+                type: 'string',
+                value: threadId,
+            },
+        };
+    },
+};
+export const deleteThreadNode = pluginNodeDefinition(DeleteThreadNodeImpl, 'Delete Thread');

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

@@ -0,0 +1,118 @@
+import {} from '../../../index.js';
+import { newId, getInputOrData } from '../../../utils/index.js';
+import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
+import { handleOpenAIError } from '../handleOpenaiError.js';
+export const GetAssistantNodeImpl = {
+    create() {
+        return {
+            id: newId(),
+            type: 'openaiGetAssistant',
+            data: {
+                assistantId: '',
+                useAssistantIdInput: true,
+            },
+            title: 'Get Assistant',
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 300,
+            },
+        };
+    },
+    getUIData() {
+        return {
+            group: 'OpenAI',
+            contextMenuTitle: 'Get Assistant',
+            infoBoxTitle: 'Get Assistant Node',
+            infoBoxBody: 'Retrieve an assistant by its ID from 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 retrieve.',
+                required: true,
+            });
+        }
+        return inputs;
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'assistantId',
+                dataType: 'string',
+                title: 'Assistant ID',
+                description: 'The ID of the retrieved assistant.',
+            },
+            {
+                id: 'assistant',
+                dataType: 'object',
+                title: 'Assistant',
+                description: 'The full retrieved assistant object.',
+            },
+        ];
+    },
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                dataKey: 'assistantId',
+                useInputToggleDataKey: 'useAssistantIdInput',
+                label: 'Assistant ID',
+                placeholder: 'Enter assistant ID',
+            },
+        ];
+    },
+    getBody(data) {
+        return `Assistant ID: ${data.useAssistantIdInput ? '(Assistant ID From Input)' : data.assistantId}`;
+    },
+    async process(data, inputData, context) {
+        const assistantId = getInputOrData(data, inputData, 'assistantId');
+        if (!assistantId?.trim()) {
+            throw new Error('Assistant ID is required.');
+        }
+        if (!context.settings.openAiKey) {
+            throw new Error('OpenAI key is not set.');
+        }
+        const response = await fetch(`https://api.openai.com/v1/assistants/${assistantId}`, {
+            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 {
+                ['assistantId']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+                ['assistant']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            };
+        }
+        await handleOpenAIError(response);
+        const body = await response.json();
+        return {
+            ['assistantId']: {
+                type: 'string',
+                value: body.id,
+            },
+            ['assistant']: {
+                type: 'object',
+                value: body,
+            },
+        };
+    },
+};
+export const getAssistantNode = pluginNodeDefinition(GetAssistantNodeImpl, 'Get Assistant');