@nodetool-ai/llm-nodes 0.8.1

package/dist/nodes/generators.js

@@ -0,0 +1,966 @@
+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 { isChunk } from "@nodetool-ai/protocol";
+import { isToolCall } from "@nodetool-ai/runtime";
+import { tagAsServer } from "@nodetool-ai/nodes-utils";
+import { serializeToolResult, streamProviderMessages, toProviderTools } from "./agents.js";
+import { asText, buildUserMessage, getModelConfig, hasProviderAccess, hasProviderSupport } from "./agent-utils.js";
+import { meterProviderSpend } from "./provider-spend.js";
+import { isCallable, isObjectLike, isRecord, isString } from "@nodetool-ai/node-sdk";
+function parseRequestedCount(prompt, fallback) {
+    // Match any integer; large requests are clamped below rather than ignored.
+    const m = prompt.match(/\b(\d{1,9})\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 (isObjectLike(c)) {
+                const record = c;
+                const name = isString(record.name)
+                    ? record.name
+                    : String(record.name ?? "");
+                const dataType = isString(record.data_type)
+                    ? record.data_type
+                    : isString(record.type)
+                        ? record.type
+                        : undefined;
+                return { name, data_type: dataType };
+            }
+            return { name: String(c) };
+        })
+            .filter((c) => c.name.length > 0);
+    }
+    if (isObjectLike(input)) {
+        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 (!isRecord(outputs))
+        return null;
+    const properties = {};
+    const required = [];
+    for (const [name, spec] of Object.entries(outputs)) {
+        required.push(name);
+        const value = isRecord(spec) ? spec : {};
+        const declared = isString(value.type) ? 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 };
+}
+/**
+ * Run one chat completion for a generator node and book what it cost.
+ *
+ * `runProviderPrediction` emits `prediction` messages, but both consumers drop
+ * a token-billed capability, so a workflow made only of generator nodes left no
+ * ledger row. The provider instance `runGenerationWith` calls is the one
+ * `context.getProvider` memoizes, so the same before/after delta the other LLM
+ * nodes report covers this call too. See `meterProviderSpend`.
+ *
+ * A context without `getProvider` (a partial harness or test double) has no
+ * provider to read a running total from, so the call runs unmetered.
+ */
+async function runMeteredMessage(context, providerId, modelId, params) {
+    const run = () => context.runProviderPrediction({
+        provider: providerId,
+        capability: "generate_message",
+        model: modelId,
+        params
+    });
+    if (!isCallable(context.getProvider))
+        return run();
+    const provider = await context.getProvider(providerId);
+    const spend = meterProviderSpend(context, provider, modelId);
+    try {
+        return await run();
+    }
+    finally {
+        spend.report();
+    }
+}
+const LIST_GENERATOR_SYSTEM_PROMPT = "You generate a list by calling the `add_item` tool once per item. " +
+    "Each call submits one item, which may be a single line or span multiple " +
+    "lines or paragraphs, as the request requires. " +
+    "Continue calling `add_item` until all requested items have been emitted, " +
+    "then stop. " +
+    "If the user does not specify a count, emit 5 items. " +
+    "Use tool calls only — do not write the list as prose.";
+// Appended to the system prompt for a single retry when the model answers in
+// prose and emits no `add_item` calls, to push it into using the tool.
+const LIST_GENERATOR_ENFORCEMENT_PROMPT = "Your previous response produced no items because you did not call the " +
+    "`add_item` tool. Build the list now by calling `add_item` once per item. " +
+    "Do not reply with prose or explanations — only emit `add_item` tool calls.";
+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 content of one list item. It may be a single line or span " +
+                        "multiple lines or paragraphs, as the request requires."
+                }
+            }
+        },
+        process: async (_ctx, params) => {
+            const item = asText(params?.item ?? "");
+            return { ok: true, item };
+        }
+    };
+}
+async function* streamListItemsViaToolCalls(context, providerId, modelId, prompt, maxTokens, systemPrompt = LIST_GENERATOR_SYSTEM_PROMPT) {
+    const provider = await context.getProvider(providerId);
+    const tool = makeAddItemTool();
+    const providerTools = toProviderTools([tool]);
+    const messages = [
+        { role: "system", content: systemPrompt },
+        { 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 (isToolCall(item)) {
+                assistantToolCalls.push(item);
+                if (item.name === "add_item") {
+                    const text = asText(item.args?.item ?? "").trim();
+                    if (text) {
+                        yield text;
+                    }
+                }
+            }
+            else if (isChunk(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" && isCallable(tool.process)
+                ? 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 runMeteredMessage(context, providerId, modelId, {
+        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 inlineFields = ["instructions", "context"];
+    static inputFields = ["system_prompt", "image", "audio"];
+    static supportsDynamicOutputs = true;
+    // Persist the generated JSON object as a generation so it reloads on reopen.
+    static autoSaveAsset = 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);
+            const extraContext = asText(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(buildUserMessage(userText, this.image, this.audio));
+            const result = await runMeteredMessage(context, providerId, modelId, {
+                model: modelId,
+                messages,
+                max_tokens: this.max_tokens,
+                response_format: {
+                    type: "json_schema",
+                    json_schema: {
+                        name: "structured_output",
+                        schema
+                    }
+                }
+            });
+            if (isObjectLike(result) && "content" in result) {
+                const content = asText(result.content ?? "");
+                try {
+                    return JSON.parse(content);
+                }
+                catch {
+                    return { output: content };
+                }
+            }
+        }
+        if (isRecord(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);
+        const contextText = asText(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: "list[image]",
+        default: [],
+        title: "Images",
+        description: "Optional images to include in the generation request. Accepts a list, or a single Image (auto-wrapped). Each becomes a separate block in the message sent to the provider."
+    })
+], StructuredOutputGeneratorNode.prototype, "image", void 0);
+__decorate([
+    prop({
+        type: "list[audio]",
+        default: [],
+        title: "Audio",
+        description: "Optional audio to include in the generation request. Accepts a list, or a single Audio (auto-wrapped). Each becomes a separate block in the message sent to the provider."
+    })
+], 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 inlineFields = ["columns"];
+    static inputFields = ["prompt"];
+    // Persist the generated dataframe as a generation so it reloads on reopen.
+    static autoSaveAsset = true;
+    static primaryOutput = "dataframe";
+    static inputMode = "buffered";
+    static outputCorrelation = {
+        record: { kind: "iteration", source: "__execution__", group: "items" },
+        index: { kind: "iteration", source: "__execution__", group: "items" },
+        dataframe: { kind: "single", source: "__execution__" }
+    };
+    async process(context) {
+        const prompt = asText(this.prompt);
+        const inputText = asText(this.input_text);
+        const columnsInput = 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, this.max_tokens);
+            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",
+        output: "list[str]"
+    };
+    static inlineFields = [];
+    static inputFields = ["prompt"];
+    // Emit `item`/`index` output_updates even when the handles are wired onward,
+    // so the node's bespoke list body can show items as they stream regardless
+    // of downstream connections.
+    static alwaysEmitOutputUpdates = true;
+    // Persist the full generated list as a generation so the node reloads its
+    // items when the workflow is reopened. `output` carries the whole list (see
+    // the consolidating final yield in genProcess); `item`/`index` stay per-item
+    // for live streaming and downstream iteration.
+    static autoSaveAsset = true;
+    static primaryOutput = "output";
+    static inputMode = "buffered";
+    static outputCorrelation = {
+        item: { kind: "iteration", source: "__execution__", group: "items" },
+        index: { kind: "iteration", source: "__execution__", group: "items" },
+        output: { kind: "single", source: "__execution__" }
+    };
+    async process(context) {
+        const items = [];
+        for await (const chunk of this.genProcess(context)) {
+            const item = chunk.item;
+            if (isString(item))
+                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());
+        // Accumulate items so the stream-end frame can carry the whole list on the
+        // single `output` handle (drives the saved generation + reload).
+        const items = [];
+        if (hasProviderAccess(context) && providerId && modelId) {
+            let index = 0;
+            const maxTokens = this.max_tokens;
+            // Try the neutral prompt first. If the model answers in prose and emits no
+            // `add_item` calls (zero items), re-run once with an enforcement prompt
+            // that pushes it to use the tool before giving up.
+            const systemPrompts = [
+                LIST_GENERATOR_SYSTEM_PROMPT,
+                `${LIST_GENERATOR_SYSTEM_PROMPT}\n\n${LIST_GENERATOR_ENFORCEMENT_PROMPT}`
+            ];
+            for (const systemPrompt of systemPrompts) {
+                for await (const item of streamListItemsViaToolCalls(context, providerId, modelId, userMessage, maxTokens, systemPrompt)) {
+                    items.push(asText(item));
+                    yield { item, index };
+                    index += 1;
+                }
+                if (index > 0) {
+                    break;
+                }
+            }
+            if (index === 0) {
+                throw new Error("Model returned no add_item tool calls — list is empty.");
+            }
+            yield { output: items };
+            return;
+        }
+        const seed = inputText || prompt || "item";
+        const count = parseRequestedCount(userMessage, 5);
+        for (let i = 0; i < count; i += 1) {
+            const item = `${seed}_${i + 1}`;
+            items.push(item);
+            yield { item, index: i };
+        }
+        yield { output: items };
+    }
+}
+__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 inlineFields = [];
+    static inputFields = ["prompt", "data"];
+    // Persist the generated chart config as a generation so it reloads on reopen.
+    static autoSaveAsset = true;
+    static primaryOutput = "output";
+    async process(context) {
+        const prompt = asText(this.prompt);
+        const rows = Array.isArray(this.data.rows) ? this.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 runMeteredMessage(context, providerId, modelId, {
+                model: modelId,
+                messages: [
+                    { role: "system", content: systemPrompt },
+                    { role: "user", content: userMessage }
+                ],
+                max_tokens: this.max_tokens,
+                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"
+    })
+    // `DataframeRef` in the protocol has no `rows`, but every dataframe this repo
+    // actually passes carries one — `dataframeFromRows` above emits it, and
+    // `data-nodes` builds the same `RowsDataframe` shape.
+], 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 inlineFields = [];
+    static inputFields = ["prompt", "image", "audio"];
+    // Persist the generated SVG elements as a generation so they reload on reopen.
+    static autoSaveAsset = true;
+    static primaryOutput = "output";
+    async process(context) {
+        const prompt = asText(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 },
+                buildUserMessage(prompt, this.image, this.audio)
+            ];
+            const result = await runMeteredMessage(context, providerId, modelId, {
+                model: modelId,
+                messages,
+                max_tokens: this.max_tokens
+            });
+            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: "list[image]",
+        default: [],
+        title: "Images",
+        description: "Images to use for generation. Accepts a list, or a single Image (auto-wrapped). Each becomes a separate block in the message sent to the provider."
+    })
+], SVGGeneratorNode.prototype, "image", void 0);
+__decorate([
+    prop({
+        type: "list[audio]",
+        default: [],
+        title: "Audio",
+        description: "Audio to use for generation. Accepts a list, or a single Audio (auto-wrapped). Each becomes a separate block in the message sent to the provider."
+    })
+], 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 = tagAsServer([
+    StructuredOutputGeneratorNode,
+    DataGeneratorNode,
+    ListGeneratorNode,
+    ChartGeneratorNode,
+    SVGGeneratorNode
+]);
+//# sourceMappingURL=generators.js.map