@saltcorn/copilot 0.8.0 → 0.8.1

package/app-constructor/tasks.js

@@ -4,6 +4,8 @@ const Form = require("@saltcorn/data/models/form");
 const MetaData = require("@saltcorn/data/models/metadata");
 const View = require("@saltcorn/data/models/view");
 const Trigger = require("@saltcorn/data/models/trigger");
+const Page = require("@saltcorn/data/models/page");
+const Plugin = require("@saltcorn/data/models/plugin");
 const { findType } = require("@saltcorn/data/models/discovery");
 const { save_menu_items } = require("@saltcorn/data/models/config");
 const db = require("@saltcorn/data/db");
@@ -35,10 +37,15 @@ const {
 } = require("@saltcorn/markup/tags");
 const { getState } = require("@saltcorn/data/db/state");
 const renderLayout = require("@saltcorn/markup/layout");
-const { viewname, tool_choice } = require("./common");
+const { viewname } = require("./common");
 const { runTask, runNextTask } = require("./run_task");
 const { task_tool } = require("./tools");
-const { saltcorn_description, existing_tables_list } = require("./prompts");
+const {
+  saltcorn_description,
+  existing_tables_list,
+  existing_entities_list,
+  available_plugins_list,
+} = require("./prompts");
 
 const makeTaskList = async (req) => {
   const rs = await MetaData.find(
@@ -191,6 +198,34 @@ const makeTaskList = async (req) => {
       )
     );
   } else {
+    const planning = await MetaData.findOne({
+      type: "CopilotConstructMgr",
+      name: "planning",
+    });
+    if (planning) {
+      return div(
+        { class: "mt-2" },
+        p(
+          i({ class: "fas fa-spinner fa-spin me-2" }),
+          "Planning tasks, please wait..."
+        ),
+        script(
+          domReady(`
+(function() {
+  function poll() {
+    view_post(${JSON.stringify(
+      viewname
+    )}, 'planning_status', {}, function(resp) {
+      if (resp && !resp.planning) location.reload();
+      else setTimeout(poll, 3000);
+    });
+  }
+  setTimeout(poll, 3000);
+})();
+`)
+        )
+      );
+    }
     return div(
       { class: "mt-2" },
       p("No tasks found"),
@@ -205,27 +240,59 @@ const makeTaskList = async (req) => {
   }
 };
 
-const gen_tasks = async (table_id, viewname, config, body, { req, res }) => {
-  const spec = await MetaData.findOne({
-    type: "CopilotConstructMgr",
-    name: "spec",
-  });
-  if (!spec) throw new Error("Specification not found");
-  const rs = await MetaData.find({
-    type: "CopilotConstructMgr",
-    name: "requirement",
-  });
-  if (!rs.length) throw new Error("No requirements found");
-  const schema = await MetaData.findOne({
+const get_view_config_tool = {
+  type: "function",
+  function: {
+    name: "get_view_config",
+    description:
+      "Fetch the full configuration of an existing view so you can decide whether to reuse it or create a new one. Call this before planning a task if you are unsure whether an existing view already meets the requirements.",
+    parameters: {
+      type: "object",
+      required: ["name"],
+      properties: {
+        name: {
+          type: "string",
+          description: "The exact name of the existing view to inspect.",
+        },
+      },
+    },
+  },
+};
+
+const doGenTasks = async (spec, rs, schema, userId) => {
+  const planningMd = await MetaData.create({
     type: "CopilotConstructMgr",
-    name: "schema",
+    name: "planning",
+    body: {},
   });
-  if (!schema) throw new Error("No schema found");
-  if (!schema.body.implemented) throw new Error("Schema not implemented");
-  const tables = await Table.find({});
+  try {
+    const tables = await Table.find({});
+    const tableById = Object.fromEntries(tables.map((t) => [t.id, t.name]));
+    const views = await View.find({});
+    const triggers = await Trigger.find({});
+    const pages = await Page.find({});
+    const entitiesSection = existing_entities_list({
+      views,
+      triggers,
+      pages,
+      tableById,
+    });
+    const installedPlugins = await Plugin.find({});
+    const installedNames = new Set(installedPlugins.map((p) => p.name));
+    let storePlugins = [];
+    try {
+      storePlugins = await Plugin.store_plugins_available();
+    } catch (_) {}
+    const pluginsSection = available_plugins_list(storePlugins, installedNames);
 
-  const answer = await getState().functions.llm_generate.run(
-    `Generate a plan for building this application:
+    const systemPrompt =
+      "You are a project manager. The user wants to build an application, and you must analyse their application description";
+
+    const tools = [get_view_config_tool, task_tool];
+    const chat = [];
+
+    let answer = await getState().functions.llm_generate.run(
+      `Generate a plan for building this application:
 
 Description: ${spec.body.description}
 Audience: ${spec.body.audience}
@@ -233,7 +300,7 @@ Core features: ${spec.body.core_features}
 Out of scope: ${spec.body.out_of_scope}
 Visual style: ${spec.body.visual_style}
 
-These are the requirements of the application: 
+These are the requirements of the application:
 
 ${rs.map((r) => `* ${r.body.requirement}`).join("\n")}
 
@@ -243,55 +310,159 @@ The database has already been built. The following tables are now present in the
 
 ${existing_tables_list(tables)}
 
-The plan should outline the continued development of the application on top of this database. 
-Your plan can add additional tables if needed or adjust the table fields, but normally the tables 
-should be designed optimally for this application. 
+The plan should outline the continued development of the application on top of this database.
+Your plan can add additional tables if needed or adjust the table fields, but normally the tables
+should be designed optimally for this application.
+
+${entitiesSection ? entitiesSection + "\n\n" : ""}${
+        pluginsSection ? pluginsSection + "\n\n" : ""
+      }The plan should focus on building views, triggers (including workflows) and pages.
 
-The plan should focus on building views, triggers (including workflows) and pages.
+Important trigger planning rules:
+* When a task involves a simple field update (e.g. marking an item complete or incomplete), plan it as a trigger using modify_row — NOT a workflow. Use a workflow only when multiple steps, branching, or looping are genuinely required.
+* If multiple independent single-step actions are needed (e.g. "mark complete" and "mark incomplete"), describe them as separate triggers in the task description — do not describe them as one combined workflow.
+* Do NOT mention "navigate back" or "return to context" in trigger task descriptions. Navigation is configured at the view level (GoBack button), not inside a trigger.
+* If a trigger should be accessible as a button in a view, the task description must name the target view and say to add an action segment with action_name set to the trigger's name. If the view already exists, combine trigger creation and view update in the same task. If the view is created in a later task, that task's description must mention adding the trigger button, and it must depend on the trigger task.
+* Do NOT plan any task that writes to a virtual (read-only) calculated field. Virtual fields are computed automatically and cannot be stored — any trigger or workflow that tries to update them will be refused. If you find yourself planning a trigger to keep a calculated field "current", delete that task — the field already updates itself.
 
 Important view planning rules:
-* Do NOT plan separate tasks for "create" and "edit" on the same table. In Saltcorn, a single Edit view handles both (no id = create, id present = edit). Plan one task covering both, and write task descriptions that say "create and edit" rather than treating them as two separate items.
+* Each task must create exactly one view. Never put two or more views in the same task. Edit, Show, and List for the same table are always three separate tasks with three separate names, descriptions, and dependencies.
+* Do NOT plan separate tasks for "create" and "edit" on the same table. In Saltcorn, a single Edit view handles both (no id = create, id present = edit). One task, one Edit view, description says "create and edit".
+* Edit, Show, and List views for a table form a natural group and should normally each be planned as their own task. A List without a Show leaves users with no way to inspect details; omit or adjust only when the requirements explicitly say the data is read-only or not editable. When all three are planned, the ordering of tasks must be: Edit and Show first (in either order, they are independent of each other), then List last, because the List depends on both.
+* A List view task must depend on the Edit view task and the Show view task for the same table (if both exist), since its rows link to them. Set depends_on accordingly.
+* When a List view links to a Show view or Edit view, the task description must say: "Add a viewlink column to [view_name] for the current row" — not just "link each row". This wording makes it unambiguous that a viewlink column must be added to the list for each target view.
+* In general, if a view embeds or links to another view, the linked view's task must be listed as a dependency.
 * When a table has foreign key fields referencing the users table, the task description must explicitly state for each one whether it is an ownership field (automatically set from the logged-in user, omit from the form) or a selector field (the user picks a value, include a selector in the form). Example: "user_id records the owner and is set automatically; shared_with_user_id must have a user selector."
 * For FK fields that represent a parent context (e.g. trip_id on packing_items), always include the field as a normal selector in the Edit view form. Do NOT say to omit it. Saltcorn automatically pre-fills the selector from the URL query parameter when the view is opened from a parent context, and the user can select it manually when the view is used standalone.
-* A List view that includes an edit link (viewlink column pointing to an Edit view) depends on that Edit view already existing. Always plan the Edit view task before the List view task, and set the List view task's depends_on to include the Edit view task name.
-* If a List view includes a viewlink to show record details (a Show view), the Show view must be created as a separate task before the List view task, and the List view task must depend on it. A Show view is a distinct viewtemplate — do NOT use an Edit view or a page as a substitute for it. The Show view and Edit view for the same table are independent — neither depends on the other; they can be planned in any order or in parallel.
-* In general, if a view embeds or links to another view, the linked view must be created first and listed as a dependency.
+* For every task that creates a view, include the exact view name in the task description. View names must be lowercase, snake_case, unique across all tasks in the plan, and descriptive enough to identify the table and purpose — for example 'packing_items_edit' rather than just 'edit'.
 
-* For every task that creates a view, include the exact view name in the task description. View names must be lowercase, snake_case, unique across all tasks in the plan (no two tasks may produce a view with the same name), and descriptive enough to identify the table and purpose — for example 'packing_items_edit' rather than just 'edit'.
+Important user account rules:
+* The platform (Saltcorn) provides a built-in user account system with login, registration, and session management. Do NOT plan any tasks for user registration, login pages, password management, or authentication flows — these are already handled by the platform.
+* User identity is always available as the logged-in user. Ownership fields (FK to users) are set automatically from the session; no custom logic is needed.
+* If a requirement mentions "user accounts", "secure login", "saving data per user", "user-specific data", or "sharing between users", treat it as already satisfied by the platform's built-in user system. Do not generate any task in response to such a requirement.
+
+Important plugin rules:
+* If multiple plugins need to be installed, combine them ALL into a single task named "Install plugins" that lists every required plugin name. Do NOT create a separate task per plugin.
 
 Important schema/table rules:
 * The database schema is already fully designed and implemented before task planning begins. ALL tables and fields needed by the application already exist. Do NOT plan any tasks that create tables, add fields, modify fields, or change the schema in any way. If you find yourself writing a task whose output is a table or a field, delete it — that work is already done.
 * Ownership behaviour (auto-setting a FK-to-users field from the logged-in user) is configured in the Edit view, not in the database. Do not create tasks for it at the schema level.
 * Do NOT plan tasks to add uniqueness constraints or validation to existing fields — those are already in the schema.
+* Do NOT plan a standalone task for "access control", "row-level security", "permissions", or "roles". These are schema-level concerns already handled during schema design, or view-level concerns handled when building each view. The ownership field and sharing logic are already in the schema — there is nothing extra to configure as a separate task.
 
-Your plan should not include any clarification or questions to the product owner. The 
-information you have been given so far is all that is available. Every step in the plan 
+Your plan should not include any clarification or questions to the product owner. The
+information you have been given so far is all that is available. Every step in the plan
 should be immediately implementable in Saltcorn. You are writing the steps in the plan
 for a person who is competent in using saltcorn but has no other business knowledge.
 
 Do not include any steps that contain planning, design or review instructions. You are only writing a
 plan for the engineer building the application. Every step in the plan should have the construction or the modification
-of one or several application entity types. 
+of one or several application entity types.
 
-Now use the plan_tasks tool to make a plan of tasks for building software application
+Before finalising the plan, you may call get_view_config for any existing view you are unsure about — to inspect its configuration and decide whether a task should reuse it (updating it) or create a new one. Once you have gathered all necessary information, call plan_tasks to submit the complete task list.
 `,
-    {
-      tools: [task_tool],
-      ...tool_choice("plan_tasks"),
-      systemPrompt:
-        "You are a project manager. The user wants to build an application, and you must analyse their application description",
-    }
-  );
+      {
+        tools,
+        chat,
+        appendToChat: true,
+        systemPrompt,
+      }
+    );
 
-  const tc = answer.getToolCalls()[0];
+    const MAX_ITERATIONS = 10;
+    let iterations = 0;
 
-  for (const task of tc.input.tasks)
-    await MetaData.create({
-      type: "CopilotConstructMgr",
-      name: "task",
-      body: task,
-      user_id: req.user?.id,
-    });
+    while (iterations++ < MAX_ITERATIONS) {
+      if (typeof answer !== "object" || !answer.getToolCalls) break;
+      const toolCalls = answer.getToolCalls();
+      if (!toolCalls.length) break;
+
+      const planCall = toolCalls.find((tc) => tc.tool_name === "plan_tasks");
+      if (planCall) {
+        for (const task of planCall.input.tasks)
+          await MetaData.create({
+            type: "CopilotConstructMgr",
+            name: "task",
+            body: task,
+            user_id: userId,
+          });
+        break;
+      }
+
+      const getViewCalls = toolCalls.filter(
+        (tc) => tc.tool_name === "get_view_config"
+      );
+      if (!getViewCalls.length) break;
+
+      for (const tc of getViewCalls) {
+        const viewName = tc.input?.name;
+        const view = viewName ? await View.findOne({ name: viewName }) : null;
+        const result = view
+          ? JSON.stringify(
+              {
+                name: view.name,
+                viewtemplate: view.viewtemplate,
+                configuration: view.configuration,
+              },
+              null,
+              2
+            )
+          : `No view named "${viewName}" found.`;
+
+        if (answer.ai_sdk) {
+          chat.push({
+            role: "tool",
+            content: [
+              {
+                type: "tool-result",
+                toolCallId: tc.tool_call_id,
+                toolName: "get_view_config",
+                result,
+              },
+            ],
+          });
+        } else {
+          chat.push({
+            role: "tool",
+            tool_call_id: tc.tool_call_id,
+            name: "get_view_config",
+            content: result,
+          });
+        }
+      }
+
+      answer = await getState().functions.llm_generate.run(null, {
+        tools,
+        chat,
+        appendToChat: true,
+        systemPrompt,
+      });
+    }
+  } finally {
+    await planningMd.delete();
+  }
+};
+
+const gen_tasks = async (table_id, viewname, config, body, { req, res }) => {
+  const spec = await MetaData.findOne({
+    type: "CopilotConstructMgr",
+    name: "spec",
+  });
+  if (!spec) throw new Error("Specification not found");
+  const rs = await MetaData.find({
+    type: "CopilotConstructMgr",
+    name: "requirement",
+  });
+  if (!rs.length) throw new Error("No requirements found");
+  const schema = await MetaData.findOne({
+    type: "CopilotConstructMgr",
+    name: "schema",
+  });
+  if (!schema) throw new Error("No schema found");
+  if (!schema.body.implemented) throw new Error("Schema not implemented");
+  doGenTasks(spec, rs, schema, req.user?.id).catch((e) =>
+    console.error("gen_tasks error", e)
+  );
   return { json: { reload_page: true } };
 };
 
@@ -306,17 +477,28 @@ const del_task = async (table_id, viewname, config, body, { req, res }) => {
 };
 const run_task = async (table_id, viewname, config, body, { req, res }) => {
   const reqUser = req?.user;
-  setImmediate(async () => {
-    try {
-      if (body.id) await runTask(body.id, { user: reqUser, __: req.__ });
-      else await runNextTask(true);
-    } catch (e) {
-      console.error("run_task background error", e);
-    }
-  });
+  if (body.id)
+    runTask(body.id, { user: reqUser, __: req.__ }).catch((e) =>
+      console.error("run_task error", e)
+    );
+  else runNextTask(true).catch((e) => console.error("run_task error", e));
   return { json: { reload_page: true } };
 };
 
+const planning_status = async (
+  table_id,
+  viewname,
+  config,
+  body,
+  { req, res }
+) => {
+  const planning = await MetaData.findOne({
+    type: "CopilotConstructMgr",
+    name: "planning",
+  });
+  return { json: { planning: !!planning } };
+};
+
 const task_status = async (table_id, viewname, config, body, { req, res }) => {
   const ids = body.ids || [];
   const tasks = await MetaData.find({
@@ -341,6 +523,7 @@ const start = async (table_id, viewname, config, body, { req, res }) => {
       name: "settings",
       body: { running: true },
     });
+  runNextTask().catch((e) => console.error("start error", e));
   return { json: { reload_page: true } };
 };
 const stop = async (table_id, viewname, config, body, { req, res }) => {
@@ -393,6 +576,7 @@ const task_routes = {
   del_all_tasks,
   mark_done_task,
   run_task,
+  planning_status,
   task_status,
   start,
   stop,

package/builder-gen.js

@@ -6,8 +6,12 @@ const { edit_build_in_actions } = require("@saltcorn/data/viewable_fields");
 const { buildBuilderSchema } = require("./builder-schema");
 const { getLlmConfigurationSafe, canUseResponseFormat } = require("./common");
 const { build_schema_data } = require("@saltcorn/data/plugin-helper");
-const { RelationsFinder } = require("@saltcorn/common-code");
-const { RelationType } = require("@saltcorn/common-code");
+const {
+  GET_RELATION_PATHS_FUNCTION,
+  getRelationPaths,
+  getRelationPathsForPairs,
+  pickBestRelation,
+} = require("./relation-paths");
 
 const ACTION_SIZES = ["btn-sm", "btn-lg"];
 
@@ -40,7 +44,9 @@ Alternatively wrap groups of fields in a card with a descriptive title.`;
 const EDIT_ACTIONS = `\
 Use edit fieldviews, group related inputs, and finish with a row of actions: \
 a Save button (action_name "Save", style "btn btn-primary") and \
-a Cancel button (action_name "GoBack", style "btn btn-outline-secondary").`;
+a Cancel button (action_name "GoBack", style "btn btn-outline-secondary"). \
+To add a trigger button, add an extra action segment with action_name set to the trigger's name \
+exactly as it appears in the available actions list (ctx.actions).`;
 
 // ── Show-mode guidance blocks ─────────────────────────────────────────────────
 
@@ -482,7 +488,10 @@ const prettifyActionName = (name) =>
 // Picks a valid fieldview from the field's available fieldviews only.
 // Never returns a fieldview that doesn't exist in field.fieldviews
 const pickFieldview = (field, mode, requestedFieldview = null) => {
-  const availableViews = field?.fieldviews || [];
+  const isEditMode = mode === "edit" || mode === "filter";
+  const availableViews = isEditMode
+    ? field?.editFieldviews || field?.fieldviews || []
+    : field?.fieldviews || [];
 
   // If no available fieldviews, return the first one or a safe default
   if (!availableViews.length) {
@@ -779,18 +788,13 @@ const normalizeSegment = (segment, ctx) => {
       let relation = clone.relation;
       if (!relation && ctx.table && ctx.schemaData) {
         try {
-          const finder = new RelationsFinder(
-            ctx.schemaData.tables,
-            ctx.schemaData.views,
-            6
-          );
-          const relations = finder.findRelations(
+          const relations = getRelationPaths(
             ctx.table.name,
             resolvedView,
-            []
+            ctx.schemaData
           );
           if (relations.length > 0) {
-            const picked = pickRelation(relations);
+            const picked = pickBestRelation(relations);
             if (picked) relation = picked.relationString;
           }
         } catch (e) {
@@ -842,7 +846,14 @@ const normalizeSegment = (segment, ctx) => {
       return { ...clone, besides, list_columns: true };
     }
     case "list_column": {
-      const contents = normalizeChild(clone.contents, ctx);
+      let raw = clone.contents;
+      // Saltcorn's list renderer handles `above` in a cell (wraps in Container)
+      // but silently drops a typeless `besides`. Convert it so both links render
+      // stacked in one column rather than disappearing.
+      if (raw && !raw.type && Array.isArray(raw.besides)) {
+        raw = { above: raw.besides };
+      }
+      const contents = normalizeChild(raw, ctx);
       return contents
         ? { ...clone, contents, header_label: clone.header_label || "" }
         : null;
@@ -1209,21 +1220,6 @@ const buildBracketObject = (node) => {
   return obj;
 };
 
-const pickRelation = (relations) => {
-  let own = null,
-    parent = null,
-    child = null;
-  for (const r of relations) {
-    if (r.type === RelationType.OWN) own = r;
-    else if (r.type === RelationType.PARENT_SHOW) parent = r;
-    else if (
-      r.type === RelationType.CHILD_LIST ||
-      r.type === RelationType.ONE_TO_ONE_SHOW
-    )
-      child = r;
-  }
-  return own || parent || child || relations[0];
-};
 
 const buildContext = async (mode, tableName) => {
   const normalizedMode = (mode || "show").toLowerCase();
@@ -1282,13 +1278,19 @@ const buildContext = async (mode, tableName) => {
   }
   if (rawFields?.then) rawFields = await rawFields;
   const fields = (rawFields || []).map((field) => {
-    let fieldviews = Object.keys(field.type?.fieldviews || {});
+    const fvDefs = field.type?.fieldviews || {};
+    let fieldviews = Object.keys(fvDefs);
     // FK fields have type "Key" (a string) so field.type?.fieldviews is empty;
     // ensure select and show are always available for them
     const typeName = field.type?.name || field.type || "";
     if (!fieldviews.length && String(typeName).startsWith("Key")) {
       fieldviews = ["select", "show"];
     }
+    // editFieldviews: only fieldviews where isEdit is not explicitly false
+    const editFieldviews = fieldviews.filter(
+      (fv) => fvDefs[fv]?.isEdit !== false
+    );
+
     const isPkName =
       table.pk_name &&
       typeof field.name === "string" &&
@@ -1313,6 +1315,7 @@ const buildContext = async (mode, tableName) => {
       is_pk_name: !!isPkName,
       default_fieldview: defaultFieldview,
       fieldviews: fieldviews.length ? fieldviews : ["show"],
+      editFieldviews: editFieldviews.length ? editFieldviews : fieldviews,
       attributes: field.attributes || {},
     };
   });
@@ -1397,6 +1400,57 @@ const buildErrorLayout = ({ message, mode, table }) => {
   };
 };
 
+const GET_RELATION_PATHS_TOOL = { type: "function", function: GET_RELATION_PATHS_FUNCTION };
+
+/**
+ * Run the LLM giving it one opportunity to call get_relation_paths before
+ * producing the final layout JSON. Returns the final text response.
+ */
+const runWithRelationTools = async (llm, mainPrompt, opts) => {
+  const llm_add_message = getState().functions.llm_add_message;
+
+  // Local chat copy with the main prompt pre-loaded so all iterations see it.
+  const runChat = Array.isArray(opts.chat) ? [...opts.chat] : [];
+  runChat.push({ role: "user", content: mainPrompt });
+
+  // Drop response_format during tool phase; repair chain handles JSON after.
+  const toolOpts = { ...opts, tools: [GET_RELATION_PATHS_TOOL] };
+  delete toolOpts.response_format;
+  delete toolOpts.chat;
+
+  // Call 1: model either returns JSON directly or calls get_relation_paths.
+  const raw = await llm.run(null, { ...toolOpts, chat: runChat });
+  if (!raw?.hasToolCalls) {
+    return typeof raw === "string" ? raw : raw?.content ?? "";
+  }
+
+  // Append the assistant message so call 2 has full context.
+  if (raw.ai_sdk && Array.isArray(raw.messages)) {
+    raw.messages.filter((m) => m.role === "assistant").forEach((m) => runChat.push(m));
+  } else if (raw.tool_calls) {
+    runChat.push({ role: "assistant", content: raw.content || null, tool_calls: raw.tool_calls });
+  }
+
+  // Resolve the tool call(s) and push results.
+  const schemaData = await build_schema_data();
+  for (const tc of raw.getToolCalls()) {
+    let resultText;
+    if (tc.tool_name === "get_relation_paths") {
+      const sections = getRelationPathsForPairs(tc.input.pairs || [], schemaData);
+      resultText =
+        sections.join("\n\n") +
+        `\n\nSet the "relation" property to one of the strings listed above for each view_link.`;
+    } else {
+      resultText = `Unknown tool: ${tc.tool_name}`;
+    }
+    await llm_add_message.run("tool_response", resultText, { chat: runChat, tool_call: tc });
+  }
+
+  // Call 2: model has relation paths, now generates the layout JSON.
+  const final = await llm.run(null, { ...opts, chat: runChat });
+  return typeof final === "string" ? final : final?.content ?? "";
+};
+
 module.exports = {
   normalizeLayoutCandidate,
   run: async (prompt, mode, table, existing_layout, chat) => {
@@ -1467,7 +1521,7 @@ module.exports = {
       if (!schema || !schema.schema) {
         throw new Error("Builder schema unavailable");
       }
-      rawResponse = await llm.run(llmPrompt, options);
+      rawResponse = await runWithRelationTools(llm, llmPrompt, options);
       payload = parseJsonPayload(rawResponse);
       const candidate = payload.layout ?? payload;
       const result = normalizeLayoutCandidate(candidate, ctx);

package/chat-copilot.js

@@ -382,6 +382,7 @@ const actionClasses = [
   require("./actions/generate-workflow"),
   require("./actions/generate-tables"),
   require("./actions/generate-js-action"),
+  require("./actions/generate-trigger"),
   require("./actions/generate-page"),
   require("./actions/generate-view"),
 ];

package/copilot-as-agent.js

@@ -49,6 +49,7 @@ const get_agent_view = () => {
         { skill_type: "Generate View" },
         { skill_type: "Registry editor" },
         { skill_type: "Javascript Action" },
+        { skill_type: "Generate trigger" },
         ...(typeof Plugin.loadAndSaveNewPlugin === "function"
           ? [{ skill_type: "Install Plugin" }]
           : []),

package/index.js

@@ -44,7 +44,7 @@ module.exports = {
       require("./agent-skills/viewgen.js"),
       require("./agent-skills/registry-editor.js"),
       require("./agent-skills/js-action.js"),
-      require("./agent-skills/app-constructor-context.js"),
+      require("./agent-skills/triggergen.js"),
       ...(typeof Plugin.loadAndSaveNewPlugin === "function"
         ? [require("./agent-skills/install-plugin.js")]
         : []),

package/package.json

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