@alpic80/rivet-core 1.19.1-aidon.1

package/dist/esm/utils/interpolation.js

@@ -0,0 +1,6 @@
+export function interpolate(baseString, values) {
+    return baseString.replace(/\{\{([^}]+)\}\}/g, (_m, p1) => {
+        const value = values[p1];
+        return value !== undefined ? value : '';
+    });
+}

package/dist/esm/utils/misc.js

@@ -0,0 +1 @@
+export { dedent } from 'ts-dedent';

package/dist/esm/utils/newId.js

@@ -0,0 +1,4 @@
+import { nanoid } from 'nanoid/non-secure';
+export function newId() {
+    return nanoid();
+}

package/dist/esm/utils/openai.js

@@ -0,0 +1,219 @@
+import { orderBy } from 'lodash-es';
+import { DEFAULT_CHAT_NODE_TIMEOUT } from './defaults.js';
+import fetchEventSource from './fetchEventSource.js';
+export const openaiModels = {
+    'gpt-4': {
+        maxTokens: 8192,
+        cost: {
+            prompt: 0.03,
+            completion: 0.06,
+        },
+        displayName: 'GPT-4',
+    },
+    'gpt-4-32k': {
+        maxTokens: 32768,
+        cost: {
+            prompt: 0.06,
+            completion: 0.12,
+        },
+        displayName: 'GPT-4 32k',
+    },
+    'gpt-4-0613': {
+        maxTokens: 8192,
+        cost: {
+            prompt: 0.03,
+            completion: 0.06,
+        },
+        displayName: 'GPT-4 (v0613)',
+    },
+    'gpt-4-32k-0613': {
+        maxTokens: 32768,
+        cost: {
+            prompt: 0.06,
+            completion: 0.12,
+        },
+        displayName: 'GPT-4 32k (v0613)',
+    },
+    'gpt-3.5-turbo': {
+        maxTokens: 4096,
+        cost: {
+            prompt: 0.002,
+            completion: 0.002,
+        },
+        displayName: 'GPT-3.5 Turbo',
+    },
+    'gpt-3.5-turbo-16k': {
+        maxTokens: 16384,
+        cost: {
+            prompt: 0.001,
+            completion: 0.002,
+        },
+        displayName: 'GPT-3.5 16k',
+    },
+    'gpt-3.5-turbo-0613': {
+        maxTokens: 16384,
+        cost: {
+            prompt: 0.002,
+            completion: 0.002,
+        },
+        displayName: 'GPT-3.5 (v0613)',
+    },
+    'gpt-3.5-turbo-1106': {
+        maxTokens: 16385,
+        cost: {
+            prompt: 0.001,
+            completion: 0.002,
+        },
+        displayName: 'GPT-3.5 (v1106)',
+    },
+    'gpt-3.5-turbo-16k-0613': {
+        maxTokens: 16384,
+        cost: {
+            prompt: 0.001,
+            completion: 0.002,
+        },
+        displayName: 'GPT-3.5 16k (v0613)',
+    },
+    'gpt-3.5-turbo-0301': {
+        maxTokens: 16384,
+        cost: {
+            prompt: 0.002,
+            completion: 0.002,
+        },
+        displayName: 'GPT-3.5 (v0301)',
+    },
+    'gpt-4-0314': {
+        maxTokens: 8192,
+        cost: {
+            prompt: 0.03,
+            completion: 0.06,
+        },
+        displayName: 'GPT-4 (v0314)',
+    },
+    'gpt-4-32k-0314': {
+        maxTokens: 32768,
+        cost: {
+            prompt: 0.06,
+            completion: 0.12,
+        },
+        displayName: 'GPT-4 32k (v0314)',
+    },
+    'gpt-4-1106-preview': {
+        maxTokens: 128000,
+        cost: {
+            prompt: 0.01,
+            completion: 0.03,
+        },
+        displayName: 'GPT-4 Turbo 128K (1106 Preview)',
+    },
+    'gpt-4-turbo': {
+        maxTokens: 128000,
+        cost: {
+            prompt: 0.01,
+            completion: 0.03,
+        },
+        displayName: 'GPT-4 Turbo 128K with Vision',
+    },
+    'gpt-4-vision-preview': {
+        maxTokens: 128000,
+        cost: {
+            prompt: 0.01,
+            completion: 0.03,
+        },
+        displayName: 'GPT-4 Vision (Preview)',
+    },
+    'gpt-4o': {
+        maxTokens: 128000,
+        cost: {
+            prompt: 0.005,
+            completion: 0.015,
+        },
+        displayName: 'GPT-4o',
+    },
+    'gpt-4o-mini': {
+        maxTokens: 128000,
+        cost: {
+            prompt: 0.00015,
+            completion: 0.00075,
+        },
+        displayName: 'GPT-4o mini',
+    },
+    'gpt-4o-mini-2024-07-18': {
+        maxTokens: 128000,
+        cost: {
+            prompt: 0.00015,
+            completion: 0.00075,
+        },
+        displayName: 'GPT-4o mini (2024-07-18)',
+    },
+    'local-model': {
+        maxTokens: Number.MAX_SAFE_INTEGER,
+        cost: {
+            prompt: 0,
+            completion: 0,
+        },
+        displayName: 'Local Model',
+    },
+};
+export const openAiModelOptions = orderBy(Object.entries(openaiModels).map(([id, { displayName }]) => ({
+    value: id,
+    label: displayName,
+})), 'label');
+export class OpenAIError extends Error {
+    status;
+    responseJson;
+    constructor(status, responseJson) {
+        super(`OpenAIError: ${status} ${JSON.stringify(responseJson)}`);
+        this.status = status;
+        this.responseJson = responseJson;
+        this.name = 'OpenAIError';
+    }
+}
+export async function* streamChatCompletions({ endpoint, auth, signal, headers, timeout, ...rest }) {
+    const abortSignal = signal ?? new AbortController().signal;
+    const response = await fetchEventSource(endpoint, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${auth.apiKey}`,
+            ...(auth.organization ? { 'OpenAI-Organization': auth.organization } : {}),
+            ...headers,
+        },
+        body: JSON.stringify({
+            ...rest,
+            stream: true,
+        }),
+        signal: abortSignal,
+    }, timeout ?? DEFAULT_CHAT_NODE_TIMEOUT);
+    let hadChunks = false;
+    for await (const chunk of response.events()) {
+        hadChunks = true;
+        if (chunk === '[DONE]' || abortSignal?.aborted) {
+            return;
+        }
+        let data;
+        try {
+            data = JSON.parse(chunk);
+        }
+        catch (err) {
+            console.error('JSON parse failed on chunk: ', chunk);
+            throw err;
+        }
+        yield data;
+    }
+    if (!hadChunks) {
+        const responseJson = await response.json();
+        throw new OpenAIError(response.status, responseJson);
+    }
+}
+export const openAIFilePurposeOptions = [
+    { value: 'fine-tune', label: 'Fine-tuning' },
+    { value: 'fine-tune-results', label: 'Fine-tuning Results' },
+    { value: 'assistants', label: 'Assistants' },
+    { value: 'assistants_output', label: 'Assistants Output' },
+];
+export const openAIFileUploadPurposeOptions = [
+    { value: 'fine-tune', label: 'Fine-tuning' },
+    { value: 'assistants', label: 'Assistants' },
+    { value: 'assistants_output', label: 'Assistants Output' },
+];

package/dist/esm/utils/outputs.js

@@ -0,0 +1,14 @@
+import { expectType } from './expectType.js';
+import { WarningsPort } from './symbols.js';
+export function addWarning(outputs, warning) {
+    if (!outputs[WarningsPort]) {
+        outputs[WarningsPort] = { type: 'string[]', value: [] };
+    }
+    outputs[WarningsPort].value.push(warning);
+}
+export function getWarnings(outputs) {
+    if (!outputs?.[WarningsPort]) {
+        return undefined;
+    }
+    return expectType(outputs[WarningsPort], 'string[]');
+}

package/dist/esm/utils/serialization/serialization.js

@@ -0,0 +1,86 @@
+// @ts-ignore
+import * as yaml from 'yaml';
+import { graphV3Deserializer, projectV3Deserializer } from './serialization_v3.js';
+import { getError } from '../errors.js';
+import { yamlProblem } from './serializationUtils.js';
+import { datasetV4Deserializer, datasetV4Serializer, graphV4Deserializer, graphV4Serializer, projectV4Deserializer, projectV4Serializer, } from './serialization_v4.js';
+import { graphV2Deserializer, projectV2Deserializer } from './serialization_v2.js';
+import { graphV1Deserializer, projectV1Deserializer } from './serialization_v1.js';
+export function serializeProject(project, attachedData) {
+    return projectV4Serializer(project, attachedData);
+}
+const errMessage = (err) => `${getError(err).message}\n${getError(err).stack}`;
+export function deserializeProject(serializedProject, path = null) {
+    try {
+        const result = projectV4Deserializer(serializedProject);
+        if (path !== null)
+            result[0].metadata.path = path;
+        return result;
+    }
+    catch (err) {
+        if (err instanceof yaml.YAMLError) {
+            yamlProblem(err);
+        }
+        console.warn(`Failed to deserialize project v4: ${errMessage(err)}`);
+        try {
+            const project = projectV3Deserializer(serializedProject);
+            return [project, {}];
+        }
+        catch (err) {
+            if (err instanceof yaml.YAMLError) {
+                yamlProblem(err);
+            }
+            console.warn(`Failed to deserialize project v3: ${errMessage(err)}`);
+            try {
+                const project = projectV2Deserializer(serializedProject);
+                return [project, {}];
+            }
+            catch (err) {
+                if (err instanceof yaml.YAMLError) {
+                    yamlProblem(err);
+                }
+                console.warn(`Failed to deserialize project v2: ${errMessage(err)}`);
+                try {
+                    const project = projectV1Deserializer(serializedProject);
+                    return [project, {}];
+                }
+                catch (err) {
+                    console.warn(`Failed to deserialize project v1: ${errMessage(err)}`);
+                    throw new Error('Could not deserialize project');
+                }
+            }
+        }
+    }
+}
+export function serializeGraph(graph) {
+    return graphV4Serializer(graph);
+}
+export function deserializeGraph(serializedGraph) {
+    try {
+        return graphV4Deserializer(serializedGraph);
+    }
+    catch (err) {
+        try {
+            return graphV3Deserializer(serializedGraph);
+        }
+        catch (err) {
+            try {
+                return graphV2Deserializer(serializedGraph);
+            }
+            catch (err) {
+                try {
+                    return graphV1Deserializer(serializedGraph);
+                }
+                catch (err) {
+                    throw new Error('Could not deserialize graph');
+                }
+            }
+        }
+    }
+}
+export function serializeDatasets(datasets) {
+    return datasetV4Serializer(datasets);
+}
+export function deserializeDatasets(serializedDatasets) {
+    return datasetV4Deserializer(serializedDatasets);
+}

package/dist/esm/utils/serialization/serializationUtils.js

@@ -0,0 +1,13 @@
+export function doubleCheckProject(project) {
+    if (!project.metadata ||
+        !project.metadata.id ||
+        !project.metadata.title ||
+        !project.graphs ||
+        typeof project.graphs !== 'object') {
+        throw new Error('Invalid project file');
+    }
+}
+export function yamlProblem(err) {
+    const { code, message, pos, linePos } = err;
+    throw new Error(`YAML error: ${code} ${message} at ${pos} ${linePos}`);
+}

package/dist/esm/utils/serialization/serialization_v1.js

@@ -0,0 +1,19 @@
+import { doubleCheckProject } from './serializationUtils.js';
+export function projectV1Deserializer(data) {
+    if (typeof data !== 'string') {
+        throw new Error('Project v1 deserializer requires a string');
+    }
+    const project = JSON.parse(data);
+    doubleCheckProject(project);
+    return project;
+}
+export function graphV1Deserializer(data) {
+    if (typeof data !== 'string') {
+        throw new Error('Graph v1 deserializer requires a string');
+    }
+    const graph = JSON.parse(data);
+    if (!graph.nodes || !graph.connections) {
+        throw new Error('Invalid graph file');
+    }
+    return graph;
+}

package/dist/esm/utils/serialization/serialization_v2.js

@@ -0,0 +1,24 @@
+import { doubleCheckProject } from './serializationUtils.js';
+// @ts-ignore
+import * as yaml from 'yaml';
+export function projectV2Deserializer(data) {
+    if (typeof data !== 'string') {
+        throw new Error('Project v2 deserializer requires a string');
+    }
+    const project = yaml.parse(data);
+    if (project.version !== 2) {
+        throw new Error('Project v2 deserializer requires a version 2 project');
+    }
+    doubleCheckProject(project.data);
+    return project.data;
+}
+export function graphV2Deserializer(data) {
+    if (typeof data !== 'string') {
+        throw new Error('Graph v2 deserializer requires a string');
+    }
+    const graph = yaml.parse(data);
+    if (graph.version !== 2) {
+        throw new Error('Graph v2 deserializer requires a version 2 graph');
+    }
+    return graph.data;
+}

package/dist/esm/utils/serialization/serialization_v3.js

@@ -0,0 +1,145 @@
+import { mapValues } from 'lodash-es';
+import stableStringify from 'safe-stable-stringify';
+// @ts-ignore
+import * as yaml from 'yaml';
+import { doubleCheckProject } from './serializationUtils.js';
+export function projectV3Deserializer(data) {
+    if (typeof data !== 'string') {
+        throw new Error('Project v3 deserializer requires a string');
+    }
+    const serializedProject = yaml.parse(data);
+    if (serializedProject.version !== 3) {
+        throw new Error('Project v3 deserializer requires a version 3 project');
+    }
+    const project = fromSerializedProject(serializedProject.data);
+    doubleCheckProject(project);
+    return project;
+}
+export function graphV3Deserializer(data) {
+    if (typeof data !== 'string') {
+        throw new Error('Graph v3 deserializer requires a string');
+    }
+    const serializedGraph = yaml.parse(data);
+    if (serializedGraph.version !== 3) {
+        throw new Error('Graph v3 deserializer requires a version 3 graph');
+    }
+    return fromSerializedGraph(serializedGraph.data);
+}
+export function projectV3Serializer(project) {
+    // Make sure all data is ordered deterministically first
+    const stabilized = JSON.parse(stableStringify(toSerializedProject(project)));
+    const serialized = yaml.stringify({
+        version: 3,
+        data: stabilized,
+    }, null, {
+        indent: 2,
+    });
+    return serialized;
+}
+export function graphV3Serializer(graph) {
+    // Make sure all data is ordered deterministically first
+    const stabilized = JSON.parse(stableStringify(toSerializedGraph(graph)));
+    const serialized = yaml.stringify({
+        version: 4,
+        data: stabilized,
+    }, null, {
+        indent: 2,
+    });
+    return serialized;
+}
+function toSerializedProject(project) {
+    return {
+        metadata: project.metadata,
+        graphs: mapValues(project.graphs, (graph) => toSerializedGraph(graph)),
+    };
+}
+function fromSerializedProject(serializedProject) {
+    return {
+        metadata: serializedProject.metadata,
+        graphs: mapValues(serializedProject.graphs, (graph) => fromSerializedGraph(graph)),
+        plugins: [],
+    };
+}
+function toSerializedGraph(graph) {
+    return {
+        metadata: {
+            id: graph.metadata.id,
+            name: graph.metadata.name,
+            description: graph.metadata.description,
+        },
+        nodes: graph.nodes.reduce((acc, node) => ({
+            ...acc,
+            [node.id]: toSerializedNode(node, graph.nodes, graph.connections),
+        }), {}),
+    };
+}
+function fromSerializedGraph(serializedGraph) {
+    const allConnections = [];
+    const allNodes = [];
+    for (const node of Object.values(serializedGraph.nodes)) {
+        const [chartNode, connections] = fromSerializedNode(node);
+        allNodes.push(chartNode);
+        allConnections.push(...connections);
+    }
+    return {
+        metadata: {
+            id: serializedGraph.metadata.id,
+            name: serializedGraph.metadata.name,
+            description: serializedGraph.metadata.description,
+        },
+        nodes: allNodes,
+        connections: allConnections,
+    };
+}
+function toSerializedNode(node, allNodes, allConnections) {
+    return {
+        id: node.id,
+        title: node.title,
+        description: node.description,
+        type: node.type,
+        visualData: `${node.visualData.x}/${node.visualData.y}/${node.visualData.width ?? 'null'}/${node.visualData.zIndex ?? 'null'}`,
+        isSplitRun: node.isSplitRun,
+        splitRunMax: node.splitRunMax,
+        data: node.data,
+        outgoingConnections: allConnections
+            .filter((connection) => connection.outputNodeId === node.id)
+            .map((connection) => toSerializedConnection(connection, allNodes))
+            .sort(),
+        variants: (node.variants?.length ?? 0) > 0 ? node.variants : undefined,
+    };
+}
+function fromSerializedNode(serializedNode) {
+    const [x, y, width, zIndex] = serializedNode.visualData.split('/');
+    const connections = serializedNode.outgoingConnections.map((serializedConnection) => fromSerializedConnection(serializedConnection, serializedNode));
+    return [
+        {
+            id: serializedNode.id,
+            title: serializedNode.title,
+            description: serializedNode.description,
+            type: serializedNode.type,
+            isSplitRun: serializedNode.isSplitRun,
+            splitRunMax: serializedNode.splitRunMax,
+            visualData: {
+                x: parseFloat(x),
+                y: parseFloat(y),
+                width: width === 'null' ? undefined : parseFloat(width),
+                zIndex: zIndex === 'null' ? undefined : parseFloat(zIndex),
+            },
+            data: serializedNode.data,
+            variants: serializedNode.variants,
+        },
+        connections,
+    ];
+}
+function toSerializedConnection(connection, allNodes) {
+    return `${connection.outputId}->"${allNodes.find((node) => node.id === connection.inputNodeId)?.title}" ${connection.inputNodeId}/${connection.inputId}`;
+}
+function fromSerializedConnection(connection, outgoingNode) {
+    const [, outputId, , inputNodeId, inputId] = connection.match(/(.+)->"(.+)" (.+)\/(.+)/);
+    return {
+        outputId: outputId,
+        outputNodeId: outgoingNode.id,
+        inputId: inputId,
+        inputNodeId: inputNodeId,
+    };
+}