@alpic80/rivet-core 1.19.1-aidon.2 → 1.24.0-aidon.1

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 };

package/dist/types/integrations/CodeRunner.d.ts

@@ -0,0 +1,18 @@
+import type { Inputs, Outputs } from '../index.js';
+export interface CodeRunnerOptions {
+    includeRequire: boolean;
+    includeFetch: boolean;
+    includeRivet: boolean;
+    includeProcess: boolean;
+    includeConsole: boolean;
+}
+/** An object that can run arbitrary code (evals it). */
+export interface CodeRunner {
+    runCode: (code: string, inputs: Inputs, options: CodeRunnerOptions) => Promise<Outputs>;
+}
+export declare class IsomorphicCodeRunner implements CodeRunner {
+    runCode(code: string, inputs: Inputs, options: CodeRunnerOptions): Promise<Outputs>;
+}
+export declare class NotAllowedCodeRunner implements CodeRunner {
+    runCode(_code: string, _inputs: Inputs, _options: CodeRunnerOptions): Promise<Outputs>;
+}

package/dist/types/model/DataValue.d.ts

@@ -10,10 +10,14 @@ export type BoolDataValue = DataValueDef<'boolean', boolean>;
 export type SystemChatMessage = {
     type: 'system';
     message: ChatMessageMessagePart | ChatMessageMessagePart[];
+    /** If true, this message marks a breakpoint when used with prompt caching (as of right now, Anthropic-only). */
+    isCacheBreakpoint?: boolean;
 };
 export type UserChatMessage = {
     type: 'user';
     message: ChatMessageMessagePart | ChatMessageMessagePart[];
+    /** If true, this message marks a breakpoint when used with prompt caching (as of right now, Anthropic-only). */
+    isCacheBreakpoint?: boolean;
 };
 export type AssistantChatMessageFunctionCall = {
     id: string | undefined;
@@ -31,22 +35,34 @@ export type AssistantChatMessage = {
     /** @deprecated use function_calls instead */
     function_call: AssistantChatMessageFunctionCall | undefined;
     function_calls: AssistantChatMessageFunctionCall[] | undefined;
+    /** If true, this message marks a breakpoint when used with prompt caching (as of right now, Anthropic-only). */
+    isCacheBreakpoint?: boolean;
 };
 export type FunctionResponseChatMessage = {
     type: 'function';
     message: ChatMessageMessagePart | ChatMessageMessagePart[];
     name: string;
+    /** If true, this message marks a breakpoint when used with prompt caching (as of right now, Anthropic-only). */
+    isCacheBreakpoint?: boolean;
 };
 export type ChatMessage = SystemChatMessage | UserChatMessage | AssistantChatMessage | FunctionResponseChatMessage;
 export type ChatMessageMessagePart = string | {
     type: 'image';
-    mediaType: SupportedMediaTypes;
+    mediaType: SupportedImageMediaTypes;
     data: Uint8Array;
 } | {
     type: 'url';
     url: string;
+} | {
+    type: 'document';
+    title: string | undefined;
+    context: string | undefined;
+    mediaType: SupportedDocumentMediaTypes;
+    data: Uint8Array;
+    enableCitations: boolean;
 };
-export type SupportedMediaTypes = 'image/jpeg' | 'image/png' | 'image/gif';
+export type SupportedImageMediaTypes = 'image/jpeg' | 'image/png' | 'image/gif';
+export type SupportedDocumentMediaTypes = 'application/pdf' | 'text/plain';
 export type ChatMessageDataValue = DataValueDef<'chat-message', ChatMessage>;
 export type DateDataValue = DataValueDef<'date', string>;
 export type TimeDataValue = DataValueDef<'time', string>;
@@ -56,7 +72,7 @@ export type ObjectDataValue = DataValueDef<'object', Record<string, unknown>>;
 export type VectorDataValue = DataValueDef<'vector', number[]>;
 export type BinaryDataValue = DataValueDef<'binary', Uint8Array>;
 export type ImageDataValue = DataValueDef<'image', {
-    mediaType: SupportedMediaTypes;
+    mediaType: SupportedImageMediaTypes;
     data: Uint8Array;
 }>;
 export type AudioDataValue = DataValueDef<'audio', {
@@ -67,6 +83,13 @@ export type GraphReferenceValue = DataValueDef<'graph-reference', {
     graphId: GraphId;
     graphName: string;
 }>;
+export type DocumentDataValue = DataValueDef<'document', {
+    mediaType: SupportedDocumentMediaTypes;
+    data: Uint8Array;
+    title: string | undefined;
+    context: string | undefined;
+    enableCitations: boolean;
+}>;
 /** GPT function definition */
 export type GptFunction = {
     name: string;
@@ -77,7 +100,7 @@ export type GptFunction = {
 };
 export type GptFunctionDataValue = DataValueDef<'gpt-function', GptFunction>;
 export type ControlFlowExcludedDataValue = DataValueDef<'control-flow-excluded', undefined | 'loop-not-broken'>;
-export type ScalarDataValue = StringDataValue | NumberDataValue | DateDataValue | TimeDataValue | DateTimeDataValue | BoolDataValue | ChatMessageDataValue | ControlFlowExcludedDataValue | AnyDataValue | ObjectDataValue | GptFunctionDataValue | VectorDataValue | ImageDataValue | BinaryDataValue | AudioDataValue | GraphReferenceValue;
+export type ScalarDataValue = StringDataValue | NumberDataValue | DateDataValue | TimeDataValue | DateTimeDataValue | BoolDataValue | ChatMessageDataValue | ControlFlowExcludedDataValue | AnyDataValue | ObjectDataValue | GptFunctionDataValue | VectorDataValue | ImageDataValue | BinaryDataValue | AudioDataValue | GraphReferenceValue | DocumentDataValue;
 export type ScalarType = ScalarDataValue['type'];
 export type ArrayDataValue<T extends ScalarDataValue> = DataValueDef<`${T['type']}[]`, T['value'][]>;
 export type FunctionDataValue<T extends ScalarOrArrayDataValue> = DataValueDef<`fn<${T['type']}>`, () => T['value']>;
@@ -106,8 +129,8 @@ export type GetDataValue<Type extends DataType> = Extract<DataValue, {
 export type DataRef = {
     refId: DataId;
 };
-export declare const dataTypes: ["any", "any[]", "boolean", "boolean[]", "string", "string[]", "number", "number[]", "date", "date[]", "time", "time[]", "datetime", "datetime[]", "chat-message", "chat-message[]", "control-flow-excluded", "control-flow-excluded[]", "object", "object[]", "fn<string>", "fn<number>", "fn<boolean>", "fn<date>", "fn<time>", "fn<datetime>", "fn<any>", "fn<object>", "fn<chat-message>", "fn<control-flow-excluded>", "fn<string[]>", "fn<number[]>", "fn<boolean[]>", "fn<date[]>", "fn<time[]>", "fn<datetime[]>", "fn<any[]>", "fn<object[]>", "fn<chat-message[]>", "fn<control-flow-excluded[]>", "gpt-function", "gpt-function[]", "fn<gpt-function[]>", "fn<gpt-function>", "vector", "vector[]", "fn<vector>", "fn<vector[]>", "image", "image[]", "fn<image>", "fn<image[]>", "binary", "binary[]", "fn<binary>", "fn<binary[]>", "audio", "audio[]", "fn<audio>", "fn<audio[]>", "graph-reference", "graph-reference[]", "fn<graph-reference>", "fn<graph-reference[]>"];
-export declare const scalarTypes: ["any", "boolean", "string", "number", "date", "time", "datetime", "chat-message", "control-flow-excluded", "object", "gpt-function", "vector", "image", "binary", "audio", "graph-reference"];
+export declare const dataTypes: ["any", "any[]", "boolean", "boolean[]", "string", "string[]", "number", "number[]", "date", "date[]", "time", "time[]", "datetime", "datetime[]", "chat-message", "chat-message[]", "control-flow-excluded", "control-flow-excluded[]", "object", "object[]", "fn<string>", "fn<number>", "fn<boolean>", "fn<date>", "fn<time>", "fn<datetime>", "fn<any>", "fn<object>", "fn<chat-message>", "fn<control-flow-excluded>", "fn<string[]>", "fn<number[]>", "fn<boolean[]>", "fn<date[]>", "fn<time[]>", "fn<datetime[]>", "fn<any[]>", "fn<object[]>", "fn<chat-message[]>", "fn<control-flow-excluded[]>", "gpt-function", "gpt-function[]", "fn<gpt-function[]>", "fn<gpt-function>", "vector", "vector[]", "fn<vector>", "fn<vector[]>", "image", "image[]", "fn<image>", "fn<image[]>", "binary", "binary[]", "fn<binary>", "fn<binary[]>", "audio", "audio[]", "fn<audio>", "fn<audio[]>", "graph-reference", "graph-reference[]", "fn<graph-reference>", "fn<graph-reference[]>", "document", "document[]", "fn<document>", "fn<document[]>"];
+export declare const scalarTypes: ["any", "boolean", "string", "number", "date", "time", "datetime", "chat-message", "control-flow-excluded", "object", "gpt-function", "vector", "image", "binary", "audio", "graph-reference", "document"];
 export declare const dataTypeDisplayNames: Record<DataType, string>;
 export declare function isScalarDataValue(value: DataValue | undefined): value is ScalarDataValue;
 export declare function isScalarDataType(type: DataType): type is ScalarDataType;

package/dist/types/model/EditorDefinition.d.ts

@@ -94,6 +94,11 @@ export type FileBrowserEditorDefinition<T extends ChartNode> = SharedEditorDefin
     useInputToggleDataKey?: DataOfType<T, boolean>;
     accept?: string;
 };
+export type DirectoryBrowserEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'directoryBrowser';
+    dataKey: DataOfType<T, string>;
+    useInputToggleDataKey?: DataOfType<T, boolean>;
+};
 export type ImageBrowserEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
     type: 'imageBrowser';
     dataKey: DataOfType<T, DataRef>;
@@ -138,5 +143,5 @@ export type DynamicEditorDefinition<T extends ChartNode> = SharedEditorDefinitio
     dataType: DataType;
     editor: DynamicEditorEditor;
 };
-export type EditorDefinition<T extends ChartNode> = StringEditorDefinition<T> | ToggleEditorDefinition<T> | DataTypeSelectorEditorDefinition<T> | AnyDataEditorDefinition<T> | DropdownEditorDefinition<T> | NumberEditorDefinition<T> | CodeEditorDefinition<T> | GraphSelectorEditorDefinition<T> | ColorEditorDefinition<T> | GraphSelectorEditorDefinition<T> | FileBrowserEditorDefinition<T> | ImageBrowserEditorDefinition<T> | DatasetSelectorEditorDefinition<T> | KeyValuePairEditorDefinition<T> | EditorDefinitionGroup<T> | StringListEditorDefinition<T> | CustomEditorDefinition<T> | DynamicEditorDefinition<T> | FilePathBrowserEditorDefinition<T>;
+export type EditorDefinition<T extends ChartNode> = StringEditorDefinition<T> | ToggleEditorDefinition<T> | DataTypeSelectorEditorDefinition<T> | AnyDataEditorDefinition<T> | DropdownEditorDefinition<T> | NumberEditorDefinition<T> | CodeEditorDefinition<T> | GraphSelectorEditorDefinition<T> | ColorEditorDefinition<T> | GraphSelectorEditorDefinition<T> | FileBrowserEditorDefinition<T> | ImageBrowserEditorDefinition<T> | DatasetSelectorEditorDefinition<T> | KeyValuePairEditorDefinition<T> | EditorDefinitionGroup<T> | StringListEditorDefinition<T> | CustomEditorDefinition<T> | DynamicEditorDefinition<T> | FilePathBrowserEditorDefinition<T> | DirectoryBrowserEditorDefinition<T>;
 export {};