@alpic80/rivet-core 1.19.1-aidon.3 → 1.24.0-aidon.3

package/dist/esm/recording/ExecutionRecorder.js

@@ -1,6 +1,8 @@
 import { nanoid } from 'nanoid/non-secure';
 import {} from '../index.js';
 import Emittery from 'emittery';
+import { uint8ArrayToBase64Sync, base64ToUint8Array } from '../utils/base64.js';
+import { isPlainObject } from 'lodash-es';
 const toRecordedEventMap = {
     graphStart: ({ graph, inputs }) => ({ graphId: graph.metadata.id, inputs }),
     graphFinish: ({ graph, outputs }) => ({ graphId: graph.metadata.id, outputs }),
@@ -36,11 +38,13 @@ const toRecordedEventMap = {
         outputs,
         reason,
     }),
-    userInput: ({ node, inputs, callback, processId }) => ({
+    userInput: ({ node, inputs, callback, processId, inputStrings, renderingType }) => ({
         nodeId: node.id,
         inputs,
         callback,
         processId,
+        inputStrings,
+        renderingType,
     }),
     partialOutput: ({ node, outputs, index, processId }) => ({
         nodeId: node.id,
@@ -91,6 +95,25 @@ function toRecordedEvent(event, data) {
         ts: Date.now(),
     };
 }
+function mapValuesDeep(obj, fn) {
+    if (Array.isArray(obj)) {
+        return obj.map((value) => {
+            if (isPlainObject(value) || Array.isArray(value)) {
+                return mapValuesDeep(value, fn);
+            }
+            return fn(value);
+        });
+    }
+    if (isPlainObject(obj)) {
+        return Object.fromEntries(Object.entries(obj).map(([key, value]) => {
+            if (isPlainObject(value) || Array.isArray(value)) {
+                return [key, mapValuesDeep(value, fn)];
+            }
+            return [key, fn(value)];
+        }));
+    }
+    return fn(obj);
+}
 export class ExecutionRecorder {
     #events = [];
     recordingId;
@@ -107,7 +130,7 @@ export class ExecutionRecorder {
     off = undefined;
     once = undefined;
     recordSocket(channel) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve) => {
             this.recordingId = nanoid();
             const listener = (event) => {
                 const { message, data } = JSON.parse(event.data);
@@ -119,6 +142,7 @@ export class ExecutionRecorder {
                 }
                 this.#events.push(toRecordedEvent(message, data));
                 if (message === 'done' || message === 'abort' || message === 'error') {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit('finish', {
                         recording: this.getRecording(),
                     });
@@ -140,6 +164,7 @@ export class ExecutionRecorder {
             }
             this.#events.push(toRecordedEvent(event, data));
             if (event === 'done' || event === 'abort' || event === 'error') {
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 this.#emitter.emit('finish', {
                     recording: this.getRecording(),
                 });
@@ -163,15 +188,45 @@ export class ExecutionRecorder {
         if (serializedRecording.version !== 1) {
             throw new Error('Unsupported serialized events version');
         }
-        recorder.recordingId = serializedRecording.recording.recordingId;
-        recorder.#events = serializedRecording.recording.events;
+        const recording = mapValuesDeep(serializedRecording.recording, (val) => {
+            if (typeof val === 'string' && val.startsWith('$ASSET:')) {
+                const id = val.slice('$ASSET:'.length);
+                const asset = serializedRecording.assets?.[id];
+                if (asset) {
+                    return new Uint8Array(base64ToUint8Array(asset));
+                }
+                else {
+                    return val;
+                }
+            }
+            return val;
+        });
+        recorder.recordingId = recording.recordingId;
+        recorder.#events = recording.events;
         return recorder;
     }
     serialize() {
         const serialized = {
             version: 1,
             recording: this.getRecording(),
+            assets: {},
         };
+        serialized.recording = mapValuesDeep(serialized.recording, (val) => {
+            if (val instanceof Uint8Array) {
+                const asString = uint8ArrayToBase64Sync(val);
+                const existingAsset = Object.entries(serialized.assets).find(([, asset]) => asset === asString);
+                if (!existingAsset) {
+                    const id = nanoid();
+                    serialized.assets[id] = asString;
+                    return `$ASSET:${id}`;
+                }
+                else {
+                    const [id] = existingAsset;
+                    return `$ASSET:${id}`;
+                }
+            }
+            return val;
+        });
         return JSON.stringify(serialized);
     }
 }

package/dist/esm/utils/base64.js

@@ -14,6 +14,19 @@ export async function uint8ArrayToBase64(uint8Array) {
         return dataUrl.split(',')[1];
     }
 }
+export function uint8ArrayToBase64Sync(uint8Array) {
+    if (typeof window === 'undefined') {
+        // Node executor
+        return Buffer.from(uint8Array).toString('base64');
+    }
+    else {
+        // Browser executor
+        const binary = Array.from(uint8Array)
+            .map((byte) => String.fromCharCode(byte))
+            .join('');
+        return btoa(binary);
+    }
+}
 export function base64ToUint8Array(base64) {
     const binaryString = atob(base64);
     const len = binaryString.length;

package/dist/esm/utils/chatMessageToOpenAIChatCompletionMessage.js

@@ -1,6 +1,6 @@
 import { match } from 'ts-pattern';
 import { uint8ArrayToBase64 } from './index.js';
-export async function chatMessageToOpenAIChatCompletionMessage(message) {
+export async function chatMessageToOpenAIChatCompletionMessage(message, options) {
     const onlyStringContent = (message) => {
         const parts = Array.isArray(message.message) ? message.message : [message.message];
         const stringContent = parts
@@ -14,7 +14,20 @@ export async function chatMessageToOpenAIChatCompletionMessage(message) {
         return stringContent;
     };
     return match(message)
-        .with({ type: 'system' }, (m) => ({ role: m.type, content: onlyStringContent(m) }))
+        .with({ type: 'system' }, (m) => {
+        if (options.isReasoningModel) {
+            return {
+                role: 'developer',
+                content: onlyStringContent(m),
+            };
+        }
+        else {
+            return {
+                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') {

package/dist/esm/utils/coerceType.js

@@ -268,7 +268,10 @@ function coerceToBinary(value) {
     if (value.type === 'number') {
         return new Uint8Array([value.value]);
     }
-    if (value.type === 'audio' || value.type === 'image') {
+    if (value.type === 'chat-message') {
+        return new TextEncoder().encode(coerceToString(value));
+    }
+    if (value.type === 'audio' || value.type === 'image' || value.type === 'document') {
         return value.value.data;
     }
     return new TextEncoder().encode(JSON.stringify(value.value));

package/dist/esm/utils/fetchEventSource.js

@@ -47,7 +47,7 @@ export class EventSourceResponse extends Response {
     }
     async raceWithTimeout(promise, timeout) {
         const raceTimeout = timeout ?? DEFAULT_CHAT_NODE_TIMEOUT;
-        // eslint-disable-next-line no-async-promise-executor -- Error handled correctly
+        // eslint-disable-next-line no-async-promise-executor,@typescript-eslint/no-misused-promises -- Error handled correctly
         return new Promise(async (resolve, reject) => {
             const timer = setTimeout(() => {
                 reject(new Error('Timeout: API response took too long.'));

package/dist/esm/utils/interpolation.js

@@ -1,6 +1,111 @@
+import { dedent } from './misc.js';
+export const TOKEN_MATCH_REGEX = /\{\{(?!\{)([^{}\s][^{}]*[^{}\s]|[^{}\s])\}\}(?!\})/g;
+export const ESCAPED_TOKEN_REGEX = /\{{3}([^{}]+)\}{3}/g;
+const processingFunctions = {
+    indent: (input, spaces = 0) => {
+        const indent = ' '.repeat(spaces);
+        return input
+            .split('\n')
+            .map((line) => `${indent}${line}`)
+            .join('\n');
+    },
+    quote: (input, level = 1) => {
+        const quotePrefix = '> '.repeat(level);
+        return input
+            .split('\n')
+            .map((line) => `${quotePrefix}${line}`)
+            .join('\n');
+    },
+    uppercase: (input) => {
+        return input.toUpperCase();
+    },
+    lowercase: (input) => {
+        return input.toLowerCase();
+    },
+    trim: (input) => {
+        return input.trim();
+    },
+    truncate: (input, length = 50) => {
+        if (input.length <= length)
+            return input;
+        return input.slice(0, length) + '...';
+    },
+    list: (input, level = 1) => {
+        const indent = '  '.repeat(level - 1);
+        return input
+            .split('\n')
+            .map((line) => `${indent}- ${line}`)
+            .join('\n');
+    },
+    sort: (input) => {
+        return input.split('\n').sort().join('\n');
+    },
+    dedent: (input) => {
+        return dedent(input);
+    },
+    wrap: (input, width = 80) => {
+        const words = input.split(/\s+/);
+        const lines = [];
+        let currentLine = '';
+        for (const word of words) {
+            if (currentLine.length + word.length + 1 <= width) {
+                currentLine += (currentLine ? ' ' : '') + word;
+            }
+            else {
+                lines.push(currentLine);
+                currentLine = word;
+            }
+        }
+        if (currentLine) {
+            lines.push(currentLine);
+        }
+        return lines.join('\n');
+    },
+};
+// Parse processing instructions like "indent 2" or "quote" into function name and parameter
+function parseProcessing(instruction) {
+    const parts = instruction.trim().split(/\s+/);
+    return {
+        func: parts[0],
+        param: parts[1] ? parseInt(parts[1], 10) : undefined,
+    };
+}
+// Apply a chain of processing functions to a string
+function applyProcessing(value, processingChain) {
+    const instructions = processingChain.split('|').slice(1); // Remove the token part
+    return instructions.reduce((result, instruction) => {
+        const { func, param } = parseProcessing(instruction);
+        const processingFunc = processingFunctions[func];
+        if (!processingFunc) {
+            console.warn(`Unknown processing function: ${func}`);
+            return result;
+        }
+        return processingFunc(result, param);
+    }, value);
+}
 export function interpolate(baseString, values) {
-    return baseString.replace(/\{\{([^}]+)\}\}/g, (_m, p1) => {
-        const value = values[p1];
-        return value !== undefined ? value : '';
+    return baseString
+        .replace(TOKEN_MATCH_REGEX, (_m, p1) => {
+        const [token, ...processing] = p1.split('|');
+        const value = values[token.trim()];
+        if (value === undefined)
+            return '';
+        if (processing.length > 0) {
+            return applyProcessing(value, p1);
+        }
+        return value;
+    })
+        .replace(ESCAPED_TOKEN_REGEX, (_m, p1) => {
+        return `{{${p1}}}`;
     });
 }
+// Extract all unique variable names from a template string
+export function extractInterpolationVariables(template) {
+    const matches = template.matchAll(TOKEN_MATCH_REGEX);
+    const variables = new Set();
+    for (const match of matches) {
+        const [token] = match[1].split('|');
+        variables.add(token.trim());
+    }
+    return Array.from(variables);
+}

package/dist/esm/utils/openai.js

@@ -1,6 +1,9 @@
 import { orderBy } from 'lodash-es';
 import { DEFAULT_CHAT_NODE_TIMEOUT } from './defaults.js';
 import fetchEventSource from './fetchEventSource.js';
+export const defaultOpenaiSupported = {
+    parallelFunctionCalls: true,
+};
 export const openaiModels = {
     'gpt-4': {
         maxTokens: 8192,
@@ -34,54 +37,6 @@ export const openaiModels = {
         },
         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: {
@@ -146,6 +101,93 @@ export const openaiModels = {
         },
         displayName: 'GPT-4o mini (2024-07-18)',
     },
+    o1: {
+        maxTokens: 128000,
+        cost: {
+            prompt: 0.015,
+            completion: 0.6,
+        },
+        displayName: 'o1',
+        supported: {
+            parallelFunctionCalls: false,
+        },
+    },
+    'o1-preview': {
+        maxTokens: 128000,
+        cost: {
+            prompt: 0.015,
+            completion: 0.06,
+        },
+        displayName: 'o1-preview',
+        supported: {
+            parallelFunctionCalls: false,
+        },
+    },
+    'o1-preview-2024-09-12': {
+        maxTokens: 128000,
+        cost: {
+            prompt: 0.015,
+            completion: 0.06,
+        },
+        displayName: 'o1-preview (2024-09-12)',
+        supported: {
+            parallelFunctionCalls: false,
+        },
+    },
+    'o1-mini': {
+        maxTokens: 128000,
+        cost: {
+            prompt: 0.0011,
+            completion: 0.0044,
+        },
+        displayName: 'o1-mini',
+        supported: {
+            parallelFunctionCalls: false,
+        },
+    },
+    'o1-mini-2024-09-12': {
+        maxTokens: 128000,
+        cost: {
+            prompt: 0.0011,
+            completion: 0.0044,
+        },
+        displayName: 'o1-mini (2024-09-12)',
+        supported: {
+            parallelFunctionCalls: false,
+        },
+    },
+    'o3-mini': {
+        maxTokens: 200000,
+        cost: {
+            prompt: 0.0011,
+            completion: 0.0044,
+        },
+        displayName: 'o3-mini',
+        supported: {
+            parallelFunctionCalls: false,
+        },
+    },
+    'o3-mini-2025-01-31': {
+        maxTokens: 200000,
+        cost: {
+            prompt: 0.0011,
+            completion: 0.0044,
+        },
+        displayName: 'o3-mini (2025-01-31)',
+        supported: {
+            parallelFunctionCalls: false,
+        },
+    },
+    'gpt-4o-audio-preview': {
+        maxTokens: 128000,
+        cost: {
+            prompt: 0.0025,
+            completion: 0.01,
+            audioPrompt: 0.04,
+            audioCompletion: 0.08,
+        },
+        displayName: 'GPT-4o Audio (Preview)',
+    },
     'local-model': {
         maxTokens: Number.MAX_SAFE_INTEGER,
         cost: {
@@ -169,7 +211,21 @@ export class OpenAIError extends Error {
         this.name = 'OpenAIError';
     }
 }
-;
+export async function chatCompletions({ endpoint, auth, signal, headers, timeout, ...rest }) {
+    const abortSignal = signal ?? new AbortController().signal;
+    const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${auth.apiKey}`,
+            ...(auth.organization ? { 'OpenAI-Organization': auth.organization } : {}),
+            ...headers,
+        },
+        body: JSON.stringify(rest),
+        signal: abortSignal,
+    });
+    return response.json();
+}
 export async function* streamChatCompletions({ endpoint, auth, signal, headers, timeout, ...rest }) {
     const abortSignal = signal ?? new AbortController().signal;
     const response = await fetchEventSource(endpoint, {
@@ -184,7 +240,7 @@ export async function* streamChatCompletions({ endpoint, auth, signal, headers,
             ...rest,
             stream: true,
             stream_options: {
-                "include_usage": true
+                include_usage: true,
             },
         }),
         signal: abortSignal,

package/dist/esm/utils/paths.js

@@ -0,0 +1,80 @@
+export function createTreeFromPaths(paths, rootPath) {
+    // Helper to get all parent paths of a given path
+    const getParentPaths = (path) => {
+        const parts = path.split('/').filter((p) => p);
+        return parts.slice(0, -1).map((_, index) => parts.slice(0, index + 1).join('/'));
+    };
+    // First, create a unique set of all directories
+    const directories = new Set();
+    paths.forEach((path) => {
+        // Add all parent directories of this path
+        const cleanPath = path.replace(/^\/+|\/+$/g, '');
+        getParentPaths(cleanPath).forEach((dir) => directories.add(dir));
+        // If the path itself ends with /, it's a directory
+        if (path.endsWith('/')) {
+            directories.add(cleanPath);
+        }
+    });
+    // Create the root node
+    const root = {
+        path: rootPath,
+        name: rootPath || 'root',
+        isDirectory: true,
+        children: [],
+    };
+    // Create a map for quick node lookups - use full paths as keys
+    const nodeMap = new Map();
+    nodeMap.set(rootPath, root);
+    // Helper to get or create a node for a path
+    const getOrCreateNode = (fullPath) => {
+        const cleanPath = fullPath.replace(/^\/+|\/+$/g, '');
+        if (nodeMap.has(cleanPath)) {
+            return nodeMap.get(cleanPath);
+        }
+        const parts = cleanPath.split('/').filter((p) => p);
+        const name = parts[parts.length - 1] || cleanPath;
+        const node = {
+            path: name, // Just use the name as the path
+            name,
+            isDirectory: directories.has(cleanPath),
+            children: [],
+        };
+        nodeMap.set(cleanPath, node); // Still use full path for lookup
+        // Important: Create parent-child relationship immediately
+        if (parts.length > 1) {
+            const parentPath = parts.slice(0, -1).join('/');
+            const parent = getOrCreateNode(parentPath);
+            if (!parent.children.some((child) => child.name === name)) {
+                parent.children.push(node);
+            }
+        }
+        else if (cleanPath && rootPath !== cleanPath) {
+            // Top-level node
+            if (!root.children.some((child) => child.name === name)) {
+                root.children.push(node);
+            }
+        }
+        return node;
+    };
+    // Process all paths to build the tree
+    paths
+        .filter((path) => path.trim())
+        .forEach((path) => {
+        const cleanPath = path.replace(/^\/+|\/+$/g, '');
+        if (cleanPath) {
+            getOrCreateNode(cleanPath);
+        }
+    });
+    // Sort children of all nodes
+    const sortNode = (node) => {
+        node.children.sort((a, b) => {
+            if (a.isDirectory !== b.isDirectory) {
+                return a.isDirectory ? -1 : 1;
+            }
+            return a.name.localeCompare(b.name);
+        });
+        node.children.forEach(sortNode);
+    };
+    sortNode(root);
+    return root;
+}

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

@@ -3,6 +3,7 @@ import stableStringify from 'safe-stable-stringify';
 import * as yaml from 'yaml';
 import { doubleCheckProject } from './serializationUtils.js';
 import { entries } from '../typeSafety.js';
+import {} from '../../model/Project.js';
 export function projectV4Deserializer(data) {
     if (typeof data !== 'string') {
         throw new Error('Project v4 deserializer requires a string');
@@ -60,6 +61,7 @@ function toSerializedProject(project, attachedData) {
         graphs: mapValues(project.graphs, (graph) => toSerializedGraph(graph)),
         attachedData,
         plugins: project.plugins ?? [],
+        references: project.references ?? [],
     };
 }
 function fromSerializedProject(serializedProject) {
@@ -68,6 +70,7 @@ function fromSerializedProject(serializedProject) {
             metadata: serializedProject.metadata,
             graphs: mapValues(serializedProject.graphs, (graph) => fromSerializedGraph(graph)),
             plugins: serializedProject.plugins ?? [],
+            references: serializedProject.references ?? [],
         },
         serializedProject.attachedData ?? {},
     ];
@@ -136,6 +139,7 @@ function toSerializedNode(node, allNodes, allConnections) {
         outgoingConnections: outgoingConnections.length > 0 ? outgoingConnections : undefined,
         variants: (node.variants?.length ?? 0) > 0 ? node.variants : undefined,
         disabled: node.disabled ? true : undefined,
+        isConditional: node.isConditional,
     };
 }
 function fromSerializedNode(serializedNode, serializedNodeInfo) {
@@ -162,6 +166,7 @@ function fromSerializedNode(serializedNode, serializedNodeInfo) {
             data: serializedNode.data ?? {},
             variants: serializedNode.variants ?? [],
             disabled: serializedNode.disabled,
+            isConditional: serializedNode.isConditional,
         },
         connections,
     ];

package/dist/types/api/createProcessor.d.ts

@@ -1,7 +1,10 @@
 import type { PascalCase } from 'type-fest';
 import { type AttachedData, type AudioProvider, type DataValue, type DatasetProvider, type ExternalFunction, type NativeApi, type NodeRegistration, type ProcessContext, type ProcessEvents, type Project, type RivetEventStreamFilterSpec, type Settings } from '../index.js';
 import { GraphProcessor } from '../model/GraphProcessor.js';
-export type LooseDataValue = DataValue | string | number | boolean;
+import type { Tokenizer } from '../integrations/Tokenizer.js';
+import { type LooseDataValue } from './looseDataValue.js';
+import type { CodeRunner } from '../integrations/CodeRunner.js';
+import type { ProjectReferenceLoader } from '../model/ProjectReferenceLoader.js';
 export type RunGraphOptions = {
     graph?: string;
     inputs?: Record<string, LooseDataValue>;
@@ -17,18 +20,21 @@ export type RunGraphOptions = {
     };
     abortSignal?: AbortSignal;
     registry?: NodeRegistration;
+    includeTrace?: boolean;
     getChatNodeEndpoint?: ProcessContext['getChatNodeEndpoint'];
+    tokenizer?: Tokenizer;
+    codeRunner?: CodeRunner;
+    projectPath?: string;
+    projectReferenceLoader?: ProjectReferenceLoader;
 } & {
     [P in keyof ProcessEvents as `on${PascalCase<P>}`]?: (params: ProcessEvents[P]) => void;
 } & Settings;
-export declare function looseDataValuesToDataValues(values: Record<string, LooseDataValue>): Record<string, DataValue>;
-export declare function looseDataValueToDataValue(value: LooseDataValue): DataValue;
 export declare function coreCreateProcessor(project: Project, options: RunGraphOptions): {
     processor: GraphProcessor;
     inputs: Record<string, DataValue>;
     contextValues: Record<string, DataValue>;
-    getEvents: (spec: RivetEventStreamFilterSpec) => AsyncGenerator<import("./streaming.js").RivetEventStreamEventInfo, void, unknown>;
-    getSSEStream: (spec: RivetEventStreamFilterSpec) => ReadableStream<Uint8Array>;
+    getEvents: (spec: RivetEventStreamFilterSpec) => AsyncGenerator<import("./streaming.js").RivetEventStreamEventInfo, void, any>;
+    getSSEStream: (spec: RivetEventStreamFilterSpec) => ReadableStream<Uint8Array<ArrayBufferLike>>;
     streamNode: (nodeIdOrTitle: string) => ReadableStream<string>;
     run(): Promise<import("../index.js").GraphOutputs>;
 };

package/dist/types/api/looseDataValue.d.ts

@@ -0,0 +1,4 @@
+import type { DataValue } from '../model/DataValue.js';
+export type LooseDataValue = DataValue | string | number | boolean;
+export declare function looseDataValuesToDataValues(values: Record<string, LooseDataValue>): Record<string, DataValue>;
+export declare function looseDataValueToDataValue(value: LooseDataValue): DataValue;

package/dist/types/api/streaming.d.ts

@@ -52,5 +52,5 @@ export declare function getProcessorEvents(processor: GraphProcessor, spec: Rive
  */
 export declare function getProcessorSSEStream(processor: GraphProcessor, 
 /** The spec for what you're streaming to the client */
-spec: RivetEventStreamFilterSpec): ReadableStream<Uint8Array>;
+spec: RivetEventStreamFilterSpec): ReadableStream<Uint8Array<ArrayBufferLike>>;
 export declare function getSingleNodeStream(processor: GraphProcessor, nodeIdOrTitle: string): ReadableStream<string>;

package/dist/types/exports.d.ts

@@ -29,5 +29,7 @@ export * from './model/Dataset.js';
 export * from './api/streaming.js';
 export * from './api/createProcessor.js';
 export * from './integrations/AudioProvider.js';
+export * from './api/looseDataValue.js';
+export * from './integrations/CodeRunner.js';
 import * as openai from './utils/openai.js';
 export { openai };