@saltcorn/copilot 0.7.2 → 0.7.3

package/actions/generate-tables.js

@@ -5,7 +5,7 @@ const Table = require("@saltcorn/data/models/table");
 const Field = require("@saltcorn/data/models/field");
 const { apply, removeAllWhiteSpace } = require("@saltcorn/data/utils");
 const { getActionConfigFields } = require("@saltcorn/data/plugin-helper");
-const { a, pre, script, div } = require("@saltcorn/markup/tags");
+const { a, pre, script, div, domReady } = require("@saltcorn/markup/tags");
 const { fieldProperties } = require("../common");
 
 class GenerateTables {
@@ -143,6 +143,10 @@ class GenerateTables {
     need to specify a primary key, a primary key called id with autoincrementing integers is
     autmatically generated. 
 
+    Only include brand-new tables in the generate_tables arguments. If the user references a table
+    that already exists, explain that generate_tables can only add new tables (not modify existing
+    ones) and omit those tables from the tool call.
+
     The database already contains the following tables: 
 
     ${tableLines.join("\n\n")}
@@ -154,7 +158,14 @@ class GenerateTables {
     const mmdia = buildMermaidMarkup(sctables);
     return (
       pre({ class: "mermaid" }, mmdia) +
-      script(`mermaid.run({querySelector: 'pre.mermaid'});`)
+      script(
+        domReady(`
+        ensure_script_loaded("/static_assets/"+_sc_version_tag+"/mermaid.min.js", () => {
+          mermaid.initialize({ startOnLoad: false });
+          mermaid.run({ querySelector: ".mermaid" });
+        });
+      `),
+      ) 
     );
   }
 

package/actions/generate-workflow.js

@@ -3,24 +3,89 @@ const WorkflowStep = require("@saltcorn/data/models/workflow_step");
 const Trigger = require("@saltcorn/data/models/trigger");
 const Table = require("@saltcorn/data/models/table");
 const { getActionConfigFields } = require("@saltcorn/data/plugin-helper");
-const { a, pre, script, div } = require("@saltcorn/markup/tags");
+const { a, pre, script, div, domReady } = require("@saltcorn/markup/tags");
 const { fieldProperties } = require("../common");
 
+const table_triggers = ["Insert", "Update", "Delete", "Validate"];
+const additional_triggers_with_onlyif = ["Login", "PageLoad"];
+
+const optionNames = (options = []) =>
+  options
+    .map((opt) =>
+      typeof opt === "string"
+        ? opt
+        : opt?.name || opt?.label || opt?.value || "",
+    )
+    .filter(Boolean);
+
+const joinOptionNames = (options = [], limit = 10) => {
+  const names = optionNames(options);
+  if (!names.length) return "none";
+  const shown = names.slice(0, limit).join(", ");
+  return names.length > limit ? `${shown}, ...` : shown;
+};
+
+const summarizeTriggerActionMatrix = () => {
+  try {
+    const allActions = Trigger.action_options({
+      notRequireRow: false,
+      workflow: true,
+    });
+    const noRowActions = Trigger.action_options({
+      notRequireRow: true,
+      workflow: true,
+    });
+    const lines = Trigger.when_options.map((when) => {
+      const pool = table_triggers.includes(when) ? allActions : noRowActions;
+      return `* ${when}: ${joinOptionNames(pool)}`;
+    });
+    const notes = `Triggers requiring a table context: ${table_triggers.join(", ")}.
+Additional triggers that commonly use contextual only_if checks: ${additional_triggers_with_onlyif.join(", ")}.`;
+    return `${notes}
+${lines.join("\n")}`;
+  } catch (e) {
+    console.error("GenerateWorkflow: action matrix failed", e);
+    return "";
+  }
+};
+
+const summarizeTables = async () => {
+  try {
+    const tables = await Table.find({});
+    if (!tables?.length) return "";
+    const fieldType = (f = {}) =>
+      f.pretty_type || f.type?.name || f.type || f.input_type || "unknown";
+    const rows = tables.map((table) => {
+      const description = table.description ? ` – ${table.description}` : "";
+      const fields = (table.fields || [])
+        .slice(0, 8)
+        .map((f) => `${f.name}:${fieldType(f)}`)
+        .join(", ");
+      const fieldText = fields ? ` fields: ${fields}` : "";
+      return `* ${table.name}${description}${fieldText}`;
+    });
+    return rows.join("\n");
+  } catch (e) {
+    console.error("GenerateWorkflow: table summary failed", e);
+    return "";
+  }
+};
+
 const steps = async () => {
   const actionExplainers = WorkflowStep.builtInActionExplainers();
   const actionFields = await WorkflowStep.builtInActionConfigFields();
 
   let stateActions = getState().actions;
   const stateActionList = Object.entries(stateActions).filter(
-    ([k, v]) => !v.disableInWorkflow
+    ([k, v]) => !v.disableInWorkflow,
   );
 
   const stepTypeAndCfg = Object.keys(actionExplainers).map((actionName) => {
-    const properties = { 
-      step_type: { type: "string", enum: [actionName] }
+    const properties = {
+      step_type: { type: "string", enum: [actionName] },
     };
     const myFields = actionFields.filter(
-      (f) => f.showIf?.wf_action_name === actionName
+      (f) => f.showIf?.wf_action_name === actionName,
     );
     const required = ["step_type"];
     myFields.forEach((f) => {
@@ -39,8 +104,8 @@ const steps = async () => {
   });
   for (const [actionName, action] of stateActionList) {
     try {
-      const properties = { 
-        step_type: { type: "string", enum: [actionName] }
+      const properties = {
+        step_type: { type: "string", enum: [actionName] },
       };
       const cfgFields = await getActionConfigFields(action, null, {
         mode: "workflow",
@@ -73,9 +138,9 @@ const steps = async () => {
   //TODO workflows
   for (const trigger of triggers) {
     const properties = {
-      step_type: { 
+      step_type: {
         type: "string",
-        enum: [trigger.name],  
+        enum: [trigger.name],
       },
     };
     if (trigger.table_id) {
@@ -88,7 +153,7 @@ const steps = async () => {
       properties.row_expr = {
         type: "string",
         description: `JavaScript expression for the input to the action. This should be an expression for an object, with the following field name and types: ${fieldSpecs.join(
-          "; "
+          "; ",
         )}.`,
       };
     }
@@ -150,11 +215,10 @@ class GenerateWorkflow {
           description:
             "When the workflow should trigger. Optional, leave blank if unspecified or workflow will be run on button click",
           type: "string",
-          enum: ["Insert", "Delete", "Update", "Daily", "Hourly", "Weekly"],
+          enum: Trigger.when_options,
         },
         trigger_table: {
-          description:
-            "If the workflow trigger is Insert, Delete or Update, the name of the table that triggers the workflow",
+          description: `If the workflow trigger is ${table_triggers.join(", ")}, the name of the table that triggers the workflow`,
           type: "string",
         },
       },
@@ -165,15 +229,29 @@ class GenerateWorkflow {
     const actionExplainers = WorkflowStep.builtInActionExplainers();
     let stateActions = getState().actions;
     const stateActionList = Object.entries(stateActions).filter(
-      ([k, v]) => !v.disableInWorkflow
+      ([k, v]) => !v.disableInWorkflow,
     );
+    const [tableSummary, triggerMatrix] = await Promise.all([
+      summarizeTables(),
+      Promise.resolve(summarizeTriggerActionMatrix()),
+    ]);
+    const contextBlocks = [
+      tableSummary && `Current tables and key fields:\n${tableSummary}`,
+      triggerMatrix && `Workflow trigger compatibility:\n${triggerMatrix}`,
+    ]
+      .filter(Boolean)
+      .join("\n\n");
 
     return `Use the generate_workflow tool to construct computational workflows according to specifications. You must create 
   the workflow by calling the generate_workflow tool, with the step required to implement the specification.
   
+  ${contextBlocks}
+  
   The steps are specified as JSON objects. Each step has a name, specified in the step_name key in the JSON object. 
   The step name should be a valid JavaScript identifier.
   
+  When the user explicitly names an action/step type (for example "ForLoop" or "Toast"), ensure the generated workflow contains at least one step whose step_configuration.step_type exactly matches every requested action. Only skip this if the action genuinely does not exist; in that case, clearly explain the omission in the workflow description.
+
   Each run of the workflow is executed in the presence of a context, which is a JavaScript object that individual
   steps can read values from and write values to. This context is a state that is persisted on disk for each workflow 
   run. 
@@ -239,7 +317,7 @@ class GenerateWorkflow {
 
   static async execute(
     { workflow_steps, workflow_name, when_trigger, trigger_table },
-    req
+    req,
   ) {
     const steps = this.process_all_steps(workflow_steps);
     let table_id;
@@ -268,7 +346,7 @@ class GenerateWorkflow {
         "Workflow created. " +
         a(
           { target: "_blank", href: `/actions/configure/${trigger.id}` },
-          "Configure workflow."
+          "Configure workflow.",
         ),
     };
   }
@@ -286,21 +364,29 @@ class GenerateWorkflow {
         step.id = ix + 1;
       });
       const mmdia = WorkflowStep.generate_diagram(
-        steps.map((s) => new WorkflowStep(s))
+        steps.map((s) => new WorkflowStep(s)),
       );
+      console.log({ mmdia });
       return (
         div(
           `${workflow_name}${when_trigger ? `: ${when_trigger}` : ""}${
             trigger_table ? ` on ${trigger_table}` : ""
-          }`
+          }`,
         ) +
         pre({ class: "mermaid" }, mmdia) +
-        script(`mermaid.run({querySelector: 'pre.mermaid'});`)
+        script(
+          domReady(`
+          ensure_script_loaded("/static_assets/"+_sc_version_tag+"/mermaid.min.js", () => {
+            mermaid.initialize({ startOnLoad: false });
+            mermaid.run({ querySelector: ".mermaid" });
+          });
+        `),
+        ) 
       );
     }
 
     return `A workflow! Step names: ${workflow_steps.map(
-      (s) => s.step_name
+      (s) => s.step_name,
     )}. Upgrade Saltcorn to see diagrams in copilot`;
   }
 

package/agent-skills/database-design.js

@@ -1,4 +1,5 @@
 const GenerateTables = require("../actions/generate-tables");
+const Table = require("@saltcorn/data/models/table");
 
 const normalizeTablesPayload = (rawPayload) => {
   if (!rawPayload) return { tables: [] };
@@ -68,18 +69,73 @@ const collectTableWarnings = (tables) => {
 
       if (!field?.type_and_configuration?.data_type)
         warnings.push(
-          `${tableLabel}.${fieldLabel} must include type_and_configuration.data_type.`
+          `${tableLabel}.${fieldLabel} must include type_and_configuration.data_type.`,
         );
 
       if ((field?.name || "").toLowerCase() === "id")
         warnings.push(
-          `${tableLabel}.${fieldLabel} should be omitted because every table already has an auto-increment id.`
+          `${tableLabel}.${fieldLabel} should be omitted because every table already has an auto-increment id.`,
         );
     });
   });
   return warnings;
 };
 
+const fetchExistingTableNameSet = async () => {
+  const existingTables = await Table.find({});
+  const names = new Set();
+  existingTables.forEach((table) => {
+    if (table?.name) names.add(table.name.toLowerCase());
+  });
+  return names;
+};
+
+const partitionTablesByExistence = async (tables = []) => {
+  const existingNames = await fetchExistingTableNameSet();
+  const seenNewNames = new Set();
+  const newTables = [];
+  const skippedExisting = [];
+  const skippedDuplicates = [];
+  tables.forEach((table) => {
+    const tableName =
+      typeof table?.table_name === "string" ? table.table_name.trim() : "";
+    const normalized = tableName.toLowerCase();
+    if (tableName && existingNames.has(normalized)) {
+      skippedExisting.push(tableName);
+      return;
+    }
+    if (tableName && seenNewNames.has(normalized)) {
+      skippedDuplicates.push(tableName);
+      return;
+    }
+    if (tableName) seenNewNames.add(normalized);
+    newTables.push(table);
+  });
+  return { newTables, skippedExisting, skippedDuplicates };
+};
+
+const partitionTablesByValidity = (tables = []) => {
+  const validTables = [];
+  const skippedMissingNames = [];
+  const skippedMissingFields = [];
+  tables.forEach((table, idx) => {
+    const rawName =
+      typeof table?.table_name === "string" ? table.table_name.trim() : "";
+    const fallbackLabel = rawName || `Table #${idx + 1}`;
+    if (!rawName) {
+      skippedMissingNames.push(fallbackLabel);
+      return;
+    }
+    const fields = Array.isArray(table?.fields) ? table.fields : [];
+    if (!fields.length) {
+      skippedMissingFields.push(rawName);
+      return;
+    }
+    validTables.push({ ...table, table_name: rawName, fields });
+  });
+  return { validTables, skippedMissingNames, skippedMissingFields };
+};
+
 const payloadFromToolCall = (tool_call) => {
   if (!tool_call) return { tables: [] };
   if (tool_call.input) return normalizeTablesPayload(tool_call.input);
@@ -96,79 +152,187 @@ class GenerateTablesSkill {
   }
 
   constructor(cfg) {
-    console.log("GenerateTablesSkill.constructor called", { cfg });
     Object.assign(this, cfg);
   }
 
   async systemPrompt() {
-    console.log("GenerateTablesSkill.systemPrompt called");
     return await GenerateTables.system_prompt();
   }
 
   get userActions() {
-    console.log("GenerateTablesSkill.userActions getter accessed");
     return {
       async apply_copilot_tables({ user, tables }) {
-        console.log("GenerateTablesSkill.userActions.apply_copilot_tables called", {
-          user_id: user?.id,
-          table_count: tables?.length,
-        });
         if (!tables?.length) return { notify: "Nothing to create." };
-        await GenerateTables.execute({ tables }, { user });
+        const { newTables, skippedExisting, skippedDuplicates } =
+          await partitionTablesByExistence(tables);
+        const { validTables, skippedMissingNames, skippedMissingFields } =
+          partitionTablesByValidity(newTables);
+        if (!validTables.length) {
+          const skippedMessages = [];
+          if (skippedExisting.length)
+            skippedMessages.push(
+              `Existing tables: ${skippedExisting.join(", ")}`,
+            );
+          if (skippedDuplicates.length)
+            skippedMessages.push(
+              `Duplicate definitions: ${skippedDuplicates.join(", ")}`,
+            );
+          if (skippedMissingNames.length)
+            skippedMessages.push(
+              `Missing table_name: ${skippedMissingNames.join(", ")}`,
+            );
+          if (skippedMissingFields.length)
+            skippedMessages.push(
+              `Tables without fields: ${skippedMissingFields.join(", ")}`,
+            );
+          return {
+            notify:
+              skippedMessages.length > 0
+                ? `Nothing to create. Skipped ${skippedMessages.join("; ")}.`
+                : "Nothing to create.",
+          };
+        }
+        await GenerateTables.execute({ tables: validTables }, { user });
+        const createdNames = validTables.map((t) => t.table_name).join(", ");
+        const skippedMessages = [];
+        if (skippedExisting.length)
+          skippedMessages.push(
+            `Skipped existing tables: ${skippedExisting.join(", ")}`,
+          );
+        if (skippedDuplicates.length)
+          skippedMessages.push(
+            `Ignored duplicate definitions: ${skippedDuplicates.join(", ")}`,
+          );
+        if (skippedMissingNames.length)
+          skippedMessages.push(
+            `Missing table_name: ${skippedMissingNames.join(", ")}`,
+          );
+        if (skippedMissingFields.length)
+          skippedMessages.push(
+            `Tables without fields: ${skippedMissingFields.join(", ")}`,
+          );
         return {
-          notify: `Created tables: ${tables.map((t) => t.table_name).join(", ")}`,
+          notify: [`Created tables: ${createdNames}`, ...skippedMessages].join(
+            ". ",
+          ),
         };
       },
     };
   }
 
   provideTools = () => {
-    console.log("GenerateTablesSkill.provideTools called");
     const parameters = GenerateTables.json_schema();
     return {
       type: "function",
       process: async (input) => {
         const payload = normalizeTablesPayload(input);
         const tables = payload.tables || [];
-        console.log("GenerateTablesSkill.provideTools.process called", {
-          table_count: tables.length,
-        });
-        if (!tables.length) return "No tables were provided for generate_tables.";
-        const summaryLines = summarizeTables(tables).map((line) => `- ${line}`);
+        if (!tables.length) {
+          return "No tables were provided for generate_tables.";
+        }
+        const { newTables, skippedExisting, skippedDuplicates } =
+          await partitionTablesByExistence(tables);
+        const { validTables, skippedMissingNames, skippedMissingFields } =
+          partitionTablesByValidity(newTables);
+        const summaryLines = validTables.length
+          ? summarizeTables(validTables).map((line) => `- ${line}`)
+          : [];
         const warnings = collectTableWarnings(tables);
+        if (skippedExisting.length)
+          skippedExisting.forEach((name) =>
+            warnings.push(
+              `Table "${name}" already exists and will not be recreated by generate_tables.`,
+            ),
+          );
+        if (skippedDuplicates.length)
+          skippedDuplicates.forEach((name) =>
+            warnings.push(
+              `Table "${name}" was defined multiple times in this request; only the first definition will be used.`,
+            ),
+          );
+        skippedMissingNames.forEach((label) =>
+          warnings.push(
+            `${label} is skipped because it does not include a table_name.`,
+          ),
+        );
+        skippedMissingFields.forEach((label) =>
+          warnings.push(
+            `Table "${label}" is skipped because it does not define any fields.`,
+          ),
+        );
         const warningLines = warnings.length
           ? ["Warnings:", ...warnings.map((w) => `- ${w}`)]
           : [];
+        const summarySection = summaryLines.length
+          ? [
+              `Ready to create ${validTables.length} new table${
+                validTables.length === 1 ? "" : "s"
+              }:`,
+              ...summaryLines,
+            ]
+          : [
+              "No new tables remain after removing existing, duplicate, or invalid table definitions.",
+            ];
         return [
-          `Received ${tables.length} table definition${tables.length === 1 ? "" : "s"}:`,
-          ...summaryLines,
+          `Received ${tables.length} table definition${tables.length === 1 ? "" : "s"}.`,
+          ...summarySection,
           ...warningLines,
         ].join("\n");
       },
       postProcess: async ({ tool_call }) => {
-        console.log("GenerateTablesSkill.provideTools.postProcess called", {
-          has_input: !!tool_call?.input,
-        });
         const payload = payloadFromToolCall(tool_call);
         const tables = payload.tables || [];
+        const { newTables, skippedExisting, skippedDuplicates } =
+          await partitionTablesByExistence(tables);
+        const { validTables, skippedMissingNames, skippedMissingFields } =
+          partitionTablesByValidity(newTables);
         let preview = "";
         try {
-          preview = GenerateTables.render_html({ tables });
+          if (validTables.length) {
+            preview = GenerateTables.render_html({ tables: validTables });
+          } else {
+            preview =
+              '<div class="alert alert-info">No new tables to preview because every provided table already exists or was invalid.</div>';
+          }
         } catch (e) {
+          console.log("We are in postProcess but rendering failed", {
+            e,
+            time: new Date(),
+          });
           preview = `<pre>${JSON.stringify(payload, null, 2)}</pre>`;
         }
+        const warningChunks = [];
+        if (skippedExisting.length)
+          warningChunks.push(
+            `Skipped existing tables: ${skippedExisting.join(", ")}`,
+          );
+        if (skippedDuplicates.length)
+          warningChunks.push(
+            `Ignored duplicate definitions: ${skippedDuplicates.join(", ")}`,
+          );
+        if (skippedMissingNames.length)
+          warningChunks.push(
+            `Missing table_name: ${skippedMissingNames.join(", ")}`,
+          );
+        if (skippedMissingFields.length)
+          warningChunks.push(
+            `Tables without fields: ${skippedMissingFields.join(", ")}`,
+          );
+        const warningHtml = warningChunks.length
+          ? `<div class="alert alert-warning">${warningChunks.join("<br/>")}</div>`
+          : "";
         return {
           stop: true,
-          add_response: preview,
+          add_response: `${warningHtml}${preview}`,
           add_user_action:
-            tables.length > 0
+            validTables.length > 0
               ? {
                   name: "apply_copilot_tables",
                   type: "button",
-                  label: `Create tables (${tables
+                  label: `Create tables (${validTables
                     .map((t) => t.table_name)
                     .join(", ")})`,
-                  input: { tables },
+                  input: { tables: validTables },
                 }
               : undefined,
         };

package/agent-skills/pagegen.js

@@ -33,7 +33,6 @@ class GeneratePageSkill {
   }
 
   constructor(cfg) {
-    console.log("GeneratePageSkill.constructor called", { cfg });
     Object.assign(this, cfg);
   }
 

package/agent-skills/workflow.js

@@ -0,0 +1,638 @@
+const Trigger = require("@saltcorn/data/models/trigger");
+const WorkflowStep = require("@saltcorn/data/models/workflow_step");
+const { getState } = require("@saltcorn/data/db/state");
+const GenerateWorkflow = require("../actions/generate-workflow");
+
+const table_triggers = ["Insert", "Update", "Delete", "Validate"];
+
+const TABLE_TRIGGER_WHEN = new Set(
+  Trigger.when_options.filter((opt) => table_triggers.includes(opt)),
+);
+const ALLOWED_WHEN = new Set(Trigger.when_options);
+
+const FALLBACK_ACTION_CATALOG = { namespaces: [], byName: {} };
+const ACTION_SUMMARY_LIMIT = 5;
+const ACTION_HTML_LIMIT = 12;
+const RANDOM_STEP_COUNT = { min: 2, max: 3 };
+const SIMPLE_FIELD_TYPES = new Set(["string", "number", "integer", "boolean"]);
+
+let workflowSchemaCache = null;
+let workflowSchemaLoading = null;
+let actionCatalogCache = null;
+
+const ensureWorkflowParameters = () => {
+  if (!workflowSchemaCache && !workflowSchemaLoading) {
+    workflowSchemaLoading = GenerateWorkflow.json_schema()
+      .then((schema) => {
+        workflowSchemaCache = schema;
+      })
+      .catch((error) => {
+        console.error("GenerateWorkflowSkill: failed to load schema", error);
+      })
+      .finally(() => {
+        workflowSchemaLoading = null;
+      });
+  }
+  //console.log({ workflowSchemaCache }, "Workflow schema load");
+  return workflowSchemaCache;
+};
+
+const defaultWorkflowPayload = () => ({
+  workflow_steps: [],
+  workflow_name: "",
+  when_trigger: "",
+  trigger_table: "",
+});
+
+const randomInt = (min, max) =>
+  Math.floor(Math.random() * (max - min + 1)) + min;
+
+const randomChoice = (items) =>
+  items.length ? items[randomInt(0, items.length - 1)] : undefined;
+
+const randomBool = () => Math.random() < 0.5;
+
+const generateWorkflowName = () =>
+  `Workflow ${Math.floor(Math.random() * 9000) + 1000}`;
+
+const sanitizeString = (value) =>
+  typeof value === "string" ? value.trim() : "";
+
+const buildActionCatalog = () => {
+  try {
+    const byName = {};
+    const namespaceMap = new Map();
+    const register = (name, namespace, description, origin) => {
+      const cleanName = sanitizeString(name);
+      if (!cleanName) return;
+      const cleanNamespace = sanitizeString(namespace) || "Other";
+      const entry = {
+        name: cleanName,
+        namespace: cleanNamespace,
+        description: sanitizeString(description),
+        origin: origin || "core",
+      };
+      if (byName[cleanName]) return;
+      byName[cleanName] = entry;
+      if (!namespaceMap.has(cleanNamespace))
+        namespaceMap.set(cleanNamespace, []);
+      namespaceMap.get(cleanNamespace).push(entry);
+    };
+
+    try {
+      const builtInExplain = WorkflowStep.builtInActionExplainers({
+        api_call: true,
+      });
+      Object.entries(builtInExplain).forEach(([name, description]) =>
+        register(name, "Workflow Actions", description, "built-in"),
+      );
+    } catch (error) {
+      console.error("GenerateWorkflowSkill: built-in actions failed", error);
+    }
+
+    try {
+      const state = getState?.();
+      const stateActions = state?.actions || {};
+      Object.entries(stateActions)
+        .filter(([_, action]) => !action.disableInWorkflow)
+        .forEach(([name, action]) =>
+          register(
+            name,
+            action.namespace || action.plugin_name || "Other",
+            action.description,
+            action.plugin_name || "core",
+          ),
+        );
+    } catch (error) {
+      console.error(
+        "GenerateWorkflowSkill: failed to read state actions",
+        error,
+      );
+    }
+
+    try {
+      const triggers = Trigger.find({
+        when_trigger: { or: ["API call", "Never"] },
+      });
+      triggers.forEach((tr) => {
+        const namespace = tr.action === "Workflow" ? "Workflows" : "Triggers";
+        register(tr.name, namespace, tr.description, "trigger");
+      });
+    } catch (error) {
+      console.error("GenerateWorkflowSkill: trigger lookup failed", error);
+    }
+
+    const namespaces = Array.from(namespaceMap.entries())
+      .map(([namespace, actions]) => ({
+        namespace,
+        label: namespace,
+        actions: actions.sort((a, b) => a.name.localeCompare(b.name)),
+      }))
+      .sort((a, b) => a.label.localeCompare(b.label));
+
+    return { byName, namespaces };
+  } catch (error) {
+    console.error("GenerateWorkflowSkill: action catalog failed", error);
+    return { namespaces: [], byName: {} };
+  }
+};
+
+const ensureActionCatalog = () => {
+  if (!actionCatalogCache) actionCatalogCache = buildActionCatalog();
+  return actionCatalogCache || FALLBACK_ACTION_CATALOG;
+};
+
+const summarizeActionCatalog = (limit = ACTION_SUMMARY_LIMIT) => {
+  const catalog = ensureActionCatalog();
+  if (!catalog.namespaces.length) return "";
+  return catalog.namespaces
+    .map(({ label, actions }) => {
+      const names = actions
+        .slice(0, limit)
+        .map((a) => a.name)
+        .join(", ");
+      const suffix = actions.length > limit ? " ..." : "";
+      return `${label}: ${names}${suffix}`;
+    })
+    .join("\n");
+};
+
+const toPlainObject = (value) =>
+  value && typeof value === "object" && !Array.isArray(value)
+    ? { ...value }
+    : {};
+
+const mergeStepConfiguration = (step) => {
+  const config = toPlainObject(step.step_configuration);
+  if (typeof config.step_type === "string")
+    config.step_type = sanitizeString(config.step_type);
+  else if (config.step_type != null)
+    config.step_type = sanitizeString(String(config.step_type));
+  else {
+    const fallbackType = sanitizeString(step.step_type);
+    if (fallbackType) config.step_type = fallbackType;
+  }
+  const reserved = new Set([
+    "step_name",
+    "only_if",
+    "next_step",
+    "step_configuration",
+    "step_type",
+  ]);
+  Object.entries(step || {}).forEach(([key, value]) => {
+    if (reserved.has(key)) return;
+    if (config[key] === undefined) config[key] = value;
+  });
+  return config;
+};
+
+const normalizeWorkflowPayload = (rawPayload) => {
+  if (!rawPayload) return defaultWorkflowPayload();
+  let payload = rawPayload;
+  if (typeof payload === "string") {
+    try {
+      payload = JSON.parse(payload);
+    } catch (error) {
+      console.error("GenerateWorkflowSkill: failed to parse payload", error);
+      return defaultWorkflowPayload();
+    }
+  }
+  if (typeof payload !== "object" || Array.isArray(payload))
+    return defaultWorkflowPayload();
+  const normalizedSteps = Array.isArray(payload.workflow_steps)
+    ? payload.workflow_steps.filter(Boolean).map((step) => {
+        const plain = toPlainObject(step);
+        const step_configuration = mergeStepConfiguration(plain);
+        return {
+          step_name: sanitizeString(plain.step_name || plain.name),
+          only_if: sanitizeString(plain.only_if),
+          next_step: sanitizeString(plain.next_step),
+          step_configuration,
+        };
+      })
+    : [];
+  const normalized = {
+    workflow_steps: normalizedSteps,
+    workflow_name: sanitizeString(payload.workflow_name),
+    trigger_table: sanitizeString(payload.trigger_table),
+    when_trigger: ALLOWED_WHEN.has(payload.when_trigger)
+      ? payload.when_trigger
+      : "",
+  };
+  if (!normalized.when_trigger) normalized.when_trigger = "Never";
+  if (
+    normalized.when_trigger !== "Never" &&
+    !ALLOWED_WHEN.has(normalized.when_trigger)
+  )
+    normalized.when_trigger = "Never";
+  return normalized;
+};
+
+const analyzeWorkflowPayload = (payload) => {
+  const warnings = [];
+  const blocking = [];
+  const actionCatalog = ensureActionCatalog();
+  if (!payload.workflow_name) blocking.push("Workflow name is required.");
+  if (!payload.workflow_steps.length)
+    blocking.push("At least one workflow step is required.");
+  const seenNames = new Set();
+  const identifierStyle = /^[A-Za-z_][0-9A-Za-z_]*$/;
+  const knownTargets = new Set(
+    payload.workflow_steps.map((s) => s.step_name).filter(Boolean),
+  );
+  payload.workflow_steps.forEach((step, idx) => {
+    const label = step.step_name || `Step #${idx + 1}`;
+    if (!step.step_name) blocking.push(`${label} is missing step_name.`);
+    else if (seenNames.has(step.step_name))
+      blocking.push(`Duplicate step_name "${step.step_name}".`);
+    else seenNames.add(step.step_name);
+    const cfg = step.step_configuration;
+    if (!cfg || typeof cfg !== "object" || Array.isArray(cfg))
+      blocking.push(`${label} is missing step_configuration.`);
+    else {
+      const stepType = sanitizeString(cfg.step_type);
+      if (!stepType)
+        blocking.push(`${label} must specify step_configuration.step_type.`);
+      else if (!actionCatalog.byName[stepType])
+        warnings.push(`${label} uses unknown action "${stepType}".`);
+    }
+    const next = sanitizeString(step.next_step);
+    if (next && identifierStyle.test(next) && !knownTargets.has(next))
+      warnings.push(`${label} references unknown next_step "${next}".`);
+  });
+  if (TABLE_TRIGGER_WHEN.has(payload.when_trigger) && !payload.trigger_table)
+    blocking.push(`${payload.when_trigger} triggers require a trigger_table.`);
+  if (!TABLE_TRIGGER_WHEN.has(payload.when_trigger) && payload.trigger_table)
+    warnings.push(
+      `Trigger table "${payload.trigger_table}" will be ignored unless when_trigger is ${Array.from(TABLE_TRIGGER_WHEN).join("/")}.`,
+    );
+  return { warnings, blocking };
+};
+
+const describeWorkflow = (payload) => {
+  const title = payload.workflow_name || "Unnamed workflow";
+  const triggerDescription = TABLE_TRIGGER_WHEN.has(payload.when_trigger)
+    ? payload.trigger_table
+      ? `${payload.when_trigger} on ${payload.trigger_table}`
+      : `${payload.when_trigger} (table not set)`
+    : payload.when_trigger === "Never" || !payload.when_trigger
+      ? "Manual run (Never)"
+      : payload.when_trigger;
+  const stepLines = payload.workflow_steps.length
+    ? payload.workflow_steps.map((step, idx) =>
+        formatStepDescription(step, idx),
+      )
+    : ["(no steps provided)"];
+  return [
+    `${title} – trigger: ${triggerDescription}`,
+    "Steps:",
+    ...stepLines,
+  ].join("\n");
+};
+
+const escapeHtml = (str) =>
+  String(str || "")
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+
+const buildIssuesHtml = ({ warnings, blocking }) => {
+  const chunks = [];
+  if (blocking.length) {
+    const items = blocking
+      .map((issue) => `<li>${escapeHtml(issue)}</li>`)
+      .join("");
+    chunks.push(
+      `<div class="alert alert-danger"><strong>Blocking issues</strong><ul class="mb-0">${items}</ul></div>`,
+    );
+  }
+  if (warnings.length) {
+    const items = warnings
+      .map((issue) => `<li>${escapeHtml(issue)}</li>`)
+      .join("");
+    chunks.push(
+      `<div class="alert alert-warning"><strong>Warnings</strong><ul class="mb-0">${items}</ul></div>`,
+    );
+  }
+  return chunks.join("");
+};
+
+const renderWorkflowPreview = (payload) => {
+  if (!payload.workflow_steps.length) return "";
+  try {
+    return GenerateWorkflow.render_html(payload);
+  } catch (error) {
+    console.error("GenerateWorkflowSkill: preview failed", error);
+    return `<pre>${escapeHtml(JSON.stringify(payload, null, 2))}</pre>`;
+  }
+};
+
+const formatIssueSection = (label, issues) =>
+  issues.length
+    ? [label, ...issues.map((issue) => `- ${issue}`)].join("\n")
+    : `${label}: none`;
+
+const payloadFromToolCall = (tool_call) => {
+  if (!tool_call) return normalizeWorkflowPayload();
+  if (Object.prototype.hasOwnProperty.call(tool_call, "input"))
+    return normalizeWorkflowPayload(tool_call.input);
+  if (
+    tool_call.function &&
+    Object.prototype.hasOwnProperty.call(tool_call.function, "arguments")
+  )
+    return normalizeWorkflowPayload(tool_call.function.arguments);
+  return normalizeWorkflowPayload();
+};
+
+const buildEmptyStateText = () =>
+  [
+    "No workflow steps were generated yet.",
+    "Describe what the workflow should do (even at a high level) and run the tool again—I'll turn that into concrete steps automatically.",
+  ].join("\n\n");
+
+const buildEmptyStateHtml = () =>
+  '<div class="alert alert-info">No steps yet. Tell me what should happen in the workflow (simple or detailed) and rerun the generate_workflow tool—I will draft the steps for you.</div>';
+
+const getStepConfigurationSchemas = () => {
+  ensureWorkflowParameters();
+  const schema = workflowSchemaCache;
+  const stepConfig =
+    schema?.properties?.workflow_steps?.items?.properties?.step_configuration;
+  return Array.isArray(stepConfig?.anyOf) ? stepConfig.anyOf : [];
+};
+
+const isSimpleDescriptor = (descriptor) => {
+  if (!descriptor) return false;
+  if (Array.isArray(descriptor.enum) && descriptor.enum.length) return true;
+  const type = descriptor.type;
+  return SIMPLE_FIELD_TYPES.has(type);
+};
+
+const isSupportedActionSchema = (actionSchema) => {
+  if (!actionSchema || typeof actionSchema !== "object") return false;
+  const props = actionSchema.properties || {};
+  const typeField = props.step_type;
+  if (!typeField || !Array.isArray(typeField.enum) || !typeField.enum.length)
+    return false;
+  const requiredFields = (actionSchema.required || []).filter(
+    (field) => field !== "step_type",
+  );
+  return requiredFields.every((field) => isSimpleDescriptor(props[field]));
+};
+
+const buildValueForDescriptor = (name, descriptor, idx) => {
+  if (!descriptor) return undefined;
+  if (Array.isArray(descriptor.enum) && descriptor.enum.length)
+    return randomChoice(descriptor.enum);
+  switch (descriptor.type) {
+    case "string":
+      return descriptor.default || `${name}_${idx + 1}`;
+    case "integer":
+    case "number":
+      if (typeof descriptor.default === "number") return descriptor.default;
+      return randomInt(1, 10);
+    case "boolean":
+      return randomBool();
+    default:
+      return undefined;
+  }
+};
+
+const generateConfigFromSchema = (actionSchema, idx) => {
+  const props = actionSchema?.properties || {};
+  const stepTypeEnum = props.step_type?.enum;
+  if (!Array.isArray(stepTypeEnum) || !stepTypeEnum.length) return null;
+  const config = { step_type: stepTypeEnum[0] };
+  const requiredFields = (actionSchema.required || []).filter(
+    (field) => field !== "step_type",
+  );
+  for (const field of requiredFields) {
+    const descriptor = props[field];
+    const value = buildValueForDescriptor(field, descriptor, idx);
+    if (value === undefined) return null;
+    config[field] = value;
+  }
+  return config;
+};
+
+const buildRunJsFallbackSteps = (count = 2) => {
+  const catalog = ensureActionCatalog();
+  const hasRunJs = Boolean(catalog.byName["run_js_code"]);
+  const actionName = hasRunJs
+    ? "run_js_code"
+    : Object.keys(catalog.byName)[0] || "run_js_code";
+  const steps = [];
+  for (let i = 0; i < count; i += 1) {
+    const stepName = `step_${i + 1}`;
+    const config = { step_type: actionName };
+    if (actionName === "run_js_code") {
+      config.run_where = "Server";
+      config.code = `return { auto_message_${i + 1}: "Step ${i + 1} executed" };`;
+    }
+    steps.push({
+      step_name: stepName,
+      only_if: "",
+      next_step: "",
+      step_configuration: config,
+    });
+  }
+  steps.forEach((step, idx) => {
+    step.next_step = idx < steps.length - 1 ? steps[idx + 1].step_name : "";
+  });
+  return steps;
+};
+
+const buildRandomWorkflowSteps = () => {
+  const availableSchemas = getStepConfigurationSchemas().filter((schema) =>
+    isSupportedActionSchema(schema),
+  );
+  const desiredSteps = randomInt(RANDOM_STEP_COUNT.min, RANDOM_STEP_COUNT.max);
+  const steps = [];
+  let guard = desiredSteps * 3;
+  while (steps.length < desiredSteps && guard > 0) {
+    guard -= 1;
+    const schema = randomChoice(availableSchemas);
+    if (!schema) break;
+    const config = generateConfigFromSchema(schema, steps.length);
+    if (!config) continue;
+    steps.push({
+      step_name: `step_${steps.length + 1}`,
+      only_if: "",
+      next_step: "",
+      step_configuration: config,
+    });
+  }
+  if (!steps.length) return buildRunJsFallbackSteps(desiredSteps);
+  steps.forEach((step, idx) => {
+    step.next_step = idx < steps.length - 1 ? steps[idx + 1].step_name : "";
+  });
+  return steps;
+};
+
+const ensureWorkflowHasSteps = (payload) => {
+  if (payload.workflow_steps.length) return payload;
+  const seeded = {
+    ...payload,
+    workflow_steps: buildRandomWorkflowSteps(),
+    workflow_name: payload.workflow_name || generateWorkflowName(),
+    when_trigger: payload.when_trigger || "Never",
+  };
+  return seeded.workflow_steps.length
+    ? normalizeWorkflowPayload(seeded)
+    : payload;
+};
+
+const summarizeConfigValue = (value) => {
+  if (value === null || value === undefined) return "null";
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return '""';
+    return trimmed.length > 70 ? `${trimmed.slice(0, 67)}...` : trimmed;
+  }
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  try {
+    const json = JSON.stringify(value);
+    return json.length > 70 ? `${json.slice(0, 67)}...` : json;
+  } catch (error) {
+    console.error("GenerateWorkflowSkill: config summary failed", error);
+    return "[complex value]";
+  }
+};
+
+const describeStepSettings = (step) => {
+  const items = [];
+  if (step.only_if) items.push(`only_if=${step.only_if}`);
+  if (step.next_step) items.push(`next=${step.next_step}`);
+  return items.length ? items.join("; ") : "defaults";
+};
+
+const describeActionSettings = (config) => {
+  if (!config) return "defaults";
+  const pairs = Object.entries(config).filter(([key]) => key !== "step_type");
+  if (!pairs.length) return "defaults";
+  return pairs
+    .map(([key, value]) => `${key}=${summarizeConfigValue(value)}`)
+    .join("; ");
+};
+
+const formatStepDescription = (step, idx) => {
+  const actionCatalog = ensureActionCatalog();
+  const stepName = step.step_name || `Step ${idx + 1}`;
+  const actionName = sanitizeString(step.step_configuration?.step_type) || "?";
+  const actionMeta = actionCatalog.byName[actionName];
+  const namespaceLabel = actionMeta?.namespace || "Unknown group";
+  const extraInfo = actionMeta?.description
+    ? ` – ${actionMeta.description}`
+    : "";
+  const settings = describeStepSettings(step);
+  const actionSettings = describeActionSettings(step.step_configuration);
+  return [
+    `${idx + 1}. ${stepName}`,
+    `   Step settings: ${settings}`,
+    `   Action: ${actionName} (${namespaceLabel})${extraInfo}`,
+    `   Action settings: ${actionSettings}`,
+  ].join("\n");
+};
+
+class GenerateWorkflowSkill {
+  static skill_name = "Generate Workflow";
+
+  get skill_label() {
+    return "Generate Workflow";
+  }
+
+  constructor(cfg) {
+    Object.assign(this, cfg);
+    ensureWorkflowParameters();
+    ensureActionCatalog();
+  }
+
+  async systemPrompt() {
+    return await GenerateWorkflow.system_prompt();
+  }
+
+  get userActions() {
+    return {
+      async apply_copilot_workflow({ user, ...raw }) {
+        const payload = ensureWorkflowHasSteps(normalizeWorkflowPayload(raw));
+        const analysis = analyzeWorkflowPayload(payload);
+        if (analysis.blocking.length)
+          return {
+            notify: `Cannot create workflow: ${analysis.blocking.join("; ")}`,
+          };
+        const result = await GenerateWorkflow.execute(payload, { user });
+        return {
+          notify:
+            result?.postExec ||
+            `Workflow created: ${payload.workflow_name || "(unnamed)"}`,
+        };
+      },
+    };
+  }
+
+  provideTools = () => {
+    const parameters = ensureWorkflowParameters();
+    return {
+      type: "function",
+      process: async (input) => {
+        const payload = normalizeWorkflowPayload(input);
+        const preparedPayload = ensureWorkflowHasSteps(payload);
+        const hasSteps = preparedPayload.workflow_steps.length > 0;
+        if (!hasSteps) return buildEmptyStateText();
+        const analysis = analyzeWorkflowPayload(preparedPayload);
+        const summary = describeWorkflow(preparedPayload);
+        const actionSummary = summarizeActionCatalog();
+        const sections = [
+          summary,
+          formatIssueSection("Blocking issues", analysis.blocking),
+          formatIssueSection("Warnings", analysis.warnings),
+        ];
+        if (actionSummary) sections.push(`Action palette:\n${actionSummary}`);
+        return sections.join("\n\n");
+      },
+      postProcess: async ({ tool_call }) => {
+        const payload = payloadFromToolCall(tool_call);
+        const preparedPayload = ensureWorkflowHasSteps(payload);
+        const hasSteps = preparedPayload.workflow_steps.length > 0;
+        if (!hasSteps)
+          return {
+            stop: true,
+            add_response: buildEmptyStateHtml(),
+          };
+        const analysis = analyzeWorkflowPayload(preparedPayload);
+        const issuesHtml = buildIssuesHtml(analysis);
+        const previewHtml = renderWorkflowPreview(preparedPayload);
+        const canCreate =
+          analysis.blocking.length === 0 &&
+          preparedPayload.workflow_steps.length > 0;
+        return {
+          stop: true,
+          add_response: `${issuesHtml}${previewHtml}`,
+          add_user_action: canCreate
+            ? {
+                name: "apply_copilot_workflow",
+                type: "button",
+                label: `Create workflow ${
+                  preparedPayload.workflow_name || "(unnamed)"
+                }`,
+                input: preparedPayload,
+              }
+            : undefined,
+        };
+      },
+      function: {
+        name: GenerateWorkflow.function_name,
+        description: GenerateWorkflow.description,
+        parameters,
+      },
+    };
+  };
+}
+
+ensureWorkflowParameters();
+ensureActionCatalog();
+
+module.exports = GenerateWorkflowSkill;

package/builder-gen.js

@@ -6,15 +6,26 @@ const { getActionConfigFields } = require("@saltcorn/data/plugin-helper");
 
 module.exports = {
   run: async (prompt, mode, table) => {
-    await new Promise((resolve) => {
-      setTimeout(resolve, 5000);
-    });
+    const str = await getState().functions.llm_generate.run(
+      `Generate an HTML snippet according to the requirement below. Your snippet will be 
+placed inside a page which has loaded the Bootstrap 5 CSS framework, so you can use any 
+Bootstrap 5 classes.
+
+If you need to run javascript in script tag that depends on external reosurces, you wrap this
+in a DOMContentLoaded event handler as external javascript resources may be loaded after your HTML snippet is included.
+
+Include only the HTML snippet with no explanation before or after the code snippet.
+      
+Generate the HTML5 snippet for this request: ${prompt}
+`,
+    );
+    const strHtml = str.includes("```html")
+      ? str.split("```html")[1].split("```")[0]
+      : str;
     return {
       type: "blank",
       isHTML: true,
-      contents: `<h4>Placeholder copilot response</h4>
-      <blockquote class="blockquote"><p>${prompt}</p></blockquote>
-      <pre>mode=${mode} table=${table}</pre>`,
+      contents: strHtml,
       text_strings: [],
     };
   },

package/chat-copilot.js

@@ -121,7 +121,6 @@ const runLegacy = async (table_id, viewname, cfg, state, { res, req }) => {
       r.context.interactions &&
       (r.context.copilot === "_system" || !r.context.copilot)
   );
-  console.log({prevRuns})
   const cfgMsg = incompleteCfgMsg();
   if (cfgMsg) return cfgMsg;
   let runInteractions = "";
@@ -370,7 +369,6 @@ const run = async (table_id, viewname, cfg, state, extra) => {
     configuration: agentCfg,
     min_role: 100,
   });
-  console.log({agentView})
   return await agentView.run(state, extra);
 };
 

package/copilot-as-agent.js

@@ -32,25 +32,29 @@ const { getState } = require("@saltcorn/data/db/state");
 const get_state_fields = () => [];
 
 const sys_prompt = ``;
+const viewname = "Saltcorn Agent copilot";
 
 const get_agent_view = () => {
   const agent_action = new Trigger({
     action: "Agent",
     when_trigger: "Never",
     configuration: {
+      viewname,
       sys_prompt,
       skills: [
         { skill_type: "Generate Page" },
         { skill_type: "Database design" },
+        { skill_type: "Generate Workflow" },
       ],
     },
   });
   return new View({
     viewtemplate: "Agent Chat",
-    name: "Saltcorn Agent copilot",
+    name: viewname,
     min_role: 1,
     configuration: {
       agent_action,
+      viewname,
     },
   });
 };
@@ -64,12 +68,23 @@ const interact = async (table_id, viewname, config, body, reqres) => {
   return await view.runRoute("interact", body, reqres.res, reqres);
 };
 
+const execute_user_action = async (
+  table_id,
+  viewname,
+  config,
+  body,
+  reqres,
+) => {
+  const view = get_agent_view();
+  return await view.runRoute("execute_user_action", body, reqres.res, reqres);
+};
+
 module.exports = {
-  name: "Saltcorn Agent copilot",
+  name: viewname,
   display_state_form: false,
   get_state_fields,
   tableless: true,
   singleton: true,
   run,
-  routes: { interact },
+  routes: { interact, execute_user_action },
 };

package/index.js

@@ -23,6 +23,7 @@ module.exports = {
     agent_skills: [
       require("./agent-skills/pagegen.js"),
       require("./agent-skills/database-design.js"),
+      require("./agent-skills/workflow.js"),
     ],
   },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saltcorn/copilot",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "AI assistant for building Saltcorn applications",
   "main": "index.js",
   "dependencies": {

package/page-gen-action.js

@@ -126,10 +126,6 @@ const upsertHtmlPreviewPage = async (name, html, title, description, user) => {
 module.exports = {
   description: "Generate page with AI copilot",
   configFields: ({ table, mode }) => {
-    console.log({
-      table,
-      mode,
-    }, "OOOOOOOOOO");
     if (mode === "workflow") {
       return [
         {
@@ -210,7 +206,6 @@ module.exports = {
         },
       ];
     } else if (table) {
-      console.log(JSON.stringify(table, null, 2), "TABLE");
       const textFields = table.fields
         .filter((f) => f.type?.sql_name === "text")
         .map((f) => f.name);