@alpic80/rivet-core 1.19.1-aidon.1

package/dist/esm/api/createProcessor.js

@@ -0,0 +1,131 @@
+import {} from '../index.js';
+import { mapValues } from '../utils/typeSafety.js';
+import { getProcessorEvents, getProcessorSSEStream, getSingleNodeStream } from './streaming.js';
+import { GraphProcessor } from '../model/GraphProcessor.js';
+import { deserializeProject } from '../utils/serialization/serialization.js';
+import { DEFAULT_CHAT_NODE_TIMEOUT } from '../utils/defaults.js';
+export function looseDataValuesToDataValues(values) {
+    return mapValues(values, (val) => looseDataValueToDataValue(val));
+}
+export function looseDataValueToDataValue(value) {
+    if (typeof value === 'string') {
+        return { type: 'string', value };
+    }
+    if (typeof value === 'number') {
+        return { type: 'number', value };
+    }
+    if (typeof value === 'boolean') {
+        return { type: 'boolean', value };
+    }
+    return value;
+}
+export function coreCreateProcessor(project, options) {
+    const { graph, inputs = {}, context = {} } = options;
+    const graphId = graph
+        ? graph in project.graphs
+            ? graph
+            : Object.values(project.graphs).find((g) => g.metadata?.name === graph)?.metadata?.id
+        : project.metadata.mainGraphId;
+    if (!graphId) {
+        throw new Error(`Graph not found, and no main graph specified.`);
+    }
+    const processor = new GraphProcessor(project, graphId, options.registry);
+    if (options.onStart) {
+        processor.on('start', options.onStart);
+    }
+    if (options.onNodeStart) {
+        processor.on('nodeStart', options.onNodeStart);
+    }
+    if (options.onNodeFinish) {
+        processor.on('nodeFinish', options.onNodeFinish);
+    }
+    if (options.onNodeError) {
+        processor.on('nodeError', options.onNodeError);
+    }
+    if (options.onNodeExcluded) {
+        processor.on('nodeExcluded', options.onNodeExcluded);
+    }
+    if (options.onGraphStart) {
+        processor.on('graphStart', options.onGraphStart);
+    }
+    if (options.onGraphError) {
+        processor.on('graphError', options.onGraphError);
+    }
+    if (options.onGraphFinish) {
+        processor.on('graphFinish', options.onGraphFinish);
+    }
+    if (options.onPartialOutput) {
+        processor.on('partialOutput', options.onPartialOutput);
+    }
+    if (options.onUserInput) {
+        processor.on('userInput', options.onUserInput);
+    }
+    if (options.onDone) {
+        processor.on('done', options.onDone);
+    }
+    if (options.onAbort) {
+        processor.on('abort', options.onAbort);
+    }
+    if (options.onGraphAbort) {
+        processor.on('graphAbort', options.onGraphAbort);
+    }
+    if (options.onTrace) {
+        processor.on('trace', options.onTrace);
+    }
+    if (options.onNodeOutputsCleared) {
+        processor.on('nodeOutputsCleared', options.onNodeOutputsCleared);
+    }
+    if (options.externalFunctions) {
+        for (const [name, fn] of Object.entries(options.externalFunctions)) {
+            processor.setExternalFunction(name, fn);
+        }
+    }
+    if (options.onUserEvent) {
+        for (const [name, fn] of Object.entries(options.onUserEvent)) {
+            processor.onUserEvent(name, fn);
+        }
+    }
+    options.abortSignal?.addEventListener('abort', () => {
+        processor.abort();
+    });
+    const resolvedInputs = looseDataValuesToDataValues(inputs);
+    const resolvedContextValues = looseDataValuesToDataValues(context);
+    return {
+        processor,
+        inputs: resolvedInputs,
+        contextValues: resolvedContextValues,
+        getEvents: (spec) => getProcessorEvents(processor, spec),
+        getSSEStream: (spec) => getProcessorSSEStream(processor, spec),
+        streamNode: (nodeIdOrTitle) => getSingleNodeStream(processor, nodeIdOrTitle),
+        async run() {
+            const outputs = await processor.processGraph({
+                nativeApi: options.nativeApi,
+                datasetProvider: options.datasetProvider,
+                audioProvider: options.audioProvider,
+                settings: {
+                    openAiKey: options.openAiKey ?? '',
+                    openAiOrganization: options.openAiOrganization ?? '',
+                    openAiEndpoint: options.openAiEndpoint ?? '',
+                    pluginEnv: options.pluginEnv ?? {},
+                    pluginSettings: options.pluginSettings ?? {},
+                    recordingPlaybackLatency: 1000,
+                    chatNodeHeaders: options.chatNodeHeaders ?? {},
+                    chatNodeTimeout: options.chatNodeTimeout ?? DEFAULT_CHAT_NODE_TIMEOUT,
+                },
+                getChatNodeEndpoint: options.getChatNodeEndpoint,
+            }, resolvedInputs, resolvedContextValues);
+            return outputs;
+        },
+    };
+}
+export async function coreRunGraph(project, options) {
+    const processorInfo = coreCreateProcessor(project, options);
+    return processorInfo.run();
+}
+export function loadProjectFromString(content) {
+    const [project] = deserializeProject(content);
+    return project;
+}
+export function loadProjectAndAttachedDataFromString(content) {
+    return deserializeProject(content);
+}

package/dist/esm/api/streaming.js

@@ -0,0 +1,116 @@
+import {} from '../index.js';
+import { coerceType } from '../utils/coerceType.js';
+/** A simplified way to listen and stream processor events, including filtering. */
+export async function* getProcessorEvents(processor, spec) {
+    const previousIndexes = new Map();
+    for await (const event of processor.events()) {
+        if (event.type === 'partialOutput') {
+            if (spec.partialOutputs === true ||
+                spec.partialOutputs?.includes(event.node.id) ||
+                spec.partialOutputs?.includes(event.node.title)) {
+                const currentOutput = coerceType(event.outputs['response'], 'string');
+                const delta = currentOutput.slice(previousIndexes.get(event.node.id) ?? 0);
+                yield {
+                    type: 'partialOutput',
+                    nodeId: event.node.id,
+                    nodeTitle: event.node.title,
+                    delta,
+                };
+                previousIndexes.set(event.node.id, currentOutput.length);
+            }
+        }
+        else if (event.type === 'done') {
+            if (spec.done) {
+                yield {
+                    type: 'done',
+                    graphOutput: event.results,
+                };
+            }
+        }
+        else if (event.type === 'error') {
+            if (spec.error) {
+                yield {
+                    type: 'error',
+                    error: typeof event.error === 'string' ? event.error : event.error.toString(),
+                };
+            }
+        }
+        else if (event.type === 'nodeStart') {
+            if (spec.nodeStart === true ||
+                spec.nodeStart?.includes(event.node.id) ||
+                spec.nodeStart?.includes(event.node.title)) {
+                yield {
+                    type: 'nodeStart',
+                    inputs: event.inputs,
+                    nodeId: event.node.id,
+                    nodeTitle: event.node.title,
+                };
+            }
+        }
+        else if (event.type === 'nodeFinish') {
+            if (spec.nodeFinish === true ||
+                spec.nodeFinish?.includes(event.node.id) ||
+                spec.nodeFinish?.includes(event.node.title)) {
+                yield {
+                    type: 'nodeFinish',
+                    outputs: event.outputs,
+                    nodeId: event.node.id,
+                    nodeTitle: event.node.title,
+                };
+            }
+        }
+    }
+}
+/**
+ * Creates a ReadableStream for processor events, following the Server-Sent Events protocol.
+ * https://developer.mozilla.org/en-US/docs/Web/API/EventSource
+ *
+ * Includes configuration for what events to send to the client, for example you can stream the partial output deltas
+ * for specific nodes, and/or the graph output when done.
+ */
+export function getProcessorSSEStream(processor, 
+/** The spec for what you're streaming to the client */
+spec) {
+    const encoder = new TextEncoder();
+    function sendEvent(controller, type, data) {
+        const event = `event: ${type}\ndata: ${JSON.stringify(data)}\n\n`;
+        controller.enqueue(encoder.encode(event));
+    }
+    return new ReadableStream({
+        async start(controller) {
+            try {
+                for await (const event of getProcessorEvents(processor, spec)) {
+                    sendEvent(controller, event.type, event);
+                }
+                controller.close();
+            }
+            catch (err) {
+                controller.error(err);
+            }
+        },
+    });
+}
+export function getSingleNodeStream(processor, nodeIdOrTitle) {
+    return new ReadableStream({
+        async start(controller) {
+            try {
+                for await (const event of getProcessorEvents(processor, {
+                    partialOutputs: [nodeIdOrTitle],
+                    nodeFinish: [nodeIdOrTitle],
+                })) {
+                    if (event.type === 'partialOutput' && (event.nodeId === nodeIdOrTitle || event.nodeTitle === nodeIdOrTitle)) {
+                        controller.enqueue(`data: ${JSON.stringify(event.delta)}\n\n`);
+                    }
+                    else if (event.type === 'nodeFinish' &&
+                        (event.nodeId === nodeIdOrTitle || event.nodeTitle === nodeIdOrTitle)) {
+                        controller.close();
+                    }
+                }
+                controller.close();
+            }
+            catch (err) {
+                controller.error(err);
+            }
+        },
+    });
+}

package/dist/esm/exports.js

@@ -0,0 +1,32 @@
+export * from './utils/index.js';
+export * from './model/GraphProcessor.js';
+export * from './model/DataValue.js';
+export * from './model/NodeBase.js';
+export * from './model/NodeGraph.js';
+export * from './model/NodeImpl.js';
+export * from './model/NodeDefinition.js';
+export * from './model/Nodes.js';
+export * from './model/Project.js';
+export * from './native/BaseDir.js';
+export * from './native/NativeApi.js';
+export * from './native/BrowserNativeApi.js';
+export * from './model/ProcessContext.js';
+export * from './integrations/integrations.js';
+import './integrations/enableIntegrations.js';
+export * from './integrations/VectorDatabase.js';
+export * from './integrations/EmbeddingGenerator.js';
+export * from './integrations/LLMProvider.js';
+export * from './recording/ExecutionRecorder.js';
+export * from './recording/RecordedEvents.js';
+export * from './model/RivetPlugin.js';
+export * from './plugins.js';
+export * from './model/NodeRegistration.js';
+export * from './model/EditorDefinition.js';
+export * from './model/NodeBodySpec.js';
+export * from './integrations/DatasetProvider.js';
+export * from './model/Dataset.js';
+export * from './api/streaming.js';
+export * from './api/createProcessor.js';
+export * from './integrations/AudioProvider.js';
+import * as openai from './utils/openai.js';
+export { openai };

package/dist/esm/index.js

@@ -0,0 +1,2 @@
+export * from './exports.js';
+export const Rivet = undefined;

package/dist/esm/integrations/AudioProvider.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/integrations/DatasetProvider.js

@@ -0,0 +1,92 @@
+import {} from '../index.js';
+import { cloneDeep } from 'lodash-es';
+export class InMemoryDatasetProvider {
+    #datasets;
+    constructor(datasets) {
+        this.#datasets = datasets;
+    }
+    async getDatasetMetadata(id) {
+        const dataset = this.#datasets.find((d) => d.meta.id === id);
+        return dataset?.meta;
+    }
+    async getDatasetsForProject(projectId) {
+        return this.#datasets.map((d) => d.meta);
+    }
+    async getDatasetData(id) {
+        const dataset = this.#datasets.find((d) => d.meta.id === id);
+        if (!dataset) {
+            return { id, rows: [] };
+        }
+        return dataset.data;
+    }
+    async putDatasetRow(id, row) {
+        const dataset = this.#datasets.find((d) => d.meta.id === id);
+        if (!dataset) {
+            throw new Error(`Dataset ${id} not found`);
+        }
+        const existingRow = dataset.data.rows.find((r) => r.id === row.id);
+        if (existingRow) {
+            existingRow.data = row.data;
+            existingRow.embedding = row.embedding;
+            return;
+        }
+        dataset.data.rows.push(row);
+    }
+    async putDatasetData(id, data) {
+        const dataset = this.#datasets.find((d) => d.meta.id === id);
+        if (!dataset) {
+            throw new Error(`Dataset ${id} not found`);
+        }
+        dataset.data = data;
+    }
+    async putDatasetMetadata(metadata) {
+        const matchingDataset = this.#datasets.find((d) => d.meta.id === metadata.id);
+        if (matchingDataset) {
+            matchingDataset.meta = metadata;
+            return;
+        }
+        this.#datasets.push({
+            meta: metadata,
+            data: {
+                id: metadata.id,
+                rows: [],
+            },
+        });
+    }
+    async clearDatasetData(id) {
+        const dataset = this.#datasets.find((d) => d.meta.id === id);
+        if (!dataset) {
+            return;
+        }
+        dataset.data = {
+            id,
+            rows: [],
+        };
+    }
+    async deleteDataset(id) {
+        const index = this.#datasets.findIndex((d) => d.meta.id === id);
+        if (index === -1) {
+            return;
+        }
+        this.#datasets.splice(index, 1);
+    }
+    async knnDatasetRows(datasetId, k, vector) {
+        const allRows = await this.getDatasetData(datasetId);
+        const sorted = allRows.rows
+            .filter((row) => row.embedding != null)
+            .map((row) => ({
+            row,
+            similarity: dotProductSimilarity(vector, row.embedding),
+        }))
+            .sort((a, b) => b.similarity - a.similarity);
+        return sorted.slice(0, k).map((r) => ({ ...r.row, distance: r.similarity }));
+    }
+    async exportDatasetsForProject(_projectId) {
+        // Cloning is safest... but slow
+        return cloneDeep(this.#datasets);
+    }
+}
+/** OpenAI embeddings are already normalized, so this is equivalent to cosine similarity */
+const dotProductSimilarity = (a, b) => {
+    return a.reduce((acc, val, i) => acc + val * b[i], 0);
+};

package/dist/esm/integrations/EmbeddingGenerator.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/integrations/GptTokenizerTokenizer.js

@@ -0,0 +1,65 @@
+import {} from '../index.js';
+import Emittery from 'emittery';
+import { getError } from '../utils/errors.js';
+import { chatMessageToOpenAIChatCompletionMessage } from '../utils/chatMessageToOpenAIChatCompletionMessage.js';
+export class GptTokenizerTokenizer {
+    emitter = new Emittery();
+    on(event, listener) {
+        this.emitter.on(event, listener);
+    }
+    async getTokenCountForString(input, _info) {
+        const { encode } = await import('gpt-tokenizer');
+        return encode(input).length;
+    }
+    async getTokenCountForMessages(messages, functions, _info) {
+        try {
+            const openaiMessages = await Promise.all(messages.map((message) => chatMessageToOpenAIChatCompletionMessage(message)));
+            const validMessages = openaiMessages
+                .filter((message) => message.role !== 'tool')
+                .map((message) => {
+                if (Array.isArray(message.content)) {
+                    const textContent = message.content
+                        .filter((c) => c.type === 'text')
+                        .map((c) => c.text)
+                        .join('');
+                    return { ...message, content: textContent };
+                }
+                return message;
+            });
+            const { encode, encodeChat } = await import('gpt-tokenizer');
+            const encodedChat = encodeChat(validMessages, 'gpt-3.5-turbo');
+            const encodedFunctions = functions && functions.length > 0 ? encode(this.convertGptFunctionsToPromptString(functions)) : [];
+            return encodedChat.length + encodedFunctions.length;
+        }
+        catch (err) {
+            this.emitter.emit('error', getError(err));
+            return 0;
+        }
+    }
+    /**
+     * Converts GPT Functions to approximate TypeScript-style string.
+     * Per thread: https://community.openai.com/t/how-to-calculate-the-tokens-when-using-function-call/266573/24
+     * We should consider using a different library, eg. https://github.com/hmarr/openai-chat-tokens
+     * @param functions
+     */
+    convertGptFunctionsToPromptString(functions) {
+        return `
+# Tools
+
+## functions
+
+namespace functions {
+${functions
+            .map((fn) => `
+// ${fn.description}
+type ${fn.name} = (_: {
+${Object.entries(fn.parameters?.properties ?? {})
+            .map(([parameterName, value]) => `// ${value?.description}\n${parameterName}?: ${value?.type}`)
+            .join('\n')}
+})
+`)
+            .join('')}
+} // namespace functions
+`;
+    }
+}

package/dist/esm/integrations/LLMProvider.js

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

package/dist/esm/integrations/Tokenizer.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/integrations/VectorDatabase.js

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

package/dist/esm/integrations/enableIntegrations.js

@@ -0,0 +1,3 @@
+import { registerIntegration } from './integrations.js';
+import { OpenAIEmbeddingGenerator } from './openai/OpenAIEmbeddingGenerator.js';
+registerIntegration('embeddingGenerator', 'openai', (context) => new OpenAIEmbeddingGenerator(context.settings));

package/dist/esm/integrations/integrations.js

@@ -0,0 +1,19 @@
+import {} from '../model/ProcessContext.js';
+import {} from './EmbeddingGenerator.js';
+import {} from './LLMProvider.js';
+import {} from './VectorDatabase.js';
+const registeredIntegrations = {
+    vectorDatabase: new Map(),
+    llmProvider: new Map(),
+    embeddingGenerator: new Map(),
+};
+export function registerIntegration(type, integrationKey, factory) {
+    registeredIntegrations[type].set(integrationKey, factory);
+}
+export function getIntegration(type, integrationKey, context) {
+    const factory = registeredIntegrations[type].get(integrationKey);
+    if (!factory) {
+        throw new Error(`Integration ${integrationKey} not found`);
+    }
+    return factory(context);
+}

package/dist/esm/integrations/openai/OpenAIEmbeddingGenerator.js

@@ -0,0 +1,23 @@
+import {} from '../../index.js';
+import {} from '../EmbeddingGenerator.js';
+import { OpenAI } from 'openai';
+export class OpenAIEmbeddingGenerator {
+    #settings;
+    constructor(settings) {
+        this.#settings = settings;
+    }
+    async generateEmbedding(text, options) {
+        const api = new OpenAI({
+            apiKey: this.#settings.openAiKey,
+            organization: this.#settings.openAiOrganization,
+            dangerouslyAllowBrowser: true, // It's fine in Rivet
+        });
+        const response = await api.embeddings.create({
+            input: text,
+            model: options?.model ?? 'text-embedding-ada-002',
+            dimensions: options?.dimensions
+        });
+        const embeddings = response.data;
+        return embeddings[0].embedding;
+    }
+}