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

package/dist/nodes/generators.js

@@ -0,0 +1,937 @@
+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";
+import { isChunkItem, isToolCallItem, streamProviderMessages, toProviderTools } from "./agents.js";
+function asText(value) {
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (!value)
+        return "";
+    return JSON.stringify(value);
+}
+function parseRequestedCount(prompt, fallback) {
+    const m = prompt.match(/\b(\d{1,3})\b/);
+    if (!m)
+        return fallback;
+    const n = Number(m[1]);
+    if (!Number.isFinite(n))
+        return fallback;
+    return Math.max(1, Math.min(200, Math.floor(n)));
+}
+function parseColumns(input) {
+    return parseColumnSpecs(input).map((column) => column.name);
+}
+function parseColumnSpecs(input) {
+    if (Array.isArray(input)) {
+        return input
+            .map((c) => {
+            if (c && typeof c === "object") {
+                const record = c;
+                const name = typeof record.name === "string"
+                    ? record.name
+                    : String(record.name ?? "");
+                const dataType = typeof record.data_type === "string"
+                    ? record.data_type
+                    : typeof record.type === "string"
+                        ? record.type
+                        : undefined;
+                return { name, data_type: dataType };
+            }
+            return { name: String(c) };
+        })
+            .filter((c) => c.name.length > 0);
+    }
+    if (input && typeof input === "object") {
+        const columns = input.columns;
+        if (Array.isArray(columns))
+            return parseColumnSpecs(columns);
+    }
+    return [];
+}
+function makeRows(columns, count, seedText) {
+    const names = columns.length > 0 ? columns : ["value"];
+    const rows = [];
+    for (let i = 0; i < count; i += 1) {
+        const row = {};
+        for (const col of names) {
+            const lower = col.toLowerCase();
+            if (lower.includes("id"))
+                row[col] = i + 1;
+            else if (lower.includes("name"))
+                row[col] = `${seedText || "item"}_${i + 1}`;
+            else if (lower.includes("date"))
+                row[col] = new Date(Date.now() + i * 86_400_000).toISOString();
+            else if (lower.includes("price") ||
+                lower.includes("amount") ||
+                lower.includes("score")) {
+                row[col] = Number((10 + i * 1.5).toFixed(2));
+            }
+            else if (lower.includes("active") || lower.startsWith("is_")) {
+                row[col] = i % 2 === 0;
+            }
+            else
+                row[col] = `${seedText || "value"}_${i + 1}`;
+        }
+        rows.push(row);
+    }
+    return rows;
+}
+function buildSchemaFromDynamicOutputs(outputs) {
+    if (!outputs || typeof outputs !== "object" || Array.isArray(outputs))
+        return null;
+    const properties = {};
+    const required = [];
+    for (const [name, spec] of Object.entries(outputs)) {
+        required.push(name);
+        const value = spec && typeof spec === "object" ? spec : {};
+        const declared = typeof value.type === "string" ? value.type.toLowerCase() : "str";
+        let type = "string";
+        if (["int", "integer"].includes(declared))
+            type = "integer";
+        else if (["float", "number"].includes(declared))
+            type = "number";
+        else if (["bool", "boolean"].includes(declared))
+            type = "boolean";
+        else if (["list", "array"].includes(declared))
+            type = "array";
+        else if (["dict", "object"].includes(declared))
+            type = "object";
+        properties[name] = { type };
+    }
+    if (required.length === 0)
+        return null;
+    return { type: "object", additionalProperties: false, required, properties };
+}
+function normalizeBinaryRef(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    const out = {};
+    if (typeof record.uri === "string" && record.uri)
+        out.uri = record.uri;
+    if (record.data instanceof Uint8Array || typeof record.data === "string")
+        out.data = record.data;
+    if (typeof record.mimeType === "string" && record.mimeType)
+        out.mimeType = record.mimeType;
+    if (typeof record.mime_type === "string" && record.mime_type)
+        out.mimeType = record.mime_type;
+    return out.uri || out.data ? out : null;
+}
+function buildMessageContent(text, image, audio) {
+    const imageRef = normalizeBinaryRef(image);
+    const audioRef = normalizeBinaryRef(audio);
+    if (!imageRef && !audioRef)
+        return text;
+    const parts = [{ type: "text", text }];
+    if (imageRef)
+        parts.push({ type: "image", image: imageRef });
+    if (audioRef)
+        parts.push({ type: "audio", audio: audioRef });
+    return parts;
+}
+function getModelConfig(props) {
+    const model = (props.model ?? {}) ?? {};
+    return {
+        providerId: typeof model.provider === "string" ? model.provider : "",
+        modelId: typeof model.id === "string" ? model.id : ""
+    };
+}
+function hasProviderSupport(context, providerId, modelId) {
+    return (!!context &&
+        typeof context.runProviderPrediction === "function" &&
+        typeof context.streamProviderPrediction === "function" &&
+        !!providerId &&
+        !!modelId);
+}
+const LIST_GENERATOR_SYSTEM_PROMPT = "You generate a list by calling the `add_item` tool exactly once per item. " +
+    "Each call submits a single item as a short string. " +
+    "Do not output prose, explanations, or markdown — only emit tool calls. " +
+    "When the list is complete, stop without calling the tool again.";
+function makeAddItemTool() {
+    return {
+        name: "add_item",
+        description: "Add one item to the output list. Call this once per item in the list.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["item"],
+            properties: {
+                item: {
+                    type: "string",
+                    description: "The list item content (a single string)."
+                }
+            }
+        },
+        process: async (_ctx, params) => {
+            const item = asText(params?.item ?? "");
+            return { ok: true, item };
+        }
+    };
+}
+async function* streamListItemsViaToolCalls(context, providerId, modelId, prompt, maxTokens) {
+    const provider = await context.getProvider(providerId);
+    const tool = makeAddItemTool();
+    const providerTools = toProviderTools([tool]);
+    const messages = [
+        { role: "system", content: LIST_GENERATOR_SYSTEM_PROMPT },
+        { role: "user", content: prompt }
+    ];
+    for await (const item of streamProviderMessages(provider, {
+        messages,
+        model: modelId,
+        tools: providerTools,
+        maxTokens
+    })) {
+        if (isToolCallItem(item) && item.name === "add_item") {
+            const text = asText(item.args?.item ?? "").trim();
+            if (text)
+                yield text;
+        }
+        else if (isChunkItem(item)) {
+            // Ignore narrative text — items only come via tool calls.
+        }
+    }
+}
+function dataframeFromRows(rows, columnsInput) {
+    const names = rows.length > 0
+        ? Object.keys(rows[0])
+        : parseColumnSpecs(columnsInput).map((s) => s.name);
+    return {
+        rows,
+        columns: names.map((name) => ({ name })),
+        data: rows.map((row) => names.map((name) => row[name] ?? null))
+    };
+}
+function parseCsv(text, specs) {
+    const lines = text
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0 && !l.startsWith("```"));
+    if (lines.length < 2)
+        return [];
+    const header = lines[0].split(",").map((h) => h.trim().replace(/^"|"$/g, ""));
+    return lines.slice(1).map((line) => {
+        const cells = line.match(/(".*?"|[^,]+|(?<=,)(?=,)|(?<=,)$|^(?=,))/g) ??
+            line.split(",");
+        const row = {};
+        header.forEach((name, i) => {
+            const raw = (cells[i] ?? "").trim().replace(/^"|"$/g, "");
+            const spec = specs.find((s) => s.name === name);
+            const kind = (spec?.data_type ?? "").toLowerCase();
+            if (kind === "int" || kind === "integer") {
+                const n = Number.parseInt(raw, 10);
+                row[name] = Number.isFinite(n) ? n : raw;
+            }
+            else if (kind === "float" || kind === "number") {
+                const n = Number.parseFloat(raw);
+                row[name] = Number.isFinite(n) ? n : raw;
+            }
+            else {
+                row[name] = raw;
+            }
+        });
+        return row;
+    });
+}
+async function generateDataframeFromCsv(context, providerId, modelId, prompt, columnsInput, count, maxTokens) {
+    const specs = parseColumnSpecs(columnsInput);
+    const columnHint = specs.length > 0
+        ? `Use exactly these columns: ${specs.map((s) => s.name).join(", ")}.`
+        : "Choose appropriate columns for the data.";
+    const systemPrompt = `You are a data generator. Return ONLY a CSV with a header row and exactly ${count} data rows. No explanation, no markdown fences, no extra text. ${columnHint}`;
+    const result = await context.runProviderPrediction({
+        provider: providerId,
+        capability: "generate_message",
+        model: modelId,
+        params: {
+            model: modelId,
+            messages: [
+                { role: "system", content: systemPrompt },
+                { role: "user", content: prompt }
+            ],
+            max_tokens: maxTokens
+        }
+    });
+    const content = asText(result.content ?? result);
+    return parseCsv(content, specs);
+}
+export class StructuredOutputGeneratorNode extends BaseNode {
+    static nodeType = "nodetool.generators.StructuredOutputGenerator";
+    static title = "Structured Output Generator";
+    static description = "Generate structured JSON objects from instructions using LLM providers.\n    data-generation, structured-data, json, synthesis\n\n    Specialized for creating structured information:\n    - Generating JSON that follows dynamic schemas\n    - Fabricating records from requirements and guidance\n    - Simulating sample data for downstream workflows\n    - Producing consistent structured outputs for testing";
+    static basicFields = ["instructions", "context", "model"];
+    static supportsDynamicOutputs = true;
+    async process(context) {
+        const { providerId, modelId } = getModelConfig(this.serialize());
+        const schema = buildSchemaFromDynamicOutputs(this._dynamic_outputs);
+        if (schema && hasProviderSupport(context, providerId, modelId)) {
+            const instructions = asText(this.instructions ?? this.instructions ?? "");
+            const extraContext = asText(this.context ?? this.context ?? "");
+            const systemPrompt = asText(this.system_prompt ?? "");
+            const userText = [instructions, extraContext]
+                .filter(Boolean)
+                .join("\n\n");
+            const messages = [];
+            if (systemPrompt) {
+                messages.push({ role: "system", content: systemPrompt });
+            }
+            messages.push({
+                role: "user",
+                content: buildMessageContent(userText, this.image, this.audio)
+            });
+            const result = await context.runProviderPrediction({
+                provider: providerId,
+                capability: "generate_message",
+                model: modelId,
+                params: {
+                    model: modelId,
+                    messages,
+                    response_format: {
+                        type: "json_schema",
+                        json_schema: {
+                            name: "structured_output",
+                            schema
+                        }
+                    }
+                }
+            });
+            if (result &&
+                typeof result === "object" &&
+                "content" in result) {
+                const content = asText(result.content ?? "");
+                try {
+                    return JSON.parse(content);
+                }
+                catch {
+                    return { output: content };
+                }
+            }
+        }
+        if (schema && typeof schema === "object" && !Array.isArray(schema)) {
+            const props = schema.properties ?? {};
+            const out = {};
+            for (const key of Object.keys(props)) {
+                const spec = props[key];
+                if (spec?.type === "number" || spec?.type === "integer")
+                    out[key] = 0;
+                else if (spec?.type === "boolean")
+                    out[key] = false;
+                else if (spec?.type === "array")
+                    out[key] = [];
+                else if (spec?.type === "object")
+                    out[key] = {};
+                else
+                    out[key] = "";
+            }
+            return out;
+        }
+        const instructions = asText(this.instructions ?? this.instructions ?? "");
+        const contextText = asText(this.context ?? this.context ?? "");
+        return {
+            output: {
+                instructions,
+                context: contextText
+            }
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "\nYou are a structured data generator focused on JSON outputs.\n\nGoal\n- Produce a high-quality JSON object that matches <JSON_SCHEMA> using the guidance in <INSTRUCTIONS> and any supplemental <CONTEXT>.\n\nOutput format (MANDATORY)\n- Output exactly ONE fenced code block labeled json containing ONLY the JSON object:\n\n  ```json\n  { ...single JSON object matching <JSON_SCHEMA>... }\n  ```\n\n- No additional prose before or after the block.\n\nGeneration rules\n- Invent plausible, internally consistent values when not explicitly provided.\n- Honor all constraints from <JSON_SCHEMA> (types, enums, ranges, formats).\n- Prefer ISO 8601 for dates/times when applicable.\n- Ensure numbers respect reasonable magnitudes and relationships described in <INSTRUCTIONS>.\n- Avoid referencing external sources; rely solely on the provided guidance.\n\nValidation\n- Ensure the final JSON validates against <JSON_SCHEMA> exactly.\n",
+        title: "System Prompt",
+        description: "The system prompt guiding JSON generation."
+    })
+], StructuredOutputGeneratorNode.prototype, "system_prompt", void 0);
+__decorate([
+    prop({
+        type: "language_model",
+        default: {
+            type: "language_model",
+            provider: "empty",
+            id: "",
+            name: "",
+            path: null,
+            supported_tasks: []
+        },
+        title: "Model",
+        description: "Model to use for structured generation."
+    })
+], StructuredOutputGeneratorNode.prototype, "model", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Instructions",
+        description: "Detailed instructions for the structured output."
+    })
+], StructuredOutputGeneratorNode.prototype, "instructions", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Context",
+        description: "Optional context to ground the generation."
+    })
+], StructuredOutputGeneratorNode.prototype, "context", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 4096,
+        title: "Max Tokens",
+        description: "The maximum number of tokens to generate.",
+        min: 1,
+        max: 16384
+    })
+], StructuredOutputGeneratorNode.prototype, "max_tokens", void 0);
+__decorate([
+    prop({
+        type: "image",
+        default: {
+            type: "image",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Image",
+        description: "Optional image to include in the generation request."
+    })
+], StructuredOutputGeneratorNode.prototype, "image", void 0);
+__decorate([
+    prop({
+        type: "audio",
+        default: {
+            type: "audio",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Audio",
+        description: "Optional audio to include in the generation request."
+    })
+], StructuredOutputGeneratorNode.prototype, "audio", void 0);
+export class DataGeneratorNode extends BaseNode {
+    static nodeType = "nodetool.generators.DataGenerator";
+    static title = "Data Generator";
+    static description = "LLM Agent to create a dataframe based on a user prompt.\n    llm, dataframe creation, data structuring\n\n    Use cases:\n    - Generating structured data from natural language descriptions\n    - Creating sample datasets for testing or demonstration\n    - Converting unstructured text into tabular format";
+    static metadataOutputTypes = {
+        record: "dict",
+        dataframe: "dataframe",
+        index: "int"
+    };
+    static basicFields = ["prompt", "model", "columns"];
+    static isStreamingOutput = true;
+    async process(context) {
+        const prompt = asText(this.prompt ?? this.prompt ?? "");
+        const inputText = asText(this.input_text ?? this.input_text ?? "");
+        const columnsInput = this.columns ?? this.columns;
+        const columns = parseColumns(columnsInput);
+        const count = parseRequestedCount(`${prompt} ${inputText}`, 5);
+        const { providerId, modelId } = getModelConfig(this.serialize());
+        if (hasProviderSupport(context, providerId, modelId)) {
+            const rows = await generateDataframeFromCsv(context, providerId, modelId, [prompt, inputText].filter(Boolean).join("\n\n"), columnsInput, count, Number(this.max_tokens ?? 4096));
+            if (rows.length > 0) {
+                return { output: dataframeFromRows(rows, columnsInput) };
+            }
+        }
+        const rows = makeRows(columns, count, inputText || prompt || "item");
+        return { output: dataframeFromRows(rows, columnsInput) };
+    }
+    async *genProcess(context) {
+        const full = await this.process(context);
+        const rows = (full.output.rows ?? []);
+        for (let i = 0; i < rows.length; i += 1) {
+            yield { record: rows[i], index: i, dataframe: null };
+        }
+        yield { record: null, index: null, dataframe: full.output };
+    }
+}
+__decorate([
+    prop({
+        type: "language_model",
+        default: {
+            type: "language_model",
+            provider: "empty",
+            id: "",
+            name: "",
+            path: null,
+            supported_tasks: []
+        },
+        title: "Model",
+        description: "The model to use for data generation."
+    })
+], DataGeneratorNode.prototype, "model", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Prompt",
+        description: "The user prompt"
+    })
+], DataGeneratorNode.prototype, "prompt", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Input Text",
+        description: "The input text to be analyzed by the agent."
+    })
+], DataGeneratorNode.prototype, "input_text", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 4096,
+        title: "Max Tokens",
+        description: "The maximum number of tokens to generate.",
+        min: 1,
+        max: 100000
+    })
+], DataGeneratorNode.prototype, "max_tokens", void 0);
+__decorate([
+    prop({
+        type: "record_type",
+        default: {
+            type: "record_type",
+            columns: []
+        },
+        title: "Columns",
+        description: "The columns to use in the dataframe."
+    })
+], DataGeneratorNode.prototype, "columns", void 0);
+export class ListGeneratorNode extends BaseNode {
+    static nodeType = "nodetool.generators.ListGenerator";
+    static title = "List Generator";
+    static description = "LLM Agent to create a stream of strings based on a user prompt.\n    llm, text streaming\n\n    Use cases:\n    - Generating text from natural language descriptions\n    - Streaming responses from an LLM";
+    static metadataOutputTypes = {
+        item: "str",
+        index: "int"
+    };
+    static basicFields = ["prompt", "model"];
+    static isStreamingOutput = true;
+    async process(context) {
+        const items = [];
+        for await (const chunk of this.genProcess(context)) {
+            const item = chunk.item;
+            if (typeof item === "string")
+                items.push(item);
+        }
+        return { output: items };
+    }
+    async *genProcess(context) {
+        const prompt = asText(this.prompt ?? "");
+        const inputText = asText(this.input_text ?? "");
+        const userMessage = [prompt, inputText].filter(Boolean).join("\n\n");
+        const { providerId, modelId } = getModelConfig(this.serialize());
+        if (context &&
+            typeof context.getProvider === "function" &&
+            providerId &&
+            modelId) {
+            let index = 0;
+            for await (const item of streamListItemsViaToolCalls(context, providerId, modelId, userMessage, Number(this.max_tokens ?? 128))) {
+                yield { item, index };
+                index += 1;
+            }
+            if (index === 0) {
+                throw new Error("Model returned no add_item tool calls — list is empty.");
+            }
+            return;
+        }
+        const seed = inputText || prompt || "item";
+        const count = parseRequestedCount(userMessage, 5);
+        for (let i = 0; i < count; i += 1) {
+            yield { item: `${seed}_${i + 1}`, index: i };
+        }
+    }
+}
+__decorate([
+    prop({
+        type: "language_model",
+        default: {
+            type: "language_model",
+            provider: "empty",
+            id: "",
+            name: "",
+            path: null,
+            supported_tasks: []
+        },
+        title: "Model",
+        description: "The model to use for string generation."
+    })
+], ListGeneratorNode.prototype, "model", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Prompt",
+        description: "The user prompt"
+    })
+], ListGeneratorNode.prototype, "prompt", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Input Text",
+        description: "The input text to be analyzed by the agent."
+    })
+], ListGeneratorNode.prototype, "input_text", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 4096,
+        title: "Max Tokens",
+        description: "The maximum number of tokens to generate.",
+        min: 1,
+        max: 100000
+    })
+], ListGeneratorNode.prototype, "max_tokens", void 0);
+export class ChartGeneratorNode extends BaseNode {
+    static nodeType = "nodetool.generators.ChartGenerator";
+    static title = "Chart Generator";
+    static description = "LLM Agent to create Plotly Express charts based on natural language descriptions.\n    llm, data visualization, charts\n\n    Use cases:\n    - Generating interactive charts from natural language descriptions\n    - Creating data visualizations with minimal configuration\n    - Converting data analysis requirements into visual representations";
+    static metadataOutputTypes = {
+        output: "chart_config"
+    };
+    static basicFields = ["prompt", "data", "model"];
+    async process(context) {
+        const prompt = asText(this.prompt ?? this.prompt ?? "");
+        const data = this.data ?? this.data ?? { rows: [] };
+        const rows = Array.isArray(data.rows)
+            ? (data.rows ?? [])
+            : [];
+        const keys = rows.length > 0 ? Object.keys(rows[0]) : [];
+        const xKey = keys[0] ?? "x";
+        const yKey = keys[1] ?? xKey;
+        const { providerId, modelId } = getModelConfig(this.serialize());
+        if (hasProviderSupport(context, providerId, modelId)) {
+            const dataSample = rows.length > 0
+                ? `Data columns: ${keys.join(", ")}\nSample rows:\n${JSON.stringify(rows.slice(0, 5), null, 2)}`
+                : "No data provided.";
+            const systemPrompt = `You are a Plotly visualization expert. Given a user's description and optional data, generate a Plotly chart configuration as JSON.
+The JSON must conform to the provided schema. Choose appropriate chart types (bar, line, scatter, pie, histogram, box, heatmap, etc.) based on the user's description.
+Use the data columns provided to set x_column, y_column, and label fields in the series array.
+Set a descriptive title, axis labels, and legend settings.`;
+            const userMessage = `${prompt}\n\n${dataSample}`;
+            const chartSchema = {
+                type: "object",
+                additionalProperties: false,
+                required: ["title", "x_label", "y_label", "legend", "data"],
+                properties: {
+                    title: { type: "string" },
+                    x_label: { type: "string" },
+                    y_label: { type: "string" },
+                    legend: { type: "boolean" },
+                    legend_position: { type: "string" },
+                    data: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["series"],
+                        properties: {
+                            series: {
+                                type: "array",
+                                items: {
+                                    type: "object",
+                                    additionalProperties: false,
+                                    required: ["type", "x_column", "y_column", "label"],
+                                    properties: {
+                                        type: { type: "string" },
+                                        x_column: { type: "string" },
+                                        y_column: { type: "string" },
+                                        label: { type: "string" }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+            const result = await context.runProviderPrediction({
+                provider: providerId,
+                capability: "generate_message",
+                model: modelId,
+                params: {
+                    model: modelId,
+                    messages: [
+                        { role: "system", content: systemPrompt },
+                        { role: "user", content: userMessage }
+                    ],
+                    max_tokens: Number(this.max_tokens ?? 4096),
+                    response_format: {
+                        type: "json_schema",
+                        json_schema: {
+                            name: "chart_config",
+                            schema: chartSchema
+                        }
+                    }
+                }
+            });
+            const content = asText(result.content ?? result);
+            try {
+                const parsed = JSON.parse(content);
+                return {
+                    output: {
+                        type: "chart_config",
+                        ...parsed,
+                        data: {
+                            type: "chart_data",
+                            ...(parsed.data ?? {}),
+                            row: null,
+                            col: null,
+                            col_wrap: null
+                        },
+                        height: null,
+                        aspect: null,
+                        x_lim: null,
+                        y_lim: null,
+                        x_scale: null,
+                        y_scale: null,
+                        palette: null,
+                        hue_order: null,
+                        hue_norm: null,
+                        sizes: null,
+                        size_order: null,
+                        size_norm: null,
+                        marginal_kws: null,
+                        joint_kws: null,
+                        diag_kind: null,
+                        corner: false,
+                        center: null,
+                        vmin: null,
+                        vmax: null,
+                        cmap: null,
+                        annot: false,
+                        fmt: ".2g",
+                        square: false
+                    }
+                };
+            }
+            catch {
+                // Fall through to hardcoded fallback
+            }
+        }
+        return {
+            output: {
+                type: "chart_config",
+                title: prompt || "Generated Chart",
+                x_label: xKey,
+                y_label: yKey,
+                legend: true,
+                data: {
+                    type: "chart_data",
+                    series: [
+                        {
+                            type: "bar",
+                            x_column: xKey,
+                            y_column: yKey,
+                            label: prompt || "series"
+                        }
+                    ],
+                    row: null,
+                    col: null,
+                    col_wrap: null
+                },
+                height: null,
+                aspect: null,
+                x_lim: null,
+                y_lim: null,
+                x_scale: null,
+                y_scale: null,
+                legend_position: "auto",
+                palette: null,
+                hue_order: null,
+                hue_norm: null,
+                sizes: null,
+                size_order: null,
+                size_norm: null,
+                marginal_kws: null,
+                joint_kws: null,
+                diag_kind: null,
+                corner: false,
+                center: null,
+                vmin: null,
+                vmax: null,
+                cmap: null,
+                annot: false,
+                fmt: ".2g",
+                square: false
+            }
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "language_model",
+        default: {
+            type: "language_model",
+            provider: "empty",
+            id: "",
+            name: "",
+            path: null,
+            supported_tasks: []
+        },
+        title: "Model",
+        description: "The model to use for chart generation."
+    })
+], ChartGeneratorNode.prototype, "model", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Prompt",
+        description: "Natural language description of the desired chart"
+    })
+], ChartGeneratorNode.prototype, "prompt", void 0);
+__decorate([
+    prop({
+        type: "dataframe",
+        default: {
+            type: "dataframe",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null,
+            columns: null
+        },
+        title: "Data",
+        description: "The data to visualize"
+    })
+], ChartGeneratorNode.prototype, "data", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 4096,
+        title: "Max Tokens",
+        description: "The maximum number of tokens to generate.",
+        min: 1,
+        max: 100000
+    })
+], ChartGeneratorNode.prototype, "max_tokens", void 0);
+export class SVGGeneratorNode extends BaseNode {
+    static nodeType = "nodetool.generators.SVGGenerator";
+    static title = "SVGGenerator";
+    static description = "LLM Agent to create SVG elements based on user prompts.\n    svg, generator, vector, graphics\n\n    Use cases:\n    - Creating vector graphics from text descriptions\n    - Generating scalable illustrations\n    - Creating custom icons and diagrams";
+    static metadataOutputTypes = {
+        output: "list[svg_element]"
+    };
+    static basicFields = ["prompt", "image", "audio", "model"];
+    async process(context) {
+        const prompt = asText(this.prompt ?? this.prompt ?? "");
+        const width = Number(this.width ?? 512) || 512;
+        const height = Number(this.height ?? 512) || 512;
+        const { providerId, modelId } = getModelConfig(this.serialize());
+        if (hasProviderSupport(context, providerId, modelId)) {
+            const systemPrompt = `You are an SVG graphics expert. Generate SVG markup based on the user's description.
+Return one or more complete <svg>...</svg> elements. Each SVG should use the xmlns="http://www.w3.org/2000/svg" attribute.
+Default canvas size is ${width}x${height} unless the user specifies otherwise.
+Output only SVG markup, no explanations or markdown fences.`;
+            const messages = [
+                { role: "system", content: systemPrompt },
+                {
+                    role: "user",
+                    content: buildMessageContent(prompt, this.image, this.audio)
+                }
+            ];
+            const result = await context.runProviderPrediction({
+                provider: providerId,
+                capability: "generate_message",
+                model: modelId,
+                params: {
+                    model: modelId,
+                    messages,
+                    max_tokens: Number(this.max_tokens ?? 8192)
+                }
+            });
+            const content = asText(result.content ?? result);
+            const svgMatches = Array.from(content.matchAll(/<svg[\s\S]*?<\/svg>/gi));
+            if (svgMatches.length > 0) {
+                return {
+                    output: svgMatches.map((m) => ({ content: m[0] }))
+                };
+            }
+        }
+        // Fallback: generate a simple placeholder SVG
+        const text = prompt || "SVG";
+        const safeText = text
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;");
+        const svg = `<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" fill="#f2f2f2"/><text x="16" y="32" font-size="20" fill="#111">${safeText}</text></svg>`;
+        return { output: [{ content: svg }] };
+    }
+}
+__decorate([
+    prop({
+        type: "language_model",
+        default: {
+            type: "language_model",
+            provider: "empty",
+            id: "",
+            name: "",
+            path: null,
+            supported_tasks: []
+        },
+        title: "Model",
+        description: "The language model to use for SVG generation."
+    })
+], SVGGeneratorNode.prototype, "model", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Prompt",
+        description: "The user prompt for SVG generation"
+    })
+], SVGGeneratorNode.prototype, "prompt", void 0);
+__decorate([
+    prop({
+        type: "image",
+        default: {
+            type: "image",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Image",
+        description: "Image to use for generation"
+    })
+], SVGGeneratorNode.prototype, "image", void 0);
+__decorate([
+    prop({
+        type: "audio",
+        default: {
+            type: "audio",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Audio",
+        description: "Audio to use for generation"
+    })
+], SVGGeneratorNode.prototype, "audio", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 8192,
+        title: "Max Tokens",
+        description: "The maximum number of tokens to generate.",
+        min: 1,
+        max: 100000
+    })
+], SVGGeneratorNode.prototype, "max_tokens", void 0);
+export const GENERATOR_NODES = [
+    StructuredOutputGeneratorNode,
+    DataGeneratorNode,
+    ListGeneratorNode,
+    ChartGeneratorNode,
+    SVGGeneratorNode
+];
+//# sourceMappingURL=generators.js.map