@alpic80/rivet-core 1.19.1-aidon.1

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

@@ -0,0 +1,145 @@
+import {} from '../../../index.js';
+import { dedent, newId, coerceTypeOptional, getInputOrData, coerceType } from '../../../utils/index.js';
+import { interpolate } from '../../../utils/interpolation.js';
+import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
+import { mapValues } from 'lodash-es';
+export const ThreadMessageNodeImpl = {
+    create() {
+        return {
+            id: newId(),
+            type: 'threadMessage',
+            data: {
+                text: '{{input}}',
+                fileIds: [],
+                useFileIdsInput: false,
+                metadata: [],
+                useMetadataInput: false,
+            },
+            title: 'Thread Message',
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 225,
+            },
+        };
+    },
+    getUIData() {
+        return {
+            group: 'OpenAI',
+            contextMenuTitle: 'Thread Message',
+            infoBoxTitle: 'Thread Message Node',
+            infoBoxBody: 'Create a new message for a thread.',
+        };
+    },
+    getInputDefinitions(data) {
+        let inputs = [];
+        if (data.useFileIdsInput) {
+            inputs.push({
+                id: 'fileIds',
+                dataType: 'string[]',
+                title: 'File IDs',
+                coerced: true,
+                defaultValue: [],
+                description: 'The IDs of the files to attach to the 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,
+            });
+        }
+        // Extract inputs from promptText, everything like {{input}}
+        const inputNames = [...new Set(data.text.match(/\{\{([^}]+)\}\}/g))];
+        inputs = [
+            ...inputs,
+            ...(inputNames?.map((inputName) => {
+                return {
+                    // id and title should not have the {{ and }}
+                    id: inputName.slice(2, -2),
+                    title: inputName.slice(2, -2),
+                    dataType: 'string',
+                    required: false,
+                };
+            }) ?? []),
+        ];
+        return inputs;
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'message',
+                dataType: 'object',
+                title: 'Message',
+                description: 'The created message.',
+            },
+        ];
+    },
+    getEditors() {
+        return [
+            {
+                type: 'code',
+                label: 'Text',
+                dataKey: 'text',
+                language: 'prompt-interpolation-markdown',
+                theme: 'prompt-interpolation',
+            },
+            {
+                type: 'keyValuePair',
+                dataKey: 'metadata',
+                useInputToggleDataKey: 'useMetadataInput',
+                label: 'Metadata',
+                keyPlaceholder: 'Key',
+                valuePlaceholder: 'Value',
+            },
+            {
+                type: 'stringList',
+                dataKey: 'fileIds',
+                useInputToggleDataKey: 'useFileIdsInput',
+                label: 'File IDs',
+                placeholder: 'File ID',
+            },
+        ];
+    },
+    getBody(data) {
+        return {
+            type: 'colorized',
+            text: data.text.split('\n').slice(0, 15).join('\n').trim(),
+            language: 'prompt-interpolation-markdown',
+            theme: 'prompt-interpolation',
+        };
+    },
+    async process(data, inputData) {
+        const text = getInputOrData(data, inputData, 'text', 'string');
+        const fileIds = getInputOrData(data, inputData, 'fileIds', '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 inputMap = mapValues(inputData, (input) => coerceType(input, 'string'));
+        const interpolated = interpolate(text, inputMap);
+        // Here you would typically make a call to an API to create the message
+        // For the sake of this example, we'll just return the data as is
+        return {
+            ['message']: {
+                type: 'object',
+                value: {
+                    role: 'user',
+                    content: interpolated,
+                    file_ids: fileIds,
+                    metadata,
+                },
+            },
+        };
+    },
+};
+export const threadMessageNode = pluginNodeDefinition(ThreadMessageNodeImpl, 'Thread Message');

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

@@ -0,0 +1,121 @@
+import {} from '../../../index.js';
+import { newId, dedent, getInputOrData, coerceType, coerceTypeOptional } from '../../../utils/index.js';
+import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
+import { handleOpenAIError } from '../handleOpenaiError.js';
+import { openAIFileUploadPurposeOptions } from '../../../utils/openai.js';
+export const UploadFileNodeImpl = {
+    create() {
+        return {
+            id: newId(),
+            type: 'openaiUploadFile',
+            data: {
+                purpose: 'assistants',
+            },
+            title: 'Upload File to OpenAI',
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 300,
+            },
+        };
+    },
+    getUIData() {
+        return {
+            group: 'OpenAI',
+            contextMenuTitle: 'Upload File to OpenAI',
+            infoBoxTitle: 'Upload File to OpenAI Node',
+            infoBoxBody: 'Upload a file to OpenAI.',
+        };
+    },
+    getInputDefinitions() {
+        const inputs = [];
+        inputs.push({
+            id: 'data',
+            dataType: 'binary',
+            title: 'Data',
+            coerced: true,
+            defaultValue: '',
+            description: 'The binary data of the file to upload.',
+            required: true,
+        });
+        inputs.push({
+            id: 'file-name',
+            dataType: 'string',
+            title: 'File Name',
+            coerced: true,
+            description: 'An optional file name to use for the uploaded file.',
+            required: false,
+        });
+        return inputs;
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'fileId',
+                dataType: 'string',
+                title: 'File ID',
+                description: 'The ID of the uploaded file.',
+            },
+            {
+                id: 'file',
+                dataType: 'object',
+                title: 'File',
+                description: 'The full uploaded file object.',
+            },
+        ];
+    },
+    getEditors() {
+        return [
+            {
+                type: 'dropdown',
+                dataKey: 'purpose',
+                label: 'Purpose',
+                options: openAIFileUploadPurposeOptions,
+                defaultValue: 'assistants',
+            },
+        ];
+    },
+    getBody(data) {
+        return dedent `
+      Purpose: ${openAIFileUploadPurposeOptions.find(({ value }) => value === data.purpose)?.label ?? 'Unknown'}
+    `;
+    },
+    async process(data, inputData, context) {
+        const purpose = getInputOrData(data, inputData, 'purpose');
+        const fileData = coerceType(inputData['data'], 'binary');
+        const fileName = coerceTypeOptional(inputData['file-name'], 'string');
+        if (!fileData) {
+            throw new Error('File data is required.');
+        }
+        if (!context.settings.openAiKey) {
+            throw new Error('OpenAI key is not set.');
+        }
+        const file = fileName
+            ? new File([fileData], fileName, { type: 'application/octet-stream' })
+            : new Blob([fileData], { type: 'application/octet-stream' });
+        const formData = new FormData();
+        formData.append('purpose', purpose);
+        formData.append('file', file);
+        const response = await fetch('https://api.openai.com/v1/files', {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${context.settings.openAiKey}`,
+                'OpenAI-Organization': context.settings.openAiOrganization ?? '',
+            },
+            body: formData,
+        });
+        await handleOpenAIError(response);
+        const body = await response.json();
+        return {
+            ['fileId']: {
+                type: 'string',
+                value: body.id,
+            },
+            ['file']: {
+                type: 'object',
+                value: body,
+            },
+        };
+    },
+};
+export const uploadFileNode = pluginNodeDefinition(UploadFileNodeImpl, 'Upload File to OpenAI');

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

@@ -0,0 +1,44 @@
+import {} from '../../index.js';
+import { createThreadNode } from './nodes/CreateThreadNode.js';
+import { getThreadNode } from './nodes/GetThreadNode.js';
+import { deleteThreadNode } from './nodes/DeleteThreadNode.js';
+import { createAssistantNode } from './nodes/CreateAssistantNode.js';
+import { getAssistantNode } from './nodes/GetAssistantNode.js';
+import { listAssistantsNode } from './nodes/ListAssistantsNode.js';
+import { deleteAssistantNode } from './nodes/DeleteAssistantNode.js';
+import { uploadFileNode } from './nodes/UploadFileNode.js';
+import { listOpenAIFilesNode } from './nodes/ListOpenAIFilesNode.js';
+import { getOpenAIFileNode } from './nodes/GetOpenAIFileNode.js';
+import { attachAssistantFileNode } from './nodes/AttachAssistantFileNode.js';
+import { createThreadMessageNode } from './nodes/CreateThreadMessageNode.js';
+import { listThreadMessagesNode } from './nodes/ListThreadMessagesNode.js';
+import { runThreadNode } from './nodes/RunThreadNode.js';
+import { threadMessageNode } from './nodes/ThreadMessageNode.js';
+export const openAIPlugin = {
+    id: 'openai',
+    name: 'OpenAI',
+    configSpec: {},
+    contextMenuGroups: [
+        {
+            id: 'openai',
+            label: 'OpenAI',
+        },
+    ],
+    register(register) {
+        register(createThreadNode);
+        register(getThreadNode);
+        register(deleteThreadNode);
+        register(createAssistantNode);
+        register(getAssistantNode);
+        register(listAssistantsNode);
+        register(deleteAssistantNode);
+        register(uploadFileNode);
+        register(listOpenAIFilesNode);
+        register(getOpenAIFileNode);
+        register(attachAssistantFileNode);
+        register(createThreadMessageNode);
+        register(listThreadMessagesNode);
+        register(runThreadNode);
+        register(threadMessageNode);
+    },
+};

package/dist/esm/plugins/pinecone/PineconeVectorDatabase.js

@@ -0,0 +1,88 @@
+import {} from '../../index.js';
+import * as CryptoJS from 'crypto-js';
+import { coerceType } from '../../utils/coerceType.js';
+export class PineconeVectorDatabase {
+    #apiKey;
+    constructor(settings) {
+        this.#apiKey = settings.pluginSettings?.pinecone?.pineconeApiKey;
+    }
+    async store(collection, vector, data, { id }) {
+        const collectionDetails = getCollection(coerceType(collection, 'string'));
+        if (!id) {
+            id = CryptoJS.SHA256(vector.value.join(',')).toString(CryptoJS.enc.Hex);
+        }
+        let metadata = {};
+        if (data.type === 'object') {
+            metadata = data.value;
+        }
+        else {
+            metadata = { data: data.value };
+        }
+        const response = await fetch(`${collectionDetails.host}/vectors/upsert`, {
+            method: 'POST',
+            body: JSON.stringify({
+                vectors: [
+                    {
+                        id,
+                        values: vector.value,
+                        metadata,
+                    },
+                ],
+                ...collectionDetails.options,
+            }),
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                'api-key': this.#apiKey,
+            },
+        });
+        if (response.status !== 200) {
+            throw new Error(`Pinecone error: ${await response.text()}`);
+        }
+    }
+    async nearestNeighbors(collection, vector, k) {
+        const collectionDetails = getCollection(coerceType(collection, 'string'));
+        const response = await fetch(`${collectionDetails.host}/query`, {
+            method: 'POST',
+            body: JSON.stringify({
+                vector: vector.value,
+                topK: k,
+                includeMetadata: true,
+                ...collectionDetails.options,
+            }),
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                'api-key': this.#apiKey,
+            },
+        });
+        if (response.status !== 200) {
+            throw new Error(`Pinecone error: ${await response.text()}`);
+        }
+        const responseData = await response.json();
+        const { matches } = responseData;
+        return {
+            type: 'object[]',
+            value: matches.map(({ id, metadata }) => ({ id, data: metadata.data, metadata })),
+        };
+    }
+}
+function getCollection(collectionString) {
+    let collectionURL;
+    if (!collectionString.startsWith('http://') && !collectionString.startsWith('https://')) {
+        collectionString = `https://${collectionString}`;
+    }
+    try {
+        collectionURL = new URL(collectionString);
+    }
+    catch (error) {
+        throw new Error(`Incorrectly formatted Pinecone collection: ${error}`);
+    }
+    const host = `${collectionURL.protocol}//${collectionURL.host}`;
+    const options = {};
+    if (collectionURL.pathname !== '/') {
+        // Chop off the leading slash.
+        options.namespace = collectionURL.pathname.slice(1);
+    }
+    return { host, options };
+}

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

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

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

@@ -0,0 +1,19 @@
+import {} from '../../index.js';
+import { PineconeVectorDatabase } from './PineconeVectorDatabase.js';
+import { registerIntegration } from '../../integrations/integrations.js';
+export const pineconePlugin = {
+    id: 'pinecone',
+    name: 'Pinecone',
+    register: () => {
+        registerIntegration('vectorDatabase', 'pinecone', (context) => new PineconeVectorDatabase(context.settings));
+    },
+    configSpec: {
+        pineconeApiKey: {
+            type: 'secret',
+            label: 'Pinecone API Key',
+            description: 'The API key for the Pinecone service.',
+            pullEnvironmentVariable: 'PINECONE_API_KEY',
+            helperText: 'You may also set the PINECONE_API_KEY environment variable.',
+        },
+    },
+};

package/dist/esm/plugins.js

@@ -0,0 +1,21 @@
+import aidonPlugin from './plugins/aidon/index.js';
+import anthropicPlugin from './plugins/anthropic/index.js';
+import autoevalsPlugin from './plugins/autoevals/index.js';
+import assemblyAiPlugin from './plugins/assemblyAi/index.js';
+import { huggingFacePlugin } from './plugins/huggingface/plugin.js';
+import pineconePlugin from './plugins/pinecone/index.js';
+import gentracePlugin from './plugins/gentrace/index.js';
+import { openAIPlugin } from './plugins/openai/plugin.js';
+import { googlePlugin } from './plugins/google/plugin.js';
+export { aidonPlugin, anthropicPlugin, autoevalsPlugin, assemblyAiPlugin, pineconePlugin, huggingFacePlugin, gentracePlugin, googlePlugin, };
+export const plugins = {
+    aidon: aidonPlugin,
+    anthropic: anthropicPlugin,
+    autoevals: autoevalsPlugin,
+    assemblyAi: assemblyAiPlugin,
+    pinecone: pineconePlugin,
+    huggingFace: huggingFacePlugin,
+    gentrace: gentracePlugin,
+    openai: openAIPlugin,
+    google: googlePlugin,
+};

package/dist/esm/recording/ExecutionRecorder.js

@@ -0,0 +1,177 @@
+import { nanoid } from 'nanoid/non-secure';
+import {} from '../index.js';
+import Emittery from 'emittery';
+const toRecordedEventMap = {
+    graphStart: ({ graph, inputs }) => ({ graphId: graph.metadata.id, inputs }),
+    graphFinish: ({ graph, outputs }) => ({ graphId: graph.metadata.id, outputs }),
+    graphError: ({ graph, error }) => ({
+        graphId: graph.metadata.id,
+        error: typeof error === 'string' ? error : error.stack,
+    }),
+    nodeStart: ({ node, inputs, processId }) => ({
+        nodeId: node.id,
+        inputs,
+        processId,
+    }),
+    nodeFinish: ({ node, outputs, processId }) => ({
+        nodeId: node.id,
+        outputs,
+        processId,
+    }),
+    nodeError: ({ node, error, processId }) => ({
+        nodeId: node.id,
+        error: typeof error === 'string' ? error : error.stack,
+        processId,
+    }),
+    abort: ({ successful, error }) => ({ successful, error: typeof error === 'string' ? error : error?.stack }),
+    graphAbort: ({ successful, error, graph }) => ({
+        successful,
+        error: typeof error === 'string' ? error : error?.stack,
+        graphId: graph.metadata.id,
+    }),
+    nodeExcluded: ({ node, processId, inputs, outputs, reason }) => ({
+        nodeId: node.id,
+        processId,
+        inputs,
+        outputs,
+        reason,
+    }),
+    userInput: ({ node, inputs, callback, processId }) => ({
+        nodeId: node.id,
+        inputs,
+        callback,
+        processId,
+    }),
+    partialOutput: ({ node, outputs, index, processId }) => ({
+        nodeId: node.id,
+        outputs,
+        index,
+        processId,
+    }),
+    nodeOutputsCleared: ({ node, processId }) => ({
+        nodeId: node.id,
+        processId,
+    }),
+    error: ({ error }) => ({
+        error: typeof error === 'string' ? error : error.stack,
+    }),
+    done: ({ results }) => ({ results }),
+    globalSet: ({ id, processId, value }) => ({ id, processId, value }),
+    pause: () => void 0,
+    resume: () => void 0,
+    start: ({ contextValues, inputs, project, startGraph }) => ({
+        contextValues,
+        inputs,
+        projectId: project.metadata.id,
+        startGraph: startGraph.metadata.id,
+    }),
+    trace: (message) => message,
+    newAbortController: () => { },
+    finish: () => void 0,
+};
+const isPrefix = (s, prefix) => s.startsWith(prefix);
+function toRecordedEvent(event, data) {
+    if (isPrefix(event, 'globalSet:')) {
+        return {
+            type: event,
+            data: data,
+            ts: Date.now(),
+        };
+    }
+    if (isPrefix(event, 'userEvent:')) {
+        return {
+            type: event,
+            data: data,
+            ts: Date.now(),
+        };
+    }
+    return {
+        type: event,
+        data: toRecordedEventMap[event](data),
+        ts: Date.now(),
+    };
+}
+export class ExecutionRecorder {
+    #events = [];
+    recordingId;
+    #emitter;
+    #includePartialOutputs;
+    #includeTrace;
+    constructor(options = {}) {
+        this.#emitter = new Emittery();
+        this.#emitter.bindMethods(this, ['on', 'off', 'once']);
+        this.#includePartialOutputs = options.includePartialOutputs ?? false;
+        this.#includeTrace = options.includeTrace ?? false;
+    }
+    on = undefined;
+    off = undefined;
+    once = undefined;
+    recordSocket(channel) {
+        return new Promise((resolve, reject) => {
+            this.recordingId = nanoid();
+            const listener = (event) => {
+                const { message, data } = JSON.parse(event.data);
+                if (this.#includePartialOutputs === false && message === 'partialOutput') {
+                    return;
+                }
+                if (this.#includeTrace === false && message === 'trace') {
+                    return;
+                }
+                this.#events.push(toRecordedEvent(message, data));
+                if (message === 'done' || message === 'abort' || message === 'error') {
+                    this.#emitter.emit('finish', {
+                        recording: this.getRecording(),
+                    });
+                    channel.removeEventListener('message', listener);
+                    resolve();
+                }
+            };
+            channel.addEventListener('message', listener);
+        });
+    }
+    record(processor) {
+        this.recordingId = nanoid();
+        processor.onAny((event, data) => {
+            if (this.#includePartialOutputs === false && event === 'partialOutput') {
+                return;
+            }
+            if (this.#includeTrace === false && event === 'trace') {
+                return;
+            }
+            this.#events.push(toRecordedEvent(event, data));
+            if (event === 'done' || event === 'abort' || event === 'error') {
+                this.#emitter.emit('finish', {
+                    recording: this.getRecording(),
+                });
+            }
+        });
+    }
+    getRecording() {
+        return {
+            recordingId: this.recordingId,
+            events: this.#events,
+            startTs: this.#events[0]?.ts ?? 0,
+            finishTs: this.#events[this.#events.length - 1]?.ts ?? 0,
+        };
+    }
+    get events() {
+        return this.#events;
+    }
+    static deserializeFromString(serialized) {
+        const recorder = new ExecutionRecorder();
+        const serializedRecording = JSON.parse(serialized);
+        if (serializedRecording.version !== 1) {
+            throw new Error('Unsupported serialized events version');
+        }
+        recorder.recordingId = serializedRecording.recording.recordingId;
+        recorder.#events = serializedRecording.recording.events;
+        return recorder;
+    }
+    serialize() {
+        const serialized = {
+            version: 1,
+            recording: this.getRecording(),
+        };
+        return JSON.stringify(serialized);
+    }
+}

package/dist/esm/recording/RecordedEvents.js

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

package/dist/esm/utils/assertNever.js

@@ -0,0 +1,3 @@
+export function assertNever(x) {
+    throw new Error(`Unexpected object: ${x}`);
+}

package/dist/esm/utils/base64.js

@@ -0,0 +1,25 @@
+export async function uint8ArrayToBase64(uint8Array) {
+    if (typeof window === 'undefined') {
+        // Node executor
+        return Buffer.from(uint8Array).toString('base64');
+    }
+    else {
+        // Browser executor
+        const blob = new Blob([uint8Array], { type: 'application/octet-stream' });
+        const dataUrl = await new Promise((resolve) => {
+            const reader = new FileReader();
+            reader.onload = () => resolve(reader.result);
+            reader.readAsDataURL(blob);
+        });
+        return dataUrl.split(',')[1];
+    }
+}
+export function base64ToUint8Array(base64) {
+    const binaryString = atob(base64);
+    const len = binaryString.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+}