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

package/dist/esm/model/NodeBase.js

@@ -1 +1,11 @@
-export {};
+export const IF_PORT = {
+    id: `$if`,
+    title: 'if',
+    dataType: 'boolean',
+    coerced: true,
+    description: 'Only run the node if this condition is true',
+    defaultValue: 'false',
+};
+export function isBuiltInInputDefinition(input) {
+    return input.id === IF_PORT.id;
+}

package/dist/esm/model/NodeImpl.js

@@ -1,3 +1,4 @@
+import { IF_PORT, } from './NodeBase.js';
 export class NodeImpl {
     chartNode;
     constructor(chartNode) {
@@ -18,6 +19,13 @@ export class NodeImpl {
     get data() {
         return this.chartNode.data;
     }
+    getInputDefinitionsIncludingBuiltIn(connections, nodes, project, referencedProjects) {
+        const ports = [...this.getInputDefinitions(connections, nodes, project, referencedProjects)];
+        if (this.chartNode.isConditional) {
+            ports.push(IF_PORT);
+        }
+        return ports;
+    }
     getEditors(_context) {
         return [];
     }

package/dist/esm/model/Nodes.js

@@ -5,6 +5,7 @@ import { textNode } from './nodes/TextNode.js';
 export * from './nodes/TextNode.js';
 import { chatNode } from './nodes/ChatNode.js';
 export * from './nodes/ChatNode.js';
+export * from './nodes/ChatNodeBase.js';
 import { promptNode } from './nodes/PromptNode.js';
 export * from './nodes/PromptNode.js';
 import { extractRegexNode } from './nodes/ExtractRegexNode.js';
@@ -61,8 +62,8 @@ import { getGlobalNode } from './nodes/GetGlobalNode.js';
 export * from './nodes/GetGlobalNode.js';
 import { waitForEventNode } from './nodes/WaitForEventNode.js';
 export * from './nodes/WaitForEventNode.js';
-import { gptFunctionNode } from './nodes/GptFunctionNode.js';
-export * from './nodes/GptFunctionNode.js';
+import { gptFunctionNode } from './nodes/ToolNode.js';
+export * from './nodes/ToolNode.js';
 import { toYamlNode } from './nodes/ToYamlNode.js';
 export * from './nodes/ToYamlNode.js';
 import { getEmbeddingNode } from './nodes/GetEmbeddingNode.js';
@@ -145,7 +146,22 @@ import { delegateFunctionCallNode } from './nodes/DelegateFunctionCallNode.js';
 export * from './nodes/DelegateFunctionCallNode.js';
 import { playAudioNode } from './nodes/PlayAudioNode.js';
 export * from './nodes/PlayAudioNode.js';
-export * from './nodes/CallGraphNode.js';
+import { documentNode } from './nodes/DocumentNode.js';
+export * from './nodes/DocumentNode.js';
+import { chatLoopNode } from './nodes/ChatLoopNode.js';
+export * from './nodes/ChatLoopNode.js';
+import { readAllFilesNode } from './nodes/ReadAllFilesNode.js';
+export * from './nodes/ReadAllFilesNode.js';
+import { toMarkdownTableNode } from './nodes/ToMarkdownTableNode.js';
+export * from './nodes/ToMarkdownTableNode.js';
+import { cronNode } from './nodes/CronNode.js';
+export * from './nodes/CronNode.js';
+import { toTreeNode } from './nodes/ToTreeNode.js';
+export * from './nodes/ToTreeNode.js';
+import { loopUntilNode } from './nodes/LoopUntilNode.js';
+export * from './nodes/LoopUntilNode.js';
+import { referencedGraphAliasNode } from './nodes/ReferencedGraphAliasNode.js';
+export * from './nodes/ReferencedGraphAliasNode.js';
 export const registerBuiltInNodes = (registry) => {
     return registry
         .register(toYamlNode)
@@ -220,7 +236,15 @@ export const registerBuiltInNodes = (registry) => {
         .register(graphReferenceNode)
         .register(callGraphNode)
         .register(delegateFunctionCallNode)
-        .register(playAudioNode);
+        .register(playAudioNode)
+        .register(documentNode)
+        .register(chatLoopNode)
+        .register(readAllFilesNode)
+        .register(toMarkdownTableNode)
+        .register(cronNode)
+        .register(toTreeNode)
+        .register(loopUntilNode)
+        .register(referencedGraphAliasNode);
 };
 let globalRivetNodeRegistry = registerBuiltInNodes(new NodeRegistration());
 export { globalRivetNodeRegistry };

package/dist/esm/model/ProjectReferenceLoader.js

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

package/dist/esm/model/nodes/AssembleMessageNode.js

@@ -54,7 +54,7 @@ export class AssembleMessageNodeImpl extends NodeImpl {
         }
         for (let i = 1; i <= messageCount; i++) {
             inputs.push({
-                dataType: ['string', 'image', 'string[]', 'image[]', 'object', 'object[]'],
+                dataType: ['string', 'image', 'string[]', 'image[]', 'object', 'object[]', 'document', 'document[]'],
                 id: `part${i}`,
                 title: `Part ${i}`,
                 description: 'A part of the message to assemble.',
@@ -112,7 +112,7 @@ export class AssembleMessageNodeImpl extends NodeImpl {
         return {
             infoBoxBody: dedent `
         Assembles a single chat message from multiple parts. This is similar to a Prompt node, but works with multimodal
-        models, as you can include both text and images in the message.
+        models, as you can include text, images, and documents in the message.
       `,
             infoBoxTitle: 'Assemble Message Node',
             contextMenuTitle: 'Assemble Message',
@@ -181,6 +181,16 @@ export class AssembleMessageNodeImpl extends NodeImpl {
                         });
                     }
                 }
+                else if (message.type === 'document') {
+                    outMessage.message.push({
+                        type: 'document',
+                        data: message.value.data,
+                        mediaType: message.value.mediaType,
+                        context: message.value.context,
+                        title: message.value.title,
+                        enableCitations: message.value.enableCitations,
+                    });
+                }
                 else {
                     const coerced = coerceTypeOptional(message, 'string');
                     if (coerced) {

package/dist/esm/model/nodes/AssemblePromptNode.js

@@ -7,6 +7,7 @@ import { coerceType } from '../../utils/coerceType.js';
 import { orderBy } from 'lodash-es';
 import { dedent } from 'ts-dedent';
 import { nodeDefinition } from '../NodeDefinition.js';
+import { getInputOrData } from '../../utils/inputs.js';
 export class AssemblePromptNodeImpl extends NodeImpl {
     static create() {
         const chartNode = {
@@ -25,6 +26,14 @@ export class AssemblePromptNodeImpl extends NodeImpl {
     getInputDefinitions(connections) {
         const inputs = [];
         const messageCount = this.#getMessagePortCount(connections);
+        if (this.data.useIsLastMessageCacheBreakpointInput) {
+            inputs.push({
+                dataType: 'boolean',
+                id: 'isLastMessageCacheBreakpoint',
+                title: 'Is Last Message Cache Breakpoint',
+                description: 'Whether the last message in the prompt should be a cache breakpoint.',
+            });
+        }
         for (let i = 1; i <= messageCount; i++) {
             inputs.push({
                 dataType: ['chat-message', 'chat-message[]'],
@@ -87,10 +96,20 @@ export class AssemblePromptNodeImpl extends NodeImpl {
                 label: 'Compute Token Count',
                 dataKey: 'computeTokenCount',
             },
+            {
+                type: 'toggle',
+                label: 'Is Last Message Cache Breakpoint',
+                dataKey: 'isLastMessageCacheBreakpoint',
+                helperMessage: 'For Anthropic, marks the last message as a cache breakpoint - this message and every message before it will be cached using Prompt Caching.',
+            },
         ];
     }
+    getBody(_context) {
+        return this.data.isLastMessageCacheBreakpoint ? 'Last message is cache breakpoint' : '';
+    }
     async process(inputs, context) {
         const output = {};
+        const isLastMessageCacheBreakpoint = getInputOrData(this.data, inputs, 'isLastMessageCacheBreakpoint', 'boolean');
         const outMessages = [];
         const inputMessages = orderBy(Object.entries(inputs).filter(([key]) => key.startsWith('message')), ([key]) => key, 'asc');
         for (const [, inputMessage] of inputMessages) {
@@ -110,6 +129,9 @@ export class AssemblePromptNodeImpl extends NodeImpl {
                 }
             }
         }
+        if (isLastMessageCacheBreakpoint && outMessages.length > 1) {
+            outMessages.at(-1).isCacheBreakpoint = true;
+        }
         output['prompt'] = {
             type: 'chat-message[]',
             value: outMessages,

package/dist/esm/model/nodes/CallGraphNode.js

@@ -2,12 +2,11 @@ import {} from '../NodeBase.js';
 import { NodeImpl } from '../NodeImpl.js';
 import { nodeDefinition } from '../NodeDefinition.js';
 import {} from '../GraphProcessor.js';
-import {} from '../NodeGraph.js';
 import { nanoid } from 'nanoid/non-secure';
 import {} from '../ProcessContext.js';
 import { dedent } from 'ts-dedent';
-import { coerceType, coerceTypeOptional } from '../../utils/coerceType.js';
-import { looseDataValuesToDataValues } from '../../index.js';
+import { coerceTypeOptional } from '../../utils/coerceType.js';
+import { looseDataValuesToDataValues } from '../../api/looseDataValue.js';
 import { getError } from '../../utils/errors.js';
 export class CallGraphNodeImpl extends NodeImpl {
     static create() {
@@ -93,7 +92,7 @@ export class CallGraphNodeImpl extends NodeImpl {
             };
         }
         const subGraphProcessor = context.createSubProcessor(graphRef.graphId, { signal: context.signal });
-        let outputs = {};
+        const outputs = {};
         try {
             const startTime = Date.now();
             const inputData = looseDataValuesToDataValues(graphInputs);

package/dist/esm/model/nodes/ChatLoopNode.js

@@ -0,0 +1,150 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import {} from '../ProcessContext.js';
+import {} from '../../index.js';
+import { dedent } from 'ts-dedent';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { ChatNodeBase } from './ChatNodeBase.js';
+import { coerceType } from '../../utils/coerceType.js';
+export class ChatLoopNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'chatLoop',
+            title: 'Chat Loop',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                ...ChatNodeBase.defaultData(),
+                userPrompt: 'Your response:',
+                renderingFormat: 'markdown',
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        return ChatNodeBase.getInputDefinitions(this.data);
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'string[]',
+                id: 'conversation',
+                title: 'Full Conversation',
+            },
+            {
+                dataType: 'string',
+                id: 'lastMessage',
+                title: 'Last Message',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Creates an interactive chat loop with an AI model. The node will:
+        1. Send the initial prompt to the AI
+        2. Show the AI's response and prompt for user input
+        3. Send the user's input back to the AI
+        4. Repeat steps 2-3 until the user ends the conversation
+
+        The conversation history is maintained and sent with each new message.
+      `,
+            contextMenuTitle: 'Chat Loop',
+            infoBoxTitle: 'Chat Loop Node',
+            group: ['Convenience'],
+        };
+    }
+    getEditors() {
+        return [
+            ...ChatNodeBase.getEditors(),
+            {
+                type: 'code',
+                label: 'User Prompt',
+                dataKey: 'userPrompt',
+                language: 'plain-text',
+            },
+            {
+                type: 'group',
+                label: 'Rendering',
+                editors: [
+                    {
+                        type: 'dropdown',
+                        dataKey: 'renderingFormat',
+                        label: 'Format',
+                        options: [
+                            { label: 'Text', value: 'text' },
+                            { label: 'Markdown', value: 'markdown' },
+                        ],
+                        defaultValue: 'markdown',
+                    },
+                ],
+            },
+        ];
+    }
+    getBody() {
+        return ChatNodeBase.getBody(this.data);
+    }
+    async process(inputs, context) {
+        const conversation = [];
+        let continueChat = true;
+        conversation.push(...coerceType(inputs['prompt'], 'chat-message[]'));
+        // Initial chat call
+        const initialResponse = await ChatNodeBase.process(this.data, this.chartNode, inputs, context);
+        const firstMessage = coerceType(initialResponse['response'], 'string');
+        conversation.push({
+            type: 'assistant',
+            message: firstMessage,
+            function_calls: undefined,
+            function_call: undefined,
+        });
+        let messageToUser = firstMessage;
+        while (continueChat) {
+            // Get user input
+            const userResponse = await context.requestUserInput([messageToUser], this.data.renderingFormat ?? 'text');
+            // Check if user wants to end conversation
+            if (!userResponse || userResponse.value.length === 0 || userResponse.value[0]?.length === 0) {
+                continueChat = false;
+                break;
+            }
+            // Add user message to conversation
+            conversation.push({
+                type: 'user',
+                message: userResponse.value[0],
+            });
+            // Prepare next AI message
+            const chatInputs = {
+                ...inputs,
+                prompt: {
+                    type: 'chat-message[]',
+                    value: conversation,
+                },
+            };
+            // Get AI response
+            const aiResponse = await ChatNodeBase.process(this.data, this.chartNode, chatInputs, context);
+            const aiMessage = coerceType(aiResponse['response'], 'string');
+            conversation.push({
+                type: 'assistant',
+                message: aiMessage,
+                function_calls: undefined,
+                function_call: undefined,
+            });
+            messageToUser = aiMessage;
+        }
+        return {
+            ['conversation']: {
+                type: 'chat-message[]',
+                value: conversation,
+            },
+            ['lastMessage']: {
+                type: 'chat-message',
+                value: conversation.at(-1),
+            },
+        };
+    }
+}
+export const chatLoopNode = nodeDefinition(ChatLoopNodeImpl, 'Chat Loop');