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

package/dist/esm/plugins/google/google.js

@@ -1,4 +1,5 @@
-export const googleModels = {
+import {} from '@google/generative-ai';
+export const googleModelsDeprecated = {
     'gemini-pro': {
         maxTokens: 32760,
         cost: {
@@ -16,16 +17,130 @@ export const googleModels = {
         displayName: 'Gemini Pro Vision',
     },
 };
-export const googleModelOptions = Object.entries(googleModels).map(([id, { displayName }]) => ({
+export const generativeAiGoogleModels = {
+    'gemini-2.0-flash-001': {
+        maxTokens: 1048576,
+        cost: {
+            prompt: 0.15 / 1000,
+            completion: 0.6 / 1000,
+        },
+        displayName: 'Gemini 2.0 Flash',
+    },
+    'gemini-2.0-pro-exp-02-05': {
+        maxTokens: 2097152,
+        cost: {
+            prompt: 0, // Unknown
+            completion: 0, // Unknown
+        },
+        displayName: 'Gemini 2.0 Pro',
+    },
+    'gemini-2.5-pro-exp-03-25': {
+        maxTokens: 1000000,
+        cost: {
+            prompt: 0, // Unknown
+            completion: 0, // Unknown
+        },
+        displayName: 'Gemini 2.5 Pro Experimental',
+    },
+    'gemini-2.0-flash-lite-preview-02-05': {
+        maxTokens: 1048576,
+        cost: {
+            prompt: 0.075 / 1000,
+            completion: 0.3 / 1000,
+        },
+        displayName: 'Gemini 2.0 Flash Lite',
+    },
+    'gemini-2.0-flash-thinking-exp-01-21': {
+        maxTokens: 1048576,
+        cost: {
+            prompt: 0, // Unknown
+            completion: 0, // Unknown
+        },
+        displayName: 'Gemini 2.0 Flash Thinking',
+    },
+    'gemini-1.5-flash': {
+        maxTokens: 1048576,
+        cost: {
+            prompt: 0, // It's per-character wtf
+            completion: 0, // It's per-character
+        },
+        displayName: 'Gemini 1.5 Flash',
+    },
+    'gemini-1.5-pro': {
+        maxTokens: 2097152,
+        cost: {
+            prompt: 0, // It's per-character wtf
+            completion: 0, // It's per-character
+        },
+        displayName: 'Gemini 1.5 Pro',
+    },
+    'gemini-1.0-pro': {
+        maxTokens: 32760,
+        cost: {
+            prompt: 0, // It's per-character wtf
+            completion: 0, // 1It's per-character
+        },
+        displayName: 'Gemini 1.0 Pro',
+    },
+    'gemini-1.0-pro-vision': {
+        maxTokens: 16384,
+        cost: {
+            prompt: 0, // It's per-character wtf
+            completion: 0, // It's per-character
+        },
+        displayName: 'Gemini 1.0 Pro Vision',
+    },
+};
+export const googleModelOptionsDeprecated = Object.entries(googleModelsDeprecated).map(([id, { displayName }]) => ({
+    value: id,
+    label: displayName,
+}));
+export const generativeAiOptions = Object.entries(generativeAiGoogleModels).map(([id, { displayName }]) => ({
     value: id,
     label: displayName,
 }));
+export async function* streamGenerativeAi({ apiKey, model, systemPrompt, prompt, maxOutputTokens, temperature, topP, topK, signal, tools, }) {
+    const { GoogleGenerativeAI } = await import('@google/generative-ai');
+    const genAi = new GoogleGenerativeAI(apiKey);
+    const genaiModel = genAi.getGenerativeModel({
+        model,
+        systemInstruction: systemPrompt,
+        generationConfig: {
+            maxOutputTokens,
+            temperature,
+            topP,
+            topK,
+        },
+        tools,
+    });
+    const result = await genaiModel.generateContentStream({
+        contents: prompt,
+    }, { signal });
+    for await (const chunk of result.stream) {
+        const outChunk = {
+            completion: undefined,
+            finish_reason: undefined,
+            function_calls: undefined,
+            model,
+        };
+        const functionCalls = chunk.functionCalls();
+        if (functionCalls) {
+            outChunk.function_calls = functionCalls;
+        }
+        if (chunk.candidates) {
+            outChunk.completion = chunk.candidates[0]?.content?.parts?.[0]?.text;
+            outChunk.finish_reason = chunk.candidates[0]?.finishReason;
+        }
+        if (outChunk.completion || outChunk.function_calls) {
+            yield outChunk;
+        }
+    }
+}
 export async function* streamChatCompletions({ project, location, applicationCredentials, model, signal, max_output_tokens, temperature, top_p, top_k, prompt, }) {
-    const defaultSignal = new AbortController().signal;
     // If you import normally, the Google auth library throws a fit.
     const { VertexAI } = await import('@google-cloud/vertexai');
     // Can't find a way to pass the credentials path in
-    process.env['GOOGLE_APPLICATION_CREDENTIALS'] = applicationCredentials;
+    process.env.GOOGLE_APPLICATION_CREDENTIALS = applicationCredentials;
     const vertexAi = new VertexAI({ project, location });
     const generativeModel = vertexAi.preview.getGenerativeModel({
         model,
@@ -37,11 +152,10 @@ export async function* streamChatCompletions({ project, location, applicationCre
         },
     });
     const response = await generativeModel.generateContentStream({
-        contents: prompt,
+        contents: prompt, // crazy type stuff but... this is good enough, this is legacy
     });
     let hadChunks = false;
     for await (const chunk of response.stream) {
-        console.log('streaming google responses');
         hadChunks = true;
         if (!signal?.aborted && chunk.candidates[0]?.content.parts[0]?.text) {
             yield {

package/dist/esm/plugins/google/nodes/ChatGoogleNode.js

@@ -1,5 +1,5 @@
-import { uint8ArrayToBase64, } from '../../../index.js';
-import { googleModelOptions, googleModels, streamChatCompletions, } from '../google.js';
+import {} from '../../../index.js';
+import { streamChatCompletions, streamGenerativeAi, generativeAiGoogleModels, generativeAiOptions, } from '../google.js';
 import { nanoid } from 'nanoid/non-secure';
 import { dedent } from 'ts-dedent';
 import retry from 'p-retry';
@@ -7,8 +7,12 @@ import { match } from 'ts-pattern';
 import { coerceType, coerceTypeOptional } from '../../../utils/coerceType.js';
 import { addWarning } from '../../../utils/outputs.js';
 import { getError } from '../../../utils/errors.js';
+import { uint8ArrayToBase64 } from '../../../utils/base64.js';
 import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
 import { getScalarTypeOf, isArrayDataValue } from '../../../model/DataValue.js';
+import { getInputOrData } from '../../../utils/inputs.js';
+import { SchemaType, } from '@google/generative-ai';
+import { mapValues } from 'lodash-es';
 // Temporary
 const cache = new Map();
 export const ChatGoogleNodeImpl = {
@@ -23,7 +27,7 @@ export const ChatGoogleNodeImpl = {
                 width: 275,
             },
             data: {
-                model: 'gemini-pro',
+                model: 'gemini-2.0-flash-001',
                 useModelInput: false,
                 temperature: 0.5,
                 useTemperatureInput: false,
@@ -37,12 +41,20 @@ export const ChatGoogleNodeImpl = {
                 useMaxTokensInput: false,
                 cache: false,
                 useAsGraphPartialOutput: true,
+                useToolCalling: false,
             },
         };
         return chartNode;
     },
     getInputDefinitions(data) {
         const inputs = [];
+        inputs.push({
+            id: 'systemPrompt',
+            title: 'System Prompt',
+            dataType: 'string',
+            required: false,
+            description: 'An optional system prompt for the model to use.',
+        });
         if (data.useModelInput) {
             inputs.push({
                 id: 'model',
@@ -79,6 +91,14 @@ export const ChatGoogleNodeImpl = {
                 title: 'Max Tokens',
             });
         }
+        if (data.useToolCalling) {
+            inputs.push({
+                dataType: 'gpt-function[]',
+                id: 'functions',
+                title: 'Tools',
+                description: 'Tools available for the model to call.',
+            });
+        }
         inputs.push({
             dataType: ['chat-message', 'chat-message[]'],
             id: 'prompt',
@@ -105,11 +125,19 @@ export const ChatGoogleNodeImpl = {
             title: 'All Messages',
             description: 'All messages, with the response appended.',
         });
+        if (data.useToolCalling) {
+            outputs.push({
+                dataType: 'object[]',
+                id: 'function-calls',
+                title: 'Tool Calls',
+                description: 'Tool calls made by the model.',
+            });
+        }
         return outputs;
     },
     getBody(data) {
         return dedent `
-      ${googleModels[data.model]?.displayName ?? `Google (${data.model})`}
+      ${generativeAiGoogleModels[data.model]?.displayName ?? `Google (${data.model})`}
       ${data.useTopP
             ? `Top P: ${data.useTopPInput ? '(Using Input)' : data.top_p}`
             : `Temperature: ${data.useTemperatureInput ? '(Using Input)' : data.temperature}`}
@@ -123,7 +151,7 @@ export const ChatGoogleNodeImpl = {
                 label: 'Model',
                 dataKey: 'model',
                 useInputToggleDataKey: 'useModelInput',
-                options: googleModelOptions,
+                options: generativeAiOptions,
             },
             {
                 type: 'number',
@@ -158,6 +186,11 @@ export const ChatGoogleNodeImpl = {
                 max: Number.MAX_SAFE_INTEGER,
                 step: 1,
             },
+            {
+                type: 'toggle',
+                label: 'Enable Tool Calling',
+                dataKey: 'useToolCalling',
+            },
             {
                 type: 'toggle',
                 label: 'Cache (same inputs, same outputs)',
@@ -182,29 +215,23 @@ export const ChatGoogleNodeImpl = {
     },
     async process(data, inputs, context) {
         const output = {};
-        const rawModel = data.useModelInput
-            ? coerceTypeOptional(inputs['model'], 'string') ?? data.model
-            : data.model;
+        const systemPrompt = coerceTypeOptional(inputs['systemPrompt'], 'string');
+        const rawModel = getInputOrData(data, inputs, 'model');
         const model = rawModel;
-        const temperature = data.useTemperatureInput
-            ? coerceTypeOptional(inputs['temperature'], 'number') ?? data.temperature
-            : data.temperature;
-        const topP = data.useTopPInput ? coerceTypeOptional(inputs['top_p'], 'number') ?? data.top_p : data.top_p;
-        const useTopP = data.useUseTopPInput
-            ? coerceTypeOptional(inputs['useTopP'], 'boolean') ?? data.useTopP
-            : data.useTopP;
+        const temperature = getInputOrData(data, inputs, 'temperature', 'number');
+        const topP = getInputOrData(data, inputs, 'top_p', 'number');
+        const useTopP = getInputOrData(data, inputs, 'useTopP', 'boolean');
         const { messages } = getChatGoogleNodeMessages(inputs);
-        const prompt = await Promise.all(messages.map(async (message) => {
-            return {
-                role: message.type === 'user' ? 'user' : 'assistant',
-                parts: await Promise.all([message.message].flat().map(async (part) => {
+        let prompt = await Promise.all(messages.map(async (message) => {
+            if (message.type === 'user' || message.type === 'assistant') {
+                const parts = await Promise.all([message.message].flat().map(async (part) => {
                     if (typeof part === 'string') {
                         return { text: part };
                     }
                     else if (part.type === 'image') {
                         return {
-                            inline_data: {
-                                mime_type: part.mediaType,
+                            inlineData: {
+                                mimeType: part.mediaType,
                                 data: (await uint8ArrayToBase64(part.data)),
                             },
                         };
@@ -212,9 +239,61 @@ export const ChatGoogleNodeImpl = {
                     else {
                         throw new Error(`Google Vertex AI does not support message parts of type ${part.type}`);
                     }
-                })),
-            };
+                }));
+                if (message.type === 'assistant' && (message.function_calls?.length ?? 0) > 0) {
+                    if (parts[0].text === '') {
+                        parts.shift(); // remove empty text part
+                    }
+                    for (const call of message.function_calls ?? []) {
+                        parts.push({
+                            functionCall: {
+                                name: call.name,
+                                args: JSON.parse(call.arguments),
+                            },
+                        });
+                    }
+                }
+                return {
+                    role: match(message.type)
+                        .with('user', () => 'user')
+                        .with('assistant', () => 'model')
+                        .exhaustive(),
+                    parts,
+                };
+            }
+            if (message.type === 'function') {
+                return {
+                    role: 'function',
+                    parts: [
+                        {
+                            functionResponse: {
+                                name: message.name,
+                                response: {
+                                    result: typeof message.message === 'string' ? message.message : '',
+                                },
+                            },
+                        },
+                    ],
+                };
+            }
+            throw new Error(`Google Vertex AI does not support message type ${message.type}`);
         }));
+        // Collapse sequential function responses into a single function response with mutliple parts
+        prompt = prompt.reduce((acc, message) => {
+            const lastMessage = acc.at(-1);
+            // Shouldn't be undefined but not sure if this is where the crash is happening...
+            if (lastMessage &&
+                message.role === 'function' &&
+                lastMessage.role === 'function' &&
+                lastMessage?.parts &&
+                message.parts) {
+                lastMessage.parts.push(...message.parts);
+            }
+            else {
+                acc.push(message);
+            }
+            return acc;
+        }, []);
         let { maxTokens } = data;
         const tokenizerInfo = {
             node: context.node,
@@ -223,25 +302,53 @@ export const ChatGoogleNodeImpl = {
         };
         // TODO Better token counting for Google models.
         const tokenCount = await context.tokenizer.getTokenCountForMessages(messages, undefined, tokenizerInfo);
-        if (googleModels[model] && tokenCount >= googleModels[model].maxTokens) {
-            throw new Error(`The model ${model} can only handle ${googleModels[model].maxTokens} tokens, but ${tokenCount} were provided in the prompts alone.`);
+        if (generativeAiGoogleModels[model] && tokenCount >= generativeAiGoogleModels[model].maxTokens) {
+            throw new Error(`The model ${model} can only handle ${generativeAiGoogleModels[model].maxTokens} tokens, but ${tokenCount} were provided in the prompts alone.`);
         }
-        if (googleModels[model] && tokenCount + maxTokens > googleModels[model].maxTokens) {
-            const message = `The model can only handle a maximum of ${googleModels[model].maxTokens} tokens, but the prompts and max tokens together exceed this limit. The max tokens has been reduced to ${googleModels[model].maxTokens - tokenCount}.`;
+        if (generativeAiGoogleModels[model] && tokenCount + maxTokens > generativeAiGoogleModels[model].maxTokens) {
+            const message = `The model can only handle a maximum of ${generativeAiGoogleModels[model].maxTokens} tokens, but the prompts and max tokens together exceed this limit. The max tokens has been reduced to ${generativeAiGoogleModels[model].maxTokens - tokenCount}.`;
             addWarning(output, message);
-            maxTokens = Math.floor((googleModels[model].maxTokens - tokenCount) * 0.95); // reduce max tokens by 5% to be safe, calculation is a little wrong.
+            maxTokens = Math.floor((generativeAiGoogleModels[model].maxTokens - tokenCount) * 0.95); // reduce max tokens by 5% to be safe, calculation is a little wrong.
         }
         const project = context.getPluginConfig('googleProjectId');
         const location = context.getPluginConfig('googleRegion');
         const applicationCredentials = context.getPluginConfig('googleApplicationCredentials');
-        if (project == null) {
-            throw new Error('Google Project ID is not defined.');
-        }
-        if (location == null) {
-            throw new Error('Google Region is not defined.');
+        const apiKey = context.getPluginConfig('googleApiKey');
+        let tools = [];
+        if (data.useToolCalling) {
+            const gptTools = coerceTypeOptional(inputs['functions'], 'gpt-function[]') ?? [];
+            if (gptTools) {
+                tools = [
+                    {
+                        functionDeclarations: gptTools.map((tool) => ({
+                            name: tool.name,
+                            description: tool.description,
+                            parameters: Object.keys(tool.parameters.properties).length === 0
+                                ? undefined
+                                : {
+                                    type: SchemaType.OBJECT,
+                                    properties: mapValues(tool.parameters.properties, (p) => ({
+                                        // gemini doesn't support union property types, it uses openapi style not jsonschema, what a mess
+                                        type: Array.isArray(p.type) ? p.type.filter((t) => t !== 'null')[0] : p.type,
+                                        description: p.description,
+                                    })),
+                                    required: tool.parameters.required || [],
+                                },
+                        })),
+                    },
+                ];
+            }
         }
-        if (applicationCredentials == null) {
-            throw new Error('Google Application Credentials is not defined.');
+        if (!apiKey) {
+            if (project == null) {
+                throw new Error('Google Project ID or Google API Key is not defined.');
+            }
+            if (location == null) {
+                throw new Error('Google Region or Google API Key is not defined.');
+            }
+            if (applicationCredentials == null) {
+                throw new Error('Google Application Credentials or Google API Key is not defined.');
+            }
         }
         try {
             return await retry(async () => {
@@ -249,8 +356,11 @@ export const ChatGoogleNodeImpl = {
                     prompt,
                     model,
                     temperature: useTopP ? undefined : temperature,
-                    top_p: useTopP ? topP : undefined,
-                    max_output_tokens: maxTokens,
+                    topP: useTopP ? topP : undefined,
+                    maxOutputTokens: maxTokens,
+                    systemPrompt,
+                    topK: undefined,
+                    tools,
                 };
                 const cacheKey = JSON.stringify(options);
                 if (data.cache) {
@@ -260,24 +370,59 @@ export const ChatGoogleNodeImpl = {
                     }
                 }
                 const startTime = Date.now();
-                const chunks = streamChatCompletions({
-                    signal: context.signal,
-                    project,
-                    location,
-                    applicationCredentials,
-                    ...options,
-                });
+                let chunks;
+                if (data.useToolCalling && !apiKey) {
+                    throw new Error('Tool calling is only supported when using a generative API key.');
+                }
+                if (apiKey) {
+                    chunks = streamGenerativeAi({
+                        signal: context.signal,
+                        model,
+                        prompt,
+                        maxOutputTokens: maxTokens,
+                        temperature: useTopP ? undefined : temperature,
+                        topP: useTopP ? topP : undefined,
+                        topK: undefined,
+                        apiKey,
+                        systemPrompt,
+                        tools,
+                    });
+                }
+                else {
+                    chunks = streamChatCompletions({
+                        signal: context.signal,
+                        model: model,
+                        prompt,
+                        max_output_tokens: maxTokens,
+                        temperature: useTopP ? undefined : temperature,
+                        top_p: useTopP ? topP : undefined,
+                        top_k: undefined,
+                        project: project,
+                        location: location,
+                        applicationCredentials: applicationCredentials,
+                    });
+                }
                 const responseParts = [];
+                const functionCalls = [];
                 for await (const chunk of chunks) {
-                    if (!chunk.completion) {
-                        // Could be error for some reason 🤷‍♂️ but ignoring has worked for me so far.
-                        continue;
+                    if (chunk.completion) {
+                        responseParts.push(chunk.completion);
+                        output['response'] = {
+                            type: 'string',
+                            value: responseParts.join('').trim(),
+                        };
+                    }
+                    if (chunk.function_calls) {
+                        functionCalls.push(...chunk.function_calls);
+                        output['function-calls'] = {
+                            type: 'object[]',
+                            value: functionCalls.map((fc) => ({
+                                id: fc.name,
+                                name: fc.name,
+                                arguments: fc.args,
+                            })),
+                        };
                     }
-                    responseParts.push(chunk.completion);
-                    output['response'] = {
-                        type: 'string',
-                        value: responseParts.join('').trim(),
-                    };
                     context.onPartialOutputs?.(output);
                 }
                 const endTime = Date.now();
@@ -289,7 +434,13 @@ export const ChatGoogleNodeImpl = {
                             type: 'assistant',
                             message: responseParts.join('').trim() ?? '',
                             function_call: undefined,
-                            function_calls: undefined,
+                            function_calls: functionCalls.length === 0
+                                ? undefined
+                                : functionCalls.map((fc) => ({
+                                    id: fc.name,
+                                    name: fc.name,
+                                    arguments: JSON.stringify(fc.args),
+                                })),
                         },
                     ],
                 };
@@ -297,7 +448,7 @@ export const ChatGoogleNodeImpl = {
                     type: 'chat-message[]',
                     value: messages,
                 };
-                if (responseParts.length === 0) {
+                if (responseParts.length === 0 && functionCalls.length === 0) {
                     throw new Error('No response from Google');
                 }
                 output['requestTokens'] = { type: 'number', value: tokenCount };
@@ -322,6 +473,15 @@ export const ChatGoogleNodeImpl = {
                 signal: context.signal,
                 onFailedAttempt(err) {
                     context.trace(`ChatGoogleNode failed, retrying: ${err.toString()}`);
+                    const googleError = err;
+                    if (googleError.status && googleError.status >= 400 && googleError.status < 500) {
+                        if (googleError.status === 429) {
+                            context.trace('Google API rate limit exceeded, retrying...');
+                        }
+                        else {
+                            throw new Error(`Google API error: ${googleError.status} ${googleError.message}`);
+                        }
+                    }
                     if (context.signal.aborted) {
                         throw new Error('Aborted');
                     }
@@ -329,8 +489,11 @@ export const ChatGoogleNodeImpl = {
             });
         }
         catch (error) {
-            context.trace(getError(error).stack ?? 'Missing stack');
-            throw new Error(`Error processing ChatGoogleNode: ${error.message}`);
+            const raisedError = getError(error);
+            context.trace(raisedError.stack ?? 'Missing stack');
+            const err = new Error(`Error processing ChatGoogleNode: ${raisedError.message}`);
+            err.cause = raisedError;
+            throw err;
         }
     },
 };

package/dist/esm/plugins/google/plugin.js

@@ -7,26 +7,33 @@ export const googlePlugin = {
         register(chatGoogleNode);
     },
     configSpec: {
+        googleApiKey: {
+            type: 'secret',
+            label: 'Google API Key',
+            description: 'The API key for accessing Google generative AI.',
+            pullEnvironmentVariable: 'GOOGLE_GENERATIVE_AI_API_KEY',
+            helperText: 'You may also set the GOOGLE_GENERATIVE_AI_API_KEY environment variable.',
+        },
         googleProjectId: {
             type: 'string',
-            label: 'Google Project ID',
+            label: 'Google Project ID (Deprecated)',
             description: 'The Google project ID.',
             pullEnvironmentVariable: 'GCP_PROJECT',
-            helperText: 'You may also set the GCP_PROJECT environment variable.',
+            helperText: 'Deprecated, use Google API Key instead. You may also set the GCP_PROJECT environment variable.',
         },
         googleRegion: {
             type: 'string',
-            label: 'Google Region',
+            label: 'Google Region (Deprecated)',
             description: 'The Google region.',
             pullEnvironmentVariable: 'GCP_REGION',
-            helperText: 'You may also set the GCP_REGION environment variable.',
+            helperText: 'Deprecated, use Google API Key instead. You may also set the GCP_REGION environment variable.',
         },
         googleApplicationCredentials: {
             type: 'string',
-            label: 'Google Application Credentials',
+            label: 'Google Application Credentials (Deprecated)',
             description: 'The path with the JSON file that contains your credentials.',
             pullEnvironmentVariable: 'GOOGLE_APPLICATION_CREDENTIALS',
-            helperText: 'You may also set the GOOGLE_APPLICATION_CREDENTIALS environment variable. See https://cloud.google.com/vertex-ai/docs/start/client-libraries for more info.',
+            helperText: 'Deprecated, use Google API Key instead. You may also set the GOOGLE_APPLICATION_CREDENTIALS environment variable. See https://cloud.google.com/vertex-ai/docs/start/client-libraries for more info.',
         },
     },
 };

package/dist/esm/plugins/openai/nodes/RunThreadNode.js

@@ -1,10 +1,10 @@
-import { isArrayDataValue, arrayizeDataValue, unwrapDataValue, } from '../../../index.js';
+import {} from '../../../index.js';
 import { openAiModelOptions, } from '../../../utils/openai.js';
 import { dedent, newId, coerceTypeOptional, getInputOrData } from '../../../utils/index.js';
+import { arrayizeDataValue, unwrapDataValue } from '../../../model/DataValue.js';
 import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
 import { handleOpenAIError } from '../handleOpenaiError.js';
 import {} from '../../../model/DataValue.js';
-import { match } from 'ts-pattern';
 const POLL_FREQUENCY = 500;
 export const RunThreadNodeImpl = {
     create() {

package/dist/esm/plugins/openai/nodes/ThreadMessageNode.js

@@ -1,5 +1,5 @@
 import {} from '../../../index.js';
-import { dedent, newId, coerceTypeOptional, getInputOrData, coerceType } from '../../../utils/index.js';
+import { newId, coerceTypeOptional, getInputOrData, coerceType } from '../../../utils/index.js';
 import { interpolate } from '../../../utils/interpolation.js';
 import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
 import { mapValues } from 'lodash-es';