@alpic80/rivet-core 1.19.1-aidon.1

package/dist/esm/utils/chatMessageToOpenAIChatCompletionMessage.js

@@ -0,0 +1,60 @@
+import { match } from 'ts-pattern';
+import { uint8ArrayToBase64 } from './index.js';
+export async function chatMessageToOpenAIChatCompletionMessage(message) {
+    const onlyStringContent = (message) => {
+        const parts = Array.isArray(message.message) ? message.message : [message.message];
+        const stringContent = parts
+            .map((part) => {
+            if (typeof part !== 'string') {
+                throw new Error('System prompt must be a string');
+            }
+            return part;
+        })
+            .join('\n\n');
+        return stringContent;
+    };
+    return match(message)
+        .with({ type: 'system' }, (m) => ({ role: m.type, content: onlyStringContent(m) }))
+        .with({ type: 'user' }, async (m) => {
+        const parts = Array.isArray(m.message) ? m.message : [m.message];
+        if (parts.length === 1 && typeof parts[0] === 'string') {
+            return { role: m.type, content: parts[0] };
+        }
+        const chatMessageParts = await Promise.all(parts.map(async (part) => {
+            if (typeof part === 'string') {
+                return { type: 'text', text: part };
+            }
+            const url = part.type === 'url' ? part.url : `data:${part.mediaType};base64,${await uint8ArrayToBase64(part.data)}`;
+            return {
+                type: 'image_url',
+                image_url: { url },
+            };
+        }));
+        return { role: m.type, content: chatMessageParts };
+    })
+        .with({ type: 'assistant' }, (m) => ({
+        role: m.type,
+        content: onlyStringContent(m),
+        tool_calls: m.function_calls
+            ? m.function_calls.map((fc) => ({
+                id: fc.id ?? 'unknown_function_call',
+                type: 'function',
+                function: fc,
+            }))
+            : m.function_call
+                ? [
+                    {
+                        id: m.function_call.id ?? 'unknown_function_call',
+                        type: 'function',
+                        function: m.function_call,
+                    },
+                ]
+                : undefined,
+    }))
+        .with({ type: 'function' }, (m) => ({
+        role: 'tool',
+        content: onlyStringContent(m),
+        tool_call_id: m.name ?? 'unknown_function_call',
+    }))
+        .exhaustive();
+}

package/dist/esm/utils/coerceType.js

@@ -0,0 +1,322 @@
+import { match } from 'ts-pattern';
+import { getScalarTypeOf, isArrayDataType, isArrayDataValue, unwrapDataValue, } from '../model/DataValue.js';
+import { expectTypeOptional } from './expectType.js';
+export function coerceTypeOptional(wrapped, type) {
+    const value = wrapped ? unwrapDataValue(wrapped) : undefined;
+    // Coerce 'true' to [true] for example
+    if (isArrayDataType(type) && !isArrayDataValue(value)) {
+        const coerced = coerceTypeOptional(value, getScalarTypeOf(type));
+        if (coerced === undefined) {
+            return undefined;
+        }
+        return [coerced];
+    }
+    // Coerce foo[] to bar[]
+    if (isArrayDataType(type) && isArrayDataValue(value) && getScalarTypeOf(type) !== getScalarTypeOf(value.type)) {
+        return value.value.map((v) => coerceTypeOptional({ type: getScalarTypeOf(value.type), value: v }, getScalarTypeOf(type)));
+    }
+    const result = match(type)
+        .with('string', () => coerceToString(value))
+        .with('boolean', () => coerceToBoolean(value))
+        .with('chat-message', () => coerceToChatMessage(value))
+        .with('number', () => coerceToNumber(value))
+        .with('object', () => coerceToObject(value))
+        .with('binary', () => coerceToBinary(value))
+        .with('graph-reference', () => coerceToGraphReference(value))
+        .otherwise(() => {
+        if (!value) {
+            return value;
+        }
+        if (getScalarTypeOf(value.type) === 'any' || getScalarTypeOf(type) === 'any') {
+            return value.value;
+        }
+        return expectTypeOptional(value, type);
+    });
+    return result;
+}
+export function coerceType(value, type) {
+    const result = coerceTypeOptional(value, type);
+    if (result === undefined) {
+        throw new Error(`Expected value of type ${type} but got undefined`);
+    }
+    return result;
+}
+export function inferType(value) {
+    if (value === undefined) {
+        return { type: 'any', value: undefined };
+    }
+    if (value === null) {
+        return { type: 'any', value: null };
+    }
+    if (typeof value === 'function') {
+        return { type: 'fn<any>', value: value };
+    }
+    if (typeof value === 'string') {
+        return { type: 'string', value };
+    }
+    if (typeof value === 'boolean') {
+        return { type: 'boolean', value };
+    }
+    if (typeof value === 'number') {
+        return { type: 'number', value };
+    }
+    if (value instanceof Date) {
+        return { type: 'datetime', value: value.toISOString() };
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return { type: 'any[]', value: [] };
+        }
+        const inferredType = inferType(value[0]);
+        return { type: inferredType.type + '[]', value };
+    }
+    if (typeof value === 'object') {
+        return { type: 'object', value: value };
+    }
+    throw new Error(`Cannot infer type of value: ${value}`);
+}
+function coerceToString(value) {
+    if (!value) {
+        return '';
+    }
+    if (isArrayDataValue(value)) {
+        return value.value
+            .map((v) => coerceTypeOptional({ type: getScalarTypeOf(value.type), value: v }, 'string'))
+            .join('\n');
+    }
+    if (value.type === 'string') {
+        return value.value;
+    }
+    if (value.type === 'boolean') {
+        return value.value.toString();
+    }
+    if (value.type === 'number') {
+        return value.value.toString();
+    }
+    if (value.type === 'date') {
+        return value.value;
+    }
+    if (value.type === 'time') {
+        return value.value;
+    }
+    if (value.type === 'datetime') {
+        return value.value;
+    }
+    if (value.type === 'chat-message') {
+        const messageParts = Array.isArray(value.value.message) ? value.value.message : [value.value.message];
+        const singleString = messageParts
+            .map((part) => {
+            if (typeof part === 'string') {
+                return part;
+            }
+            return part.type === 'url' ? `(Image: ${part.url})` : '(Image)';
+        })
+            .join('\n\n');
+        return singleString;
+    }
+    if (value.value === undefined) {
+        return undefined;
+    }
+    if (value.value === null) {
+        return undefined;
+    }
+    if (typeof value.value === 'object' && !Array.isArray(value.value)) {
+        return JSON.stringify(value.value);
+    }
+    // Don't know, so try to infer it from the type of the value
+    // Any and object are basically the same...
+    if (value.type === 'any' || value.type === 'object') {
+        const inferred = inferType(value.value);
+        return coerceTypeOptional(inferred, 'string');
+    }
+    return JSON.stringify(value.value);
+}
+function coerceToChatMessage(value) {
+    const chatMessage = coerceToChatMessageRaw(value);
+    if (chatMessage?.type === 'assistant') {
+        // Double check that arguments is a string, stringify if needed
+        if (chatMessage.function_call?.arguments && typeof chatMessage.function_call.arguments !== 'string') {
+            chatMessage.function_call.arguments = JSON.stringify(chatMessage.function_call.arguments);
+        }
+    }
+    return chatMessage;
+}
+function coerceToChatMessageRaw(value) {
+    if (!value || value.value == null) {
+        return undefined;
+    }
+    if (value.type === 'chat-message') {
+        return value.value;
+    }
+    if (value.type === 'string') {
+        return { type: 'user', message: value.value };
+    }
+    if (value.type === 'object' &&
+        'type' in value.value &&
+        'message' in value.value &&
+        typeof value.value.type === 'string' &&
+        typeof value.value.message === 'string') {
+        return value.value;
+    }
+    if (value.type === 'any') {
+        const inferred = inferType(value.value);
+        return coerceTypeOptional(inferred, 'chat-message');
+    }
+}
+function coerceToBoolean(value) {
+    if (!value || !value.value) {
+        return false;
+    }
+    if (isArrayDataValue(value)) {
+        return value.value
+            .map((v) => coerceTypeOptional({ type: value.type.replace('[]', ''), value: v }, 'boolean'))
+            .every((v) => v);
+    }
+    if (value.type === 'string') {
+        return value.value.length > 0 && value.value !== 'false';
+    }
+    if (value.type === 'boolean') {
+        return value.value;
+    }
+    if (value.type === 'number') {
+        return value.value !== 0;
+    }
+    if (value.type === 'date') {
+        return true;
+    }
+    if (value.type === 'time') {
+        return true;
+    }
+    if (value.type === 'datetime') {
+        return true;
+    }
+    if (value.type === 'chat-message') {
+        const hasValue = (Array.isArray(value.value.message) && value.value.message.length > 0) ||
+            (typeof value.value.message === 'string' && value.value.message.length > 0) ||
+            (typeof value.value.message === 'object' &&
+                'type' in value.value.message &&
+                value.value.message.type === 'url' &&
+                value.value.message.url.length > 0);
+        return hasValue;
+    }
+    return !!value.value;
+}
+function coerceToNumber(value) {
+    if (!value || value.value == null) {
+        return undefined;
+    }
+    if (isArrayDataValue(value)) {
+        return undefined;
+    }
+    if (value.type === 'string') {
+        return parseFloat(value.value);
+    }
+    if (value.type === 'boolean') {
+        return value.value ? 1 : 0;
+    }
+    if (value.type === 'number') {
+        return value.value;
+    }
+    if (value.type === 'date') {
+        return new Date(value.value).valueOf();
+    }
+    if (value.type === 'time') {
+        return new Date(value.value).valueOf();
+    }
+    if (value.type === 'datetime') {
+        return new Date(value.value).valueOf();
+    }
+    if (value.type === 'chat-message') {
+        if (typeof value.value.message === 'string') {
+            return parseFloat(value.value.message);
+        }
+        if (Array.isArray(value.value.message) &&
+            value.value.message.length === 1 &&
+            typeof value.value.message[0] === 'string') {
+            return parseFloat(value.value.message[0]);
+        }
+        return undefined;
+    }
+    if (value.type === 'any' || value.type === 'object') {
+        const inferred = inferType(value.value);
+        return coerceTypeOptional(inferred, 'number');
+    }
+    return undefined;
+}
+function coerceToObject(value) {
+    if (!value || value.value == null) {
+        return undefined;
+    }
+    return value.value; // Whatever, consider anything an object
+}
+function coerceToBinary(value) {
+    if (!value || value.value == null) {
+        return undefined;
+    }
+    if (value.type === 'binary') {
+        return value.value;
+    }
+    if (value.type === 'string') {
+        return new TextEncoder().encode(value.value);
+    }
+    if (value.type === 'boolean') {
+        return new TextEncoder().encode(value.value.toString());
+    }
+    if (value.type === 'vector' || value.type === 'number[]') {
+        return new Uint8Array(value.value);
+    }
+    if (value.type === 'number') {
+        return new Uint8Array([value.value]);
+    }
+    if (value.type === 'audio' || value.type === 'image') {
+        return value.value.data;
+    }
+    return new TextEncoder().encode(JSON.stringify(value.value));
+}
+function coerceToGraphReference(value) {
+    if (!value || value.value == null) {
+        return undefined;
+    }
+    if (value.type === 'graph-reference') {
+        return value.value;
+    }
+    if (value.type === 'string') {
+        return { graphName: value.value, graphId: '' };
+    }
+    if (value.type === 'object' && 'graphName' in value.value && 'graphId' in value.value) {
+        return value.value;
+    }
+    return undefined;
+}
+export function canBeCoercedAny(from, to) {
+    for (const fromType of Array.isArray(from) ? from : [from]) {
+        for (const toType of Array.isArray(to) ? to : [to]) {
+            if (canBeCoerced(fromType, toType)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+// TODO hard to keep in sync with coerceType
+export function canBeCoerced(from, to) {
+    if (to === 'any' || from === 'any') {
+        return true;
+    }
+    if (isArrayDataType(to) && isArrayDataType(from)) {
+        return canBeCoerced(getScalarTypeOf(from), getScalarTypeOf(to));
+    }
+    if (isArrayDataType(to) && !isArrayDataType(from)) {
+        return canBeCoerced(from, getScalarTypeOf(to));
+    }
+    if (isArrayDataType(from) && !isArrayDataType(to)) {
+        return to === 'string' || to === 'object';
+    }
+    if (to === 'gpt-function') {
+        return from === 'object';
+    }
+    if (to === 'audio' || to === 'binary' || to === 'image') {
+        return false;
+    }
+    return true;
+}

package/dist/esm/utils/compatibility.js

@@ -0,0 +1,27 @@
+import { isArrayDataType } from '../model/DataValue.js';
+export function isDataTypeAccepted(inputType, accepted) {
+    inputType = Array.isArray(inputType) ? inputType : [inputType];
+    accepted = Array.isArray(accepted) ? accepted : [accepted];
+    for (const input of inputType) {
+        for (const accept of accepted) {
+            if (isDataTypeCompatible(input, accept)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function isDataTypeCompatible(inputType, accepted) {
+    // Any is always compatible on either side
+    if (inputType === 'any' || accepted === 'any') {
+        return true;
+    }
+    // If they're both arrays, and either is 'any[]', it's compatible
+    if (isArrayDataType(inputType) && isArrayDataType(accepted) && (inputType === 'any[]' || accepted === 'any[]')) {
+        return true;
+    }
+    if (inputType === accepted) {
+        return true;
+    }
+    return false;
+}

package/dist/esm/utils/copyToClipboard.js

@@ -0,0 +1,10 @@
+export const copyToClipboard = (text) => {
+    const textarea = document.createElement('textarea');
+    textarea.textContent = text;
+    textarea.style.position = 'absolute';
+    textarea.style.left = '-9999px';
+    document.body.appendChild(textarea);
+    textarea.select();
+    document.execCommand('copy');
+    document.body.removeChild(textarea);
+};

package/dist/esm/utils/defaults.js

@@ -0,0 +1,2 @@
+export const DEFAULT_CHAT_ENDPOINT = 'https://api.openai.com/v1/chat/completions';
+export const DEFAULT_CHAT_NODE_TIMEOUT = 30_000;

package/dist/esm/utils/errors.js

@@ -0,0 +1,7 @@
+/** Gets an Error from an unknown error object (strict unknown errors is enabled, helper util). */
+export function getError(error) {
+    const errorInstance = typeof error === 'object' && error instanceof Error
+        ? error
+        : new Error(error != null ? error.toString() : 'Unknown error');
+    return errorInstance;
+}

package/dist/esm/utils/expectType.js

@@ -0,0 +1,34 @@
+import { getScalarTypeOf, isArrayDataType, isFunctionDataType, isScalarDataValue, unwrapDataValue, } from '../model/DataValue.js';
+export function expectType(value, type) {
+    // Allow a string to be expected for a string[], just return an array of one element
+    if (isArrayDataType(type) && isScalarDataValue(value) && getScalarTypeOf(type) === value.type) {
+        return [value.value];
+    }
+    if (type === 'any' || type === 'any[]' || value?.type === 'any' || value?.type === 'any[]') {
+        return value?.value;
+    }
+    if ((isFunctionDataType(type) && value?.type === `fn<${type}>`) || type === 'fn<any>') {
+        return (() => value.value);
+    }
+    if (value?.type !== type) {
+        throw new Error(`Expected value of type ${type} but got ${value?.type}`);
+    }
+    return value.value;
+}
+export function expectTypeOptional(value, type) {
+    if (value === undefined) {
+        return undefined;
+    }
+    // Allow a string to be expected for a string[], just return an array of one element
+    if (isArrayDataType(type) && isScalarDataValue(value) && getScalarTypeOf(type) === value.type) {
+        return [value.value];
+    }
+    // We allow a fn<string> to be expected for a string, so unwrap it on demand
+    if (isFunctionDataType(value.type) && value.type === `fn<${type}>`) {
+        value = unwrapDataValue(value);
+    }
+    if (value.type !== type) {
+        throw new Error(`Expected value of type ${type} but got ${value?.type}`);
+    }
+    return value.value;
+}

package/dist/esm/utils/fetchEventSource.js

@@ -0,0 +1,120 @@
+import { getError } from './errors.js';
+import { DEFAULT_CHAT_NODE_TIMEOUT } from './defaults.js';
+// https://github.com/openai/openai-node/issues/18#issuecomment-1518715285
+export class EventSourceResponse extends Response {
+    name;
+    timeout;
+    streams;
+    constructor(body, init, timeout) {
+        if (body == null) {
+            super(null, init);
+            this.name = 'EventSourceResponse';
+            this.streams = null;
+            this.timeout = timeout;
+            return;
+        }
+        const [bodyForString, bodyForEvents] = body.tee();
+        const streams = createEventStream(bodyForEvents);
+        // By passing our transformed stream into the Response constructor, we prevent anyone
+        // from accidentally accessing the raw response.body stream.
+        super(bodyForString, init);
+        this.name = 'EventSourceResponse';
+        this.streams = streams;
+        this.timeout = timeout;
+    }
+    async *events() {
+        if (this.streams == null) {
+            return;
+        }
+        const reader = this.streams.eventStream.getReader();
+        try {
+            while (true) {
+                const { done, value } = await this.raceWithTimeout(reader.read(), this.timeout);
+                if (done) {
+                    break;
+                }
+                yield value;
+            }
+        }
+        finally {
+            try {
+                reader.releaseLock();
+            }
+            catch (err) {
+                console.error(`Failed to release read lock on event source: ${getError(err).toString()}`);
+            }
+        }
+    }
+    async raceWithTimeout(promise, timeout) {
+        const raceTimeout = timeout ?? DEFAULT_CHAT_NODE_TIMEOUT;
+        // eslint-disable-next-line no-async-promise-executor -- Error handled correctly
+        return new Promise(async (resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error('Timeout: API response took too long.'));
+            }, raceTimeout);
+            try {
+                const result = await promise;
+                clearTimeout(timer);
+                resolve(result);
+            }
+            catch (error) {
+                clearTimeout(timer);
+                reject(error);
+            }
+        });
+    }
+}
+export default async function fetchEventSource(url, init, timeout) {
+    const headers = {
+        ...init?.headers,
+        accept: 'text/event-stream',
+    };
+    const response = await fetch(url, {
+        ...init,
+        headers,
+    });
+    return new EventSourceResponse(response.body, response, timeout);
+}
+class LineSplitter {
+    separator;
+    buffer = '';
+    constructor(separator = /\n+/) {
+        this.separator = separator;
+    }
+    transform(chunk, controller) {
+        this.buffer += chunk;
+        const lines = this.buffer.split(this.separator);
+        this.buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            controller.enqueue(line);
+        }
+    }
+    flush(controller) {
+        if (this.buffer.length > 0) {
+            controller.enqueue(this.buffer);
+            this.buffer = '';
+        }
+    }
+}
+function createEventStream(body) {
+    if (body == null) {
+        return null;
+    }
+    const textStream = body.pipeThrough(new TextDecoderStream());
+    const eventStream = textStream.pipeThrough(new TransformStream(new LineSplitter())).pipeThrough(new TransformStream({
+        transform(line, controller) {
+            if (line.trim().length === 0) {
+                return;
+            }
+            if (line.startsWith('data: ')) {
+                const data = line.slice(6).trim();
+                controller.enqueue(data);
+            }
+            else if (line.startsWith('event: ')) {
+                const event = line.slice(7).trim();
+                controller.enqueue(`[${event}]`);
+            }
+        },
+    }));
+    return { eventStream, textStream };
+}

package/dist/esm/utils/genericUtilFunctions.js

@@ -0,0 +1,25 @@
+export function isNotNull(value) {
+    return value != null;
+}
+/**
+ * Checks that the given tuple is exhaustive, ie. it represents all possible values in the union T.
+ * Note that this function returns a function, so the function needs to be called like
+ * `SpecificStrings.exhaustiveTuple<Furniture>()('v1', 'v2', ...)`.
+ * If you miss a value, the type error will tell you which value you missed.
+ *
+ * Taken from https://stackoverflow.com/a/55266531/
+ *
+ * @example
+ *   type Furniture = 'chair' | 'table' | 'lamp' | 'ottoman';
+ *   const furniture = SpecificStrings.exhaustiveTuple<Furniture>()('chair', 'table', 'lamp', 'ottoman');
+ *
+ *   // error, argument of type '"chair"' is not assignable to parameter of type '"You are missing ottoman"'.
+ *   const missingFurniture = SpecificStrings.exhaustiveTuple<Furniture>()('chair', 'table', 'lamp');
+ */
+export const exhaustiveTuple = () => 
+// impressive inference from TS: it knows when the condition and the true branch can't both be satisfied
+(...x) => x;
+/**
+ * See exhaustiveTuple above. Does the same thing except returns a Set, not an array.
+ */
+export const exhaustiveSet = () => (...x) => new Set(x);

package/dist/esm/utils/getPluginConfig.js

@@ -0,0 +1,23 @@
+export function getPluginConfig(plugin, settings, name) {
+    if (!plugin) {
+        return undefined;
+    }
+    const configSpec = plugin?.configSpec?.[name];
+    if (!configSpec) {
+        return undefined;
+    }
+    const pluginSettings = settings.pluginSettings?.[plugin.id];
+    if (pluginSettings) {
+        const value = pluginSettings[name];
+        if (!value || typeof value !== 'string') {
+            return undefined;
+        }
+        return value;
+    }
+    const envFallback = configSpec.pullEnvironmentVariable;
+    const envFallbackName = envFallback === true ? name : envFallback;
+    if (envFallbackName && settings.pluginEnv?.[envFallbackName]) {
+        return settings.pluginEnv[envFallbackName];
+    }
+    return undefined;
+}

package/dist/esm/utils/handleEscapeCharacters.js

@@ -0,0 +1,11 @@
+/** Let the user type things like \n and \t in the editor, and they'll be replaced with the actual characters. */
+export function handleEscapeCharacters(inputString) {
+    // Would use negative lookbehind but not supported in some recent safari versions >.<
+    return inputString
+        .replace(/([^\\]|^)\\n/g, '$1\n')
+        .replace(/([^\\]|^)\\t/g, '$1\t')
+        .replace(/([^\\]|^)\\r/g, '$1\r')
+        .replace(/([^\\]|^)\\f/g, '$1\f')
+        .replace(/([^\\]|^)\\b/g, '$1\b')
+        .replace(/([^\\]|^)\\v/g, '$1\v');
+}

package/dist/esm/utils/index.js

@@ -0,0 +1,14 @@
+export * from './coerceType.js';
+export * from './expectType.js';
+export * from './errors.js';
+export * from './serialization/serialization.js';
+export * from './outputs.js';
+export * from './base64.js';
+export * from './inputs.js';
+export * from './misc.js';
+export * from './getPluginConfig.js';
+export * from './newId.js';
+export * from './serialization/serializationUtils.js';
+export * from './handleEscapeCharacters.js';
+export * from './compatibility.js';
+export * from './defaults.js';

package/dist/esm/utils/inputs.js

@@ -0,0 +1,16 @@
+import { coerceTypeOptional } from './coerceType.js';
+import { entries } from './typeSafety.js';
+export function getInputOrData(data, inputs, inputAndDataKey, type, useInputToggleDataKey) {
+    if (!useInputToggleDataKey) {
+        const capitalized = inputAndDataKey[0].toUpperCase() + inputAndDataKey.slice(1);
+        const key = `use${capitalized}Input`;
+        useInputToggleDataKey = key;
+    }
+    const value = data[useInputToggleDataKey] && inputs[inputAndDataKey] != null
+        ? coerceTypeOptional(inputs[inputAndDataKey], type ?? 'string') ?? data[inputAndDataKey]
+        : data[inputAndDataKey];
+    return value;
+}
+export function cleanHeaders(headers) {
+    return Object.fromEntries(entries(headers).filter(([key]) => key.trim()));
+}