@nodetool-ai/base-nodes 0.7.0-rc.23 → 0.8.2

package/dist/nodes/generators.js

@@ -1,968 +0,0 @@
-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, serializeToolResult, 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. " +
-    "Continue calling `add_item` until all requested items have been emitted. " +
-    "If the user does not specify a count, emit 5 items. " +
-    "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 }
-    ];
-    const maxIterations = parseRequestedCount(prompt, 5);
-    for (let iteration = 0; iteration < maxIterations; iteration += 1) {
-        const assistantToolCalls = [];
-        let assistantText = "";
-        for await (const item of streamProviderMessages(provider, {
-            messages,
-            model: modelId,
-            tools: providerTools,
-            maxTokens
-        })) {
-            if (isToolCallItem(item)) {
-                assistantToolCalls.push(item);
-                if (item.name === "add_item") {
-                    const text = asText(item.args?.item ?? "").trim();
-                    if (text) {
-                        yield text;
-                    }
-                }
-            }
-            else if (isChunkItem(item) && !item.thinking) {
-                // Narrative text is ignored for output, but kept in the conversation
-                // history so providers can continue after tool calls correctly.
-                assistantText += item.content ?? "";
-            }
-        }
-        if (assistantToolCalls.length === 0) {
-            break;
-        }
-        messages.push({
-            role: "assistant",
-            content: assistantText || null,
-            toolCalls: assistantToolCalls
-        });
-        for (const toolCall of assistantToolCalls) {
-            const result = toolCall.name === "add_item" && typeof tool.process === "function"
-                ? await tool.process(context, toolCall.args)
-                : { error: `Unknown tool: ${toolCall.name}` };
-            messages.push({
-                role: "tool",
-                toolCallId: toolCall.id,
-                content: JSON.stringify(serializeToolResult(result))
-            });
-        }
-    }
-}
-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