@nodetool-ai/base-nodes 0.7.0-rc.11

package/dist/nodes/input.js

@@ -0,0 +1,1459 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseNode, prop } from "@nodetool-ai/node-sdk";
+export class FloatInputNode extends BaseNode {
+    static nodeType = "nodetool.input.FloatInput";
+    static title = "Float Input";
+    static description = "Accepts a floating-point number as a parameter for workflows, typically constrained by a minimum and maximum value.  This input allows for precise numeric settings, such as adjustments, scores, or any value requiring decimal precision.\n    input, parameter, float, number, decimal, range";
+    static metadataOutputTypes = {
+        output: "float"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? 0.0 };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], FloatInputNode.prototype, "name", void 0);
+__decorate([
+    prop({ type: "float", default: 0, title: "Value" })
+], FloatInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], FloatInputNode.prototype, "description", void 0);
+__decorate([
+    prop({ type: "float", default: 0, title: "Min" })
+], FloatInputNode.prototype, "min", void 0);
+__decorate([
+    prop({ type: "float", default: 99999, title: "Max" })
+], FloatInputNode.prototype, "max", void 0);
+export class BooleanInputNode extends BaseNode {
+    static nodeType = "nodetool.input.BooleanInput";
+    static title = "Boolean Input";
+    static description = "Accepts a boolean (true/false) value as a parameter for workflows.  This input is used for binary choices, enabling or disabling features, or controlling conditional logic paths.\n    input, parameter, boolean, bool, toggle, switch, flag";
+    static metadataOutputTypes = {
+        output: "bool"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? false };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], BooleanInputNode.prototype, "name", void 0);
+__decorate([
+    prop({ type: "bool", default: false, title: "Value" })
+], BooleanInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], BooleanInputNode.prototype, "description", void 0);
+export class IntegerInputNode extends BaseNode {
+    static nodeType = "nodetool.input.IntegerInput";
+    static title = "Integer Input";
+    static description = "Accepts an integer (whole number) as a parameter for workflows, typically constrained by a minimum and maximum value.  This input is used for discrete numeric values like counts, indices, or iteration limits.\n    input, parameter, integer, number, count, index, whole_number";
+    static metadataOutputTypes = {
+        output: "int"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? 0 };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], IntegerInputNode.prototype, "name", void 0);
+__decorate([
+    prop({ type: "int", default: 0, title: "Value" })
+], IntegerInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], IntegerInputNode.prototype, "description", void 0);
+__decorate([
+    prop({ type: "int", default: 0, title: "Min" })
+], IntegerInputNode.prototype, "min", void 0);
+__decorate([
+    prop({ type: "int", default: 99999, title: "Max" })
+], IntegerInputNode.prototype, "max", void 0);
+export class SelectInputNode extends BaseNode {
+    static nodeType = "nodetool.input.SelectInput";
+    static title = "Select Input";
+    static description = "Accepts a selection from a predefined set of options as a parameter for workflows.\n    input, parameter, select, enum, dropdown, choice, options\n\n    Use cases:\n    - Let users choose from a fixed set of values in app mode\n    - Configure enum-like options for downstream nodes\n    - Provide dropdown selection for workflow parameters\n\n    The output is a string that can be connected to enum-typed inputs.";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    static basicFields = ["name", "value", "value"];
+    async process() {
+        return { value: this.value ?? "" };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], SelectInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Value",
+        description: "The currently selected value.",
+        json_schema_extra: {
+            type: "select"
+        }
+    })
+], SelectInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], SelectInputNode.prototype, "description", void 0);
+__decorate([
+    prop({
+        type: "list[str]",
+        default: [],
+        title: "Options",
+        description: "The list of available options to choose from."
+    })
+], SelectInputNode.prototype, "options", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Enum Type Name",
+        description: "The enum type name this select corresponds to (for type matching)."
+    })
+], SelectInputNode.prototype, "enum_type_name", void 0);
+export class StringListInputNode extends BaseNode {
+    static nodeType = "nodetool.input.StringListInput";
+    static title = "String List Input";
+    static description = "Accepts a list of strings as a parameter for workflows.\n    input, parameter, string, text, label, name, value";
+    static metadataOutputTypes = {
+        output: "list[str]"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? [] };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], StringListInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "list[str]",
+        default: [],
+        title: "Value",
+        description: "The list of strings to use as input."
+    })
+], StringListInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], StringListInputNode.prototype, "description", void 0);
+export class FolderPathInputNode extends BaseNode {
+    static nodeType = "nodetool.input.FolderPathInput";
+    static title = "Folder Path Input";
+    static description = "Accepts a folder path as a parameter for workflows.\n    input, parameter, folder, path, folderpath, local_folder, filesystem";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? "" };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], FolderPathInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Value",
+        description: "The folder path to use as input.",
+        json_schema_extra: {
+            type: "folder_path"
+        }
+    })
+], FolderPathInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], FolderPathInputNode.prototype, "description", void 0);
+export class HuggingFaceModelInputNode extends BaseNode {
+    static nodeType = "nodetool.input.HuggingFaceModelInput";
+    static title = "Hugging Face Model Input";
+    static description = "Accepts a Hugging Face model as a parameter for workflows.\n    input, parameter, model, huggingface, hugging_face, model_name";
+    static metadataOutputTypes = {
+        output: "hf.model"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? {} };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], HuggingFaceModelInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "hf.model",
+        default: {
+            type: "hf.model",
+            repo_id: "",
+            path: null,
+            variant: null,
+            allow_patterns: null,
+            ignore_patterns: null
+        },
+        title: "Value",
+        description: "The Hugging Face model to use as input."
+    })
+], HuggingFaceModelInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], HuggingFaceModelInputNode.prototype, "description", void 0);
+export class ColorInputNode extends BaseNode {
+    static nodeType = "nodetool.input.ColorInput";
+    static title = "Color Input";
+    static description = "Accepts a color value as a parameter for workflows.\n    input, parameter, color, color_picker, color_input";
+    static metadataOutputTypes = {
+        output: "color"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? {} };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], ColorInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "color",
+        default: {
+            type: "color",
+            value: null
+        },
+        title: "Value",
+        description: "The color to use as input."
+    })
+], ColorInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], ColorInputNode.prototype, "description", void 0);
+export class ImageSizeInputNode extends BaseNode {
+    static nodeType = "nodetool.input.ImageSizeInput";
+    static title = "Image Size Input";
+    static description = "Accepts image dimensions as a parameter for workflows.\n    input, parameter, image_size, resolution, width, height, dimensions";
+    static metadataOutputTypes = {
+        output: "image_size"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? {} };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], ImageSizeInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "image_size",
+        default: null,
+        title: "Value",
+        description: "The image size to use as input.",
+        required: true
+    })
+], ImageSizeInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], ImageSizeInputNode.prototype, "description", void 0);
+export class LanguageModelInputNode extends BaseNode {
+    static nodeType = "nodetool.input.LanguageModelInput";
+    static title = "Language Model Input";
+    static description = "Accepts a language model as a parameter for workflows.\n    input, parameter, model, language, model_name";
+    static metadataOutputTypes = {
+        output: "language_model"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? {} };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], LanguageModelInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "language_model",
+        default: {
+            type: "language_model",
+            provider: "empty",
+            id: "",
+            name: "",
+            path: null,
+            supported_tasks: []
+        },
+        title: "Value",
+        description: "The language model to use as input."
+    })
+], LanguageModelInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], LanguageModelInputNode.prototype, "description", void 0);
+export class ImageModelInputNode extends BaseNode {
+    static nodeType = "nodetool.input.ImageModelInput";
+    static title = "Image Model Input";
+    static description = "Accepts an image generation model as a parameter for workflows.\n    input, parameter, model, image, generation";
+    static metadataOutputTypes = {
+        output: "image_model"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? {} };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], ImageModelInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "image_model",
+        default: {
+            type: "image_model",
+            provider: "empty",
+            id: "",
+            name: "",
+            path: null,
+            supported_tasks: []
+        },
+        title: "Value",
+        description: "The image generation model to use as input."
+    })
+], ImageModelInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], ImageModelInputNode.prototype, "description", void 0);
+export class VideoModelInputNode extends BaseNode {
+    static nodeType = "nodetool.input.VideoModelInput";
+    static title = "Video Model Input";
+    static description = "Accepts a video generation model as a parameter for workflows.\n    input, parameter, model, video, generation";
+    static metadataOutputTypes = {
+        output: "video_model"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? {} };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], VideoModelInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "video_model",
+        default: {
+            type: "video_model",
+            provider: "empty",
+            id: "",
+            name: "",
+            path: null,
+            supported_tasks: []
+        },
+        title: "Value",
+        description: "The video generation model to use as input."
+    })
+], VideoModelInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], VideoModelInputNode.prototype, "description", void 0);
+export class TTSModelInputNode extends BaseNode {
+    static nodeType = "nodetool.input.TTSModelInput";
+    static title = "TTSModel Input";
+    static description = "Accepts a text-to-speech model as a parameter for workflows.\n    input, parameter, model, tts, speech, voice";
+    static metadataOutputTypes = {
+        output: "tts_model"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? {} };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], TTSModelInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "tts_model",
+        default: {
+            type: "tts_model",
+            provider: "empty",
+            id: "",
+            name: "",
+            path: null,
+            voices: [],
+            selected_voice: ""
+        },
+        title: "Value",
+        description: "The text-to-speech model to use as input."
+    })
+], TTSModelInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], TTSModelInputNode.prototype, "description", void 0);
+export class ASRModelInputNode extends BaseNode {
+    static nodeType = "nodetool.input.ASRModelInput";
+    static title = "ASRModel Input";
+    static description = "Accepts an automatic speech recognition model as a parameter for workflows.\n    input, parameter, model, asr, transcription, speech";
+    static metadataOutputTypes = {
+        output: "asr_model"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? {} };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], ASRModelInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "asr_model",
+        default: {
+            type: "asr_model",
+            provider: "empty",
+            id: "",
+            name: "",
+            path: null
+        },
+        title: "Value",
+        description: "The speech recognition model to use as input."
+    })
+], ASRModelInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], ASRModelInputNode.prototype, "description", void 0);
+export class EmbeddingModelInputNode extends BaseNode {
+    static nodeType = "nodetool.input.EmbeddingModelInput";
+    static title = "Embedding Model Input";
+    static description = "Accepts an embedding model as a parameter for workflows.\n    input, parameter, model, embedding, vector";
+    static metadataOutputTypes = {
+        output: "embedding_model"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? {} };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], EmbeddingModelInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "embedding_model",
+        default: {
+            type: "embedding_model",
+            provider: "empty",
+            id: "",
+            name: "",
+            dimensions: 0
+        },
+        title: "Value",
+        description: "The embedding model to use as input."
+    })
+], EmbeddingModelInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], EmbeddingModelInputNode.prototype, "description", void 0);
+export class DataframeInputNode extends BaseNode {
+    static nodeType = "nodetool.input.DataframeInput";
+    static title = "Dataframe Input";
+    static description = "Accepts a reference to a dataframe asset for workflows.\n    input, parameter, dataframe, table, data";
+    static metadataOutputTypes = {
+        output: "dataframe"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? {} };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], DataframeInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "dataframe",
+        default: {
+            type: "dataframe",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null,
+            columns: null
+        },
+        title: "Value",
+        description: "The dataframe to use as input."
+    })
+], DataframeInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], DataframeInputNode.prototype, "description", void 0);
+export class DocumentInputNode extends BaseNode {
+    static nodeType = "nodetool.input.DocumentInput";
+    static title = "Document Input";
+    static description = "Accepts a reference to a document asset for workflows, specified by a 'DocumentRef'.  A 'DocumentRef' points to a structured document (e.g., PDF, DOCX, TXT) which can be processed or analyzed. This node is used when the workflow needs to operate on a document as a whole entity, potentially including its structure and metadata, rather than just raw text.\n    input, parameter, document, file, asset, reference\n\n    Use cases:\n    - Load a specific document (e.g., PDF, Word, text file) for content extraction or analysis.\n    - Pass a document to models that are designed to process specific document formats.\n    - Manage documents as distinct assets within a workflow.\n    - If you have a local file path and need to convert it to a 'DocumentRef', consider using 'DocumentFileInput'.";
+    static metadataOutputTypes = {
+        output: "document"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? {} };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], DocumentInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "document",
+        default: {
+            type: "document",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Value",
+        description: "The document to use as input."
+    })
+], DocumentInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], DocumentInputNode.prototype, "description", void 0);
+export class ImageInputNode extends BaseNode {
+    static nodeType = "nodetool.input.ImageInput";
+    static title = "Image Input";
+    static description = "Accepts a reference to an image asset for workflows, specified by an 'ImageRef'.  An 'ImageRef' points to image data that can be used for display, analysis, or processing by vision models.\n    input, parameter, image, picture, graphic, visual, asset";
+    static metadataOutputTypes = {
+        output: "image"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? {} };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], ImageInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "image",
+        default: {
+            type: "image",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Value",
+        description: "The image to use as input."
+    })
+], ImageInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], ImageInputNode.prototype, "description", void 0);
+export class ImageListInputNode extends BaseNode {
+    static nodeType = "nodetool.input.ImageListInput";
+    static title = "Image List Input";
+    static description = "Accepts a list of image references as a parameter for workflows.\n    input, parameter, image, picture, graphic, visual, asset, list";
+    static metadataOutputTypes = {
+        output: "list[image]"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? [] };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], ImageListInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "list[image]",
+        default: [],
+        title: "Value",
+        description: "The list of images to use as input."
+    })
+], ImageListInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], ImageListInputNode.prototype, "description", void 0);
+export class VideoListInputNode extends BaseNode {
+    static nodeType = "nodetool.input.VideoListInput";
+    static title = "Video List Input";
+    static description = "Accepts a list of video references as a parameter for workflows.\n    input, parameter, video, movie, clip, visual, asset, list";
+    static metadataOutputTypes = {
+        output: "list[video]"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? [] };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], VideoListInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "list[video]",
+        default: [],
+        title: "Value",
+        description: "The list of videos to use as input."
+    })
+], VideoListInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], VideoListInputNode.prototype, "description", void 0);
+export class AudioListInputNode extends BaseNode {
+    static nodeType = "nodetool.input.AudioListInput";
+    static title = "Audio List Input";
+    static description = "Accepts a list of audio references as a parameter for workflows.\n    input, parameter, audio, sound, voice, speech, asset, list";
+    static metadataOutputTypes = {
+        output: "list[audio]"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? [] };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], AudioListInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "list[audio]",
+        default: [],
+        title: "Value",
+        description: "The list of audio files to use as input."
+    })
+], AudioListInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], AudioListInputNode.prototype, "description", void 0);
+export class TextListInputNode extends BaseNode {
+    static nodeType = "nodetool.input.TextListInput";
+    static title = "Text List Input";
+    static description = "Accepts a list of text strings as a parameter for workflows.\n    input, parameter, text, string, list";
+    static metadataOutputTypes = {
+        output: "list[str]"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? [] };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], TextListInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "list[str]",
+        default: [],
+        title: "Value",
+        description: "The list of text strings to use as input."
+    })
+], TextListInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], TextListInputNode.prototype, "description", void 0);
+export class VideoInputNode extends BaseNode {
+    static nodeType = "nodetool.input.VideoInput";
+    static title = "Video Input";
+    static description = "Accepts a reference to a video asset for workflows, specified by a 'VideoRef'.  A 'VideoRef' points to video data that can be used for playback, analysis, frame extraction, or processing by video-capable models.\n    input, parameter, video, movie, clip, visual, asset";
+    static metadataOutputTypes = {
+        output: "video"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? {} };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], VideoInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "video",
+        default: {
+            type: "video",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null,
+            duration: null,
+            format: null
+        },
+        title: "Value",
+        description: "The video to use as input."
+    })
+], VideoInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], VideoInputNode.prototype, "description", void 0);
+export class AudioInputNode extends BaseNode {
+    static nodeType = "nodetool.input.AudioInput";
+    static title = "Audio Input";
+    static description = "Accepts a reference to an audio asset for workflows, specified by an 'AudioRef'.  An 'AudioRef' points to audio data that can be used for playback, transcription, analysis, or processing by audio-capable models.\n    input, parameter, audio, sound, voice, speech, asset";
+    static metadataOutputTypes = {
+        output: "audio"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? {} };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], AudioInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "audio",
+        default: {
+            type: "audio",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Value",
+        description: "The audio to use as input."
+    })
+], AudioInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], AudioInputNode.prototype, "description", void 0);
+export class Model3DInputNode extends BaseNode {
+    static nodeType = "nodetool.input.Model3DInput";
+    static title = "Model 3D Input";
+    static description = "Accepts a reference to a 3D model asset for workflows, specified by a 'Model3DRef'.\n    A 'Model3DRef' points to 3D model data that can be used for visualization, processing,\n    or conversion by 3D-capable nodes.\n    input, parameter, 3d, model, mesh, obj, glb, stl, ply, asset";
+    static metadataOutputTypes = {
+        output: "model_3d"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? {} };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], Model3DInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "model_3d",
+        default: {
+            type: "model_3d",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null,
+            format: null,
+            material_file: null,
+            texture_files: []
+        },
+        title: "Value",
+        description: "The 3D model to use as input."
+    })
+], Model3DInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], Model3DInputNode.prototype, "description", void 0);
+export class AssetFolderInputNode extends BaseNode {
+    static nodeType = "nodetool.input.AssetFolderInput";
+    static title = "Asset Folder Input";
+    static description = "Accepts an asset folder as a parameter for workflows.\n    input, parameter, folder, path, folderpath, local_folder, filesystem";
+    static metadataOutputTypes = {
+        output: "folder"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? {} };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], AssetFolderInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "folder",
+        default: {
+            type: "folder",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Value",
+        description: "The folder to use as input."
+    })
+], AssetFolderInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], AssetFolderInputNode.prototype, "description", void 0);
+export class MessageInputNode extends BaseNode {
+    static nodeType = "nodetool.input.MessageInput";
+    static title = "Message Input";
+    static description = "Accepts a chat message object for workflows.\n    input, parameter, message, chat, conversation";
+    static metadataOutputTypes = {
+        output: "message"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? {} };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], MessageInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "message",
+        default: {
+            type: "message",
+            id: null,
+            workflow_id: null,
+            graph: null,
+            thread_id: null,
+            tools: null,
+            tool_call_id: null,
+            role: "",
+            name: null,
+            content: null,
+            tool_calls: null,
+            collections: null,
+            input_files: null,
+            created_at: null,
+            provider: null,
+            model: null,
+            agent_mode: null,
+            help_mode: null,
+            agent_execution_id: null,
+            execution_event_type: null,
+            workflow_target: null,
+            workflow_message_input_name: null,
+            workflow_messages_input_name: null
+        },
+        title: "Value",
+        description: "The message object containing role, content, and metadata."
+    })
+], MessageInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], MessageInputNode.prototype, "description", void 0);
+export class MessageListInputNode extends BaseNode {
+    static nodeType = "nodetool.input.MessageListInput";
+    static title = "Message List Input";
+    static description = "Accepts a list of chat message objects for workflows.\n    input, parameter, messages, chat, conversation, history";
+    static metadataOutputTypes = {
+        output: "list[message]"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? [] };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], MessageListInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "list[message]",
+        default: [],
+        title: "Value",
+        description: "The list of message objects representing chat history."
+    })
+], MessageListInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], MessageListInputNode.prototype, "description", void 0);
+export class StringInputNode extends BaseNode {
+    static nodeType = "nodetool.input.StringInput";
+    static title = "String Input";
+    static description = "Accepts a string value as a parameter for workflows.\n    input, parameter, string, text, label, name, value\n\n    Use cases:\n    - Define a name for an entity or process.\n    - Specify a label for a component or output.\n    - Enter a short keyword or search term.\n    - Provide a simple configuration value (e.g., an API key, a model name).\n    - If you need to input multi-line text or the content of a file, use 'DocumentFileInput'.";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        const raw = String(this.value ?? "");
+        const max = Number(this.max_length ?? 0);
+        if (max > 0 && raw.length > max) {
+            return { value: raw.slice(0, max) };
+        }
+        return { value: raw };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], StringInputNode.prototype, "name", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "Value" })
+], StringInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], StringInputNode.prototype, "description", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 0,
+        title: "Max length",
+        description: "Maximum number of characters allowed. Use 0 for unlimited.",
+        min: 0,
+        max: 100000
+    })
+], StringInputNode.prototype, "max_length", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "single_line",
+        title: "Line mode",
+        description: "Controls whether the UI should render the input as single-line or multiline.",
+        json_schema_extra: {
+            type: "enum",
+            values: ["single_line", "multi_line"]
+        }
+    })
+], StringInputNode.prototype, "line_mode", void 0);
+export class RealtimeAudioInputNode extends BaseNode {
+    static nodeType = "nodetool.input.RealtimeAudioInput";
+    static title = "Realtime Audio Input";
+    static description = "Accepts streaming audio data for workflows.\n    input, parameter, audio, sound, voice, speech, asset";
+    static metadataOutputTypes = {
+        chunk: "chunk"
+    };
+    static basicFields = ["name", "value", "value"];
+    static isStreamingOutput = true;
+    async process() {
+        return { chunk: this.value ?? null };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "audio",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], RealtimeAudioInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "audio",
+        default: {
+            type: "audio",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Value",
+        description: "The audio to use as input."
+    })
+], RealtimeAudioInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], RealtimeAudioInputNode.prototype, "description", void 0);
+export class DocumentFileInputNode extends BaseNode {
+    static nodeType = "nodetool.input.DocumentFileInput";
+    static title = "Document File Input";
+    static description = "Accepts a local file path pointing to a document and converts it into a 'DocumentRef'.\n    input, parameter, document, file, path, local_file, load";
+    static metadataOutputTypes = {
+        document: "document",
+        path: "str"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        const p = String(this.value ?? "");
+        return { document: { uri: p ? `file://${p}` : "" }, path: p };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], DocumentFileInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Value",
+        description: "The path to the document file.",
+        json_schema_extra: {
+            type: "file_path"
+        }
+    })
+], DocumentFileInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], DocumentFileInputNode.prototype, "description", void 0);
+export class FilePathInputNode extends BaseNode {
+    static nodeType = "nodetool.input.FilePathInput";
+    static title = "File Path Input";
+    static description = "Accepts a local filesystem path (to a file or directory) as input for workflows.\n    input, parameter, path, filepath, directory, local_file, filesystem";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    static basicFields = ["name", "value"];
+    async process() {
+        return { value: this.value ?? "" };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Name",
+        description: "The parameter name for the workflow."
+    })
+], FilePathInputNode.prototype, "name", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Value",
+        description: "The path to use as input.",
+        json_schema_extra: {
+            type: "file_path"
+        }
+    })
+], FilePathInputNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Description",
+        description: "The description of the input for the workflow."
+    })
+], FilePathInputNode.prototype, "description", void 0);
+export class MessageDeconstructorNode extends BaseNode {
+    static nodeType = "nodetool.input.MessageDeconstructor";
+    static title = "Message Deconstructor";
+    static description = "Deconstructs a chat message object into its individual fields.\n    extract, decompose, message, fields, chat\n\n    Use cases:\n    - Extract specific fields from a message (e.g., role, content, thread_id).\n    - Access message metadata for workflow logic.\n    - Process different parts of a message separately.";
+    static metadataOutputTypes = {
+        id: "str",
+        thread_id: "str",
+        role: "str",
+        text: "str",
+        image: "image",
+        audio: "audio",
+        model: "language_model"
+    };
+    async process() {
+        const msg = (this.value ?? {});
+        const content = msg.content;
+        let text = "";
+        let image = null;
+        let audio = null;
+        if (typeof content === "string") {
+            text = content;
+        }
+        else if (Array.isArray(content)) {
+            for (const item of content) {
+                if (!item || typeof item !== "object")
+                    continue;
+                const block = item;
+                const type = String(block.type ?? "");
+                if (type === "text")
+                    text = String(block.text ?? "");
+                else if (type === "image" || type === "image_url")
+                    image = block.image ?? null;
+                else if (type === "audio")
+                    audio = block.audio ?? null;
+            }
+        }
+        const provider = msg.provider;
+        const modelId = msg.model;
+        const model = typeof provider === "string" && typeof modelId === "string"
+            ? { provider, id: modelId }
+            : null;
+        return {
+            id: msg.id ?? null,
+            thread_id: msg.thread_id ?? null,
+            role: String(msg.role ?? ""),
+            text,
+            image,
+            audio,
+            model
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "message",
+        default: {
+            type: "message",
+            id: null,
+            workflow_id: null,
+            graph: null,
+            thread_id: null,
+            tools: null,
+            tool_call_id: null,
+            role: "",
+            name: null,
+            content: null,
+            tool_calls: null,
+            collections: null,
+            input_files: null,
+            created_at: null,
+            provider: null,
+            model: null,
+            agent_mode: null,
+            help_mode: null,
+            agent_execution_id: null,
+            execution_event_type: null,
+            workflow_target: null,
+            workflow_message_input_name: null,
+            workflow_messages_input_name: null
+        },
+        title: "Value",
+        description: "The message object to deconstruct."
+    })
+], MessageDeconstructorNode.prototype, "value", void 0);
+export const INPUT_NODES = [
+    FloatInputNode,
+    BooleanInputNode,
+    IntegerInputNode,
+    StringInputNode,
+    SelectInputNode,
+    StringListInputNode,
+    FolderPathInputNode,
+    HuggingFaceModelInputNode,
+    ColorInputNode,
+    ImageSizeInputNode,
+    LanguageModelInputNode,
+    ImageModelInputNode,
+    VideoModelInputNode,
+    TTSModelInputNode,
+    ASRModelInputNode,
+    EmbeddingModelInputNode,
+    DataframeInputNode,
+    DocumentInputNode,
+    ImageInputNode,
+    ImageListInputNode,
+    VideoListInputNode,
+    AudioListInputNode,
+    TextListInputNode,
+    VideoInputNode,
+    AudioInputNode,
+    Model3DInputNode,
+    RealtimeAudioInputNode,
+    AssetFolderInputNode,
+    FilePathInputNode,
+    DocumentFileInputNode,
+    MessageInputNode,
+    MessageListInputNode,
+    MessageDeconstructorNode
+];
+//# sourceMappingURL=input.js.map