@saltcorn/copilot 0.8.1 → 0.8.2

package/builder-gen.js

@@ -79,7 +79,9 @@ only use "show_with_html" when the task explicitly requires rendering HTML conte
 
 const LISTCOLUMNS_VIEW_LINK = `\
 A view_link that opens the detail of a row MUST point to a Show-type view (viewtemplate "Show"). \
-Only include such a view_link if a Show view for this table is listed in the available views.`;
+Only include such a view_link if a Show view for this table is listed in the available views. \
+Every view_link requires a "relation" string — you MUST call get_relation_paths before generating the layout \
+whenever the layout will contain any view_link or embedded view segment.`;
 
 // ── Composed MODE_GUIDANCE ────────────────────────────────────────────────────
 
@@ -805,7 +807,8 @@ const normalizeSegment = (segment, ctx) => {
       let viewLabel = clone.view_label || clone.view;
       let isFormula = clone.isFormula || {};
       const tmplMatch =
-        typeof viewLabel === "string" && viewLabel.match(/^\{\{\s*(.+?)\s*\}\}$/);
+        typeof viewLabel === "string" &&
+        viewLabel.match(/^\{\{\s*(.+?)\s*\}\}$/);
       if (tmplMatch) {
         viewLabel = tmplMatch[1];
         isFormula = { ...isFormula, label: true };
@@ -843,7 +846,9 @@ const normalizeSegment = (segment, ctx) => {
         child == null ? null : normalizeSegment(child, ctx)
       );
       if (!besides.some(Boolean)) return null;
-      return { ...clone, besides, list_columns: true };
+      // Drop 'type' — List viewtemplate expects { besides, list_columns: true } with no type field
+      const { type: _t, ...rest } = clone;
+      return { ...rest, besides, list_columns: true };
     }
     case "list_column": {
       let raw = clone.contents;
@@ -961,7 +966,21 @@ const normalizeLayoutCandidate = (candidate, ctx) => {
     normalized = convertForeignLayout(candidate, ctx);
   }
   if (!normalized) return null;
-  const layout = Array.isArray(normalized) ? { above: normalized } : normalized;
+  let layout = Array.isArray(normalized) ? { above: normalized } : normalized;
+
+  // For listcolumns mode: if the LLM wrapped the list in a stack, unwrap it
+  if (
+    ctx.mode === "listcolumns" &&
+    layout.type === "stack" &&
+    Array.isArray(layout.above)
+  ) {
+    const listChild = layout.above.find((c) => c?.list_columns);
+    if (listChild) {
+      const { type: _t, ...rest } = listChild;
+      layout = rest;
+    }
+  }
+
   return sanitizeNoHtmlSegments(layout);
 };
 
@@ -1000,6 +1019,11 @@ const buildPromptText = (userPrompt, ctx, schema) => {
       schema
     )}`
   );
+  parts.push(
+    `TOOL CALL REQUIRED: If the layout you are about to generate contains any view_link or embedded view (type "view") segment, ` +
+      `you MUST call get_relation_paths with all required source_table/target_view pairs BEFORE returning JSON. ` +
+      `Do NOT guess or omit the "relation" field — return the tool call first and use the result in the layout.`
+  );
   parts.push(
     `Based on the schema above, process the following user request and generate the layout JSON. Reminder: ONLY output valid JSON starting with { and ending with }, no markdown fences.\nUser request:\n"${userPrompt}"`
   );
@@ -1220,7 +1244,6 @@ const buildBracketObject = (node) => {
   return obj;
 };
 
-
 const buildContext = async (mode, tableName) => {
   const normalizedMode = (mode || "show").toLowerCase();
   const ctx = {
@@ -1400,16 +1423,19 @@ const buildErrorLayout = ({ message, mode, table }) => {
   };
 };
 
-const GET_RELATION_PATHS_TOOL = { type: "function", function: GET_RELATION_PATHS_FUNCTION };
+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.
+ * Run the LLM allowing up to MAX_TOOL_ROUNDS get_relation_paths calls (depth
+ * escalation: 2 → 4 → 6) before producing the final layout JSON.
  */
+const MAX_TOOL_ROUNDS = 4;
 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 });
 
@@ -1418,35 +1444,54 @@ const runWithRelationTools = async (llm, mainPrompt, opts) => {
   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 ?? "";
-  }
+  const schemaData = await build_schema_data();
 
-  // 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 });
-  }
+  for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+    const raw = await llm.run(null, { ...toolOpts, chat: runChat });
 
-  // 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}`;
+    if (!raw?.hasToolCalls) {
+      return typeof raw === "string" ? raw : raw?.content ?? "";
+    }
+
+    // Append the assistant message so the next round 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,
+      });
+    }
+
+    for (const tc of raw.getToolCalls()) {
+      let resultText;
+      if (tc.tool_name === "get_relation_paths") {
+        const maxDepth = tc.input.max_depth ?? 2;
+        const sections = getRelationPathsForPairs(
+          tc.input.pairs || [],
+          schemaData,
+          maxDepth
+        );
+        resultText =
+          sections.join("\n\n") +
+          `\n\nFor each pair above: analyse whether the listed paths include a suitable one for the intended relation type (ChildList, ParentShow, Own, etc.). ` +
+          `If a suitable path exists, set the "relation" property to the chosen path string for all types including Own. ` +
+          `If no suitable path exists for a pair (no paths listed, or none match the intended type), call get_relation_paths again with a higher max_depth (4, then 6). ` +
+          `Do not escalate just because multiple paths are listed — only escalate when none is appropriate.`;
+      } else {
+        resultText = `Unknown tool: ${tc.tool_name}`;
+      }
+      await llm_add_message.run("tool_response", resultText, {
+        chat: runChat,
+        tool_call: tc,
+      });
     }
-    await llm_add_message.run("tool_response", resultText, { chat: runChat, tool_call: tc });
   }
 
-  // Call 2: model has relation paths, now generates the layout JSON.
+  // Exhausted tool rounds — force final JSON answer.
   const final = await llm.run(null, { ...opts, chat: runChat });
   return typeof final === "string" ? final : final?.content ?? "";
 };
@@ -1564,6 +1609,7 @@ module.exports = {
   },
   isAsync: true,
   description: "Generate a builder layout",
+  hidden: true,
   arguments: [
     { name: "prompt", type: "String" },
     { name: "mode", type: "String" },

package/copilot-as-agent.js

@@ -62,6 +62,7 @@ const get_agent_view = () => {
     min_role: 1,
     configuration: {
       agent_action,
+      show_prev_runs: true,
       viewname,
     },
   });

package/index.js

@@ -18,7 +18,6 @@ module.exports = {
   dependencies: ["@saltcorn/large-language-model", "@saltcorn/agents"],
   viewtemplates: features.workflows
     ? [
-        require("./chat-copilot"),
         require("./user-copilot"),
         require("./copilot-as-agent"),
         require("./app-constructor/view.js"),

package/js-code-gen.js

@@ -57,6 +57,7 @@ module.exports = {
   },
   isAsync: true,
   description: "Generate JavaScript code for an action",
+  hidden: true,
   arguments: [
     { name: "description", type: "String" },
     { name: "existing_code", type: "String" },

package/package.json

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

package/relation-paths.js

@@ -36,66 +36,72 @@ const { RelationsFinder, RelationType } = require("@saltcorn/common-code");
 const RELATION_PATH_DOC = `
 ## Relation paths
 
-Relation paths connect a view_link column or embedded view (type "view") segment to its
-target view. There are two formats — **new** (preferred) and **legacy** (read-only).
+Every view_link and embedded view segment requires two fields:
+- \`view\`: the view name (plain string, e.g. \`"packing_items_list"\`)
+- \`relation\`: a dot-separated path string (e.g. \`".trips.packing_items$trip_id"\`)
 
----
+**Always use this format. Never generate anything else.**
 
-### New format (always use this when generating or updating)
+---
 
-Two separate fields:
-- \`view\`: just the view name, e.g. \`"packing_items_list"\`
-- \`relation\`: a dot-separated path string, e.g. \`".trips.packing_items$trip_id"\`
+### Relation path format
 
-**Path string format:** \`.sourcetable.segment1.segment2...\`
+\`.sourcetable.segment1.segment2...\`
 
 Segment types:
-- **Outbound FK** (navigate to a parent): FK field name alone — e.g. \`trip_id\`
-- **Inbound FK** (collect child rows): \`childtable$fkfield\` — e.g. \`packing_items$trip_id\`
+- **Outbound FK** (to a parent): FK field name alone — e.g. \`trip_id\`
+- **Inbound FK** (child rows): \`childtable$fkfield\` — e.g. \`packing_items$trip_id\`
+- **Same table** (no FK traversal): just the source table, no segments — e.g. \`".invoice_line_items"\`
 
 Examples:
-| relation string | type | meaning |
-|---|---|---|
-| \`.trips.packing_items$trip_id\` | ChildList | all packing_items for a trip |
-| \`.packing_items.trip_id\` | ParentShow | the trip that owns a packing_item |
-| \`.artists.artist_plays_on_album$artist.album\` | ChildList | albums via join table |
-| \`.users.orders$user_id.order_lines$order_id\` | RelationPath | multi-level |
+| relation string | meaning |
+|---|---|
+| \`.invoice_line_items\` | same-table link (no FK traversal) |
+| \`.trips.packing_items$trip_id\` | all packing_items for a trip |
+| \`.packing_items.trip_id\` | the trip that owns a packing_item |
+| \`.artists.artist_plays_on_album$artist.album\` | albums via join table |
+| \`.users.orders$user_id.order_lines$order_id\` | multi-level |
 
 ---
 
-### Legacy format (you may encounter this in existing configs — do not generate it)
+### Legacy format — read-only, never generate
 
-The type and path are encoded together inside the \`view\` field as a colon-prefixed string.
-There is no separate \`relation\` field.
+Any \`view\` field value that contains a colon (e.g. \`"ChildList:trips_list.packing_items.trip_id"\`,
+\`"Own:viewname"\`, \`"ParentShow:viewname.table.fkfield"\`) is legacy. You may encounter it in
+existing configs. Parse it to understand the relation, then always write back in the new format.
 
-| legacy view field | equivalent new relation |
+| legacy view field | new format equivalent |
 |---|---|
-| \`"Own:viewname"\` | \`view: "viewname"\`, no relation |
+| \`"Own:viewname"\` | \`relation: ".sourcetable"\` |
+| \`"Independent:viewname"\` | no \`relation\` field needed |
 | \`"ParentShow:viewname.table.fkfield"\` | \`relation: ".sourcetable.fkfield"\` |
 | \`"ChildList:viewname.table.inbkey"\` | \`relation: ".sourcetable.childtable$inbkey"\` |
 | \`"OneToOneShow:viewname.table.inbkey"\` | \`relation: ".sourcetable.childtable$inbkey"\` |
-| \`"Independent:viewname"\` | \`view: "viewname"\`, no relation |
-
-When you read an existing view config and see a legacy \`view\` value like \`"ChildList:trips_list.packing_items.trip_id"\`, parse it as: type=ChildList, view=trips_list, relation=.sourcetable.packing_items$trip_id. When writing back, convert to the new format.
 
 ---
 
 ### Using get_relation_paths
 
-Call it **once** with all source_table/target_view pairs you need — do not make separate calls per pair. The tool returns paths in the new RelationPath format; always write back in the new format, even if you read legacy strings from an existing config.
+Call it **once** with all source_table/target_view pairs you need. The tool always returns new-format
+path strings — use them as the \`relation\` field directly.
 
-When multiple paths are returned for one pair, pick by matching the relation type to what the target view is meant to show:
-- **ChildList** — target view shows multiple rows belonging to the current row (e.g. packing items for a trip).
-- **ParentShow** — target view shows the single parent the current row belongs to (e.g. the trip for a packing item).
+**Depth escalation:** Start with \`max_depth=2\`. After receiving results, analyse each pair: does the
+result contain a path that matches the intended relation type? If yes, use it. If a pair has no
+suitable path (no paths at all, or none of the right type), call again with \`max_depth=4\`, then
+\`max_depth=6\` if still none. Do not escalate just because multiple paths are listed.
+
+Selecting among returned paths:
+- **ChildList** — target view shows multiple rows belonging to the current row.
+- **ParentShow** — target view shows the single parent the current row belongs to.
 - **OneToOneShow** — exactly one related child row via a unique FK.
-- **Own** — target view is on the same table (no FK traversal needed).
-- If multiple paths of the same type exist (e.g. a table has two FKs pointing to the same target), pick the one whose FK field name best matches the semantic relationship in the task.
+- **Own** — same table, no FK traversal. Relation string is just \`.sourcetable\`.
+- If multiple paths of the same type exist, pick the one whose FK field name best matches the task.
 - Prefer shorter paths (fewer segments) unless a longer one is clearly more appropriate.
 `;
 
 const typeToLabel = (type) => {
   if (type === RelationType.OWN)
-    return "Own – source and target are the same table (no relation needed)";
+    return "Own – source and target are the same table. Use this relation string as-is (no extra segments after the table name).";
   if (type === RelationType.INDEPENDENT)
     return "Independent – no FK relationship exists";
   if (type === RelationType.PARENT_SHOW)
@@ -113,10 +119,19 @@ const typeToLabel = (type) => {
  * @param {{ tables, views }} schemaData  pre-fetched via build_schema_data()
  * @returns {Array<Relation>}  raw Relation objects from RelationsFinder
  */
-function getRelationPaths(sourceTableName, targetViewName, schemaData) {
+function getRelationPaths(
+  sourceTableName,
+  targetViewName,
+  schemaData,
+  maxDepth = 6
+) {
   if (!schemaData) return [];
   try {
-    const finder = new RelationsFinder(schemaData.tables, schemaData.views, 6);
+    const finder = new RelationsFinder(
+      schemaData.tables,
+      schemaData.views,
+      maxDepth
+    );
     return finder.findRelations(sourceTableName, targetViewName, []);
   } catch {
     return [];
@@ -130,13 +145,22 @@ function getRelationPaths(sourceTableName, targetViewName, schemaData) {
  * @param {{ tables, views }} schemaData
  * @returns {Array<string>}  one formatted result string per pair
  */
-function getRelationPathsForPairs(pairs, schemaData) {
-  if (!schemaData) return pairs.map(({ source_table, target_view }) =>
-    formatRelationPathResult(source_table, target_view, { error: "Schema data unavailable" })
+function getRelationPathsForPairs(pairs, schemaData, maxDepth = 6) {
+  if (!schemaData)
+    return pairs.map(({ source_table, target_view }) =>
+      formatRelationPathResult(source_table, target_view, {
+        error: "Schema data unavailable",
+      })
+    );
+  const finder = new RelationsFinder(
+    schemaData.tables,
+    schemaData.views,
+    maxDepth
   );
-  const finder = new RelationsFinder(schemaData.tables, schemaData.views, 6);
   return pairs.map(({ source_table, target_view }) => {
-    const targetView = (schemaData.views || []).find((v) => v.name === target_view);
+    const targetView = (schemaData.views || []).find(
+      (v) => v.name === target_view
+    );
     if (!targetView)
       return formatRelationPathResult(source_table, target_view, {
         error: `View "${target_view}" not found in current schema`,
@@ -198,8 +222,11 @@ const GET_RELATION_PATHS_FUNCTION = {
   name: "get_relation_paths",
   description:
     "Get all valid relation path strings for one or more source_table/target_view pairs. " +
-    "Call this ONCE with all pairs you need before setting any 'relation' property on " +
-    "view_link columns or embedded view (type 'view') segments.",
+    "Call this before setting any 'relation' property on view_link columns or embedded view segments. " +
+    "Always start with max_depth=2 to keep the result compact. " +
+    "After receiving the results, analyse whether each pair has a suitable path for its intended relation type. " +
+    "If a pair has no suitable path, call again with max_depth=4, then max_depth=6 if still none. " +
+    "Stop as soon as every pair has a suitable path.",
   parameters: {
     type: "object",
     required: ["pairs"],
@@ -223,6 +250,12 @@ const GET_RELATION_PATHS_FUNCTION = {
           },
         },
       },
+      max_depth: {
+        type: "integer",
+        description:
+          "Maximum join depth to search. Start with 2. Escalate to 4, then 6, only if a pair has no suitable path in the current results — not just because paths exist, but because none match the intended relation type.",
+        default: 2,
+      },
     },
   },
 };

package/standard-prompt.js

@@ -73,6 +73,7 @@ ${ds.join("\n")}`);
   },
   isAsync: true,
   description: "Return a standard prompt for writing code",
+  hidden: true,
   arguments: [
     {
       name: "options",

package/user-copilot.js

@@ -933,5 +933,7 @@ module.exports = {
   get_state_fields,
   tableless: true,
   run,
+  deprecated: true,
+  description: "Use Agents from the agent module instead",
   routes: { interact, delprevrun },
 };

package/workflow-gen.js

@@ -41,5 +41,6 @@ module.exports = {
   },
   isAsync: true,
   description: "Generate a workflow",
+  hidden: true,
   arguments: [{ name: "description", type: "String" }],
 };