@saltcorn/agents 0.1.2 → 0.1.3

package/agent-view.js

@@ -45,7 +45,7 @@ const configuration_workflow = (req) =>
   new Workflow({
     steps: [
       {
-        name: req.__("Agent action"),
+        name: "Agent action",
         form: async (context) => {
           const agent_actions = await Trigger.find({ action: "Agent" });
           return new Form({
@@ -68,7 +68,7 @@ const configuration_workflow = (req) =>
                       "data-dyn-href": `\`/actions/configure/\${action_id}\``,
                       target: "_blank",
                     },
-                    req.__("Configure")
+                    "Configure"
                   ),
               },
               {
@@ -80,7 +80,14 @@ const configuration_workflow = (req) =>
                 name: "placeholder",
                 label: "Placeholder",
                 type: "String",
-                default: "How can I help you?"
+                default: "How can I help you?",
+              },
+              {
+                name: "explainer",
+                label: "Explainer",
+                type: "String",
+                sublabel:
+                  "Appears below the input box. Use for additional instructions.",
               },
             ],
           });
@@ -94,7 +101,7 @@ const get_state_fields = () => [];
 const run = async (
   table_id,
   viewname,
-  { action_id, show_prev_runs, placeholder },
+  { action_id, show_prev_runs, placeholder, explainer },
   state,
   { res, req }
 ) => {
@@ -238,7 +245,8 @@ const run = async (
       span(
         { class: "submit-button p-2", onclick: "$('form.copilot').submit()" },
         i({ id: "sendbuttonicon", class: "far fa-paper-plane" })
-      )
+      ),
+      explainer && small({ class: "explainer" }, i(explainer))
     )
   );
 
@@ -310,6 +318,11 @@ const run = async (
               position: relative; 
               top: -1.8rem;
               left: 0.1rem;              
+            }
+              .copilot-entry .explainer {
+              position: relative; 
+              top: -1.2rem;    
+              display: block;                        
             }
             .copilot-entry {margin-bottom: -1.25rem; margin-top: 1rem;}
             p.prevrun_content {

package/common.js

@@ -9,6 +9,8 @@ const get_skills = () => {
   return [
     require("./skills/FTSRetrieval"),
     require("./skills/EmbeddingRetrieval"),
+    require("./skills/Trigger"),
+    require("./skills/Table"),
     //require("./skills/AdaptiveFeedback"),
   ];
 };
@@ -181,7 +183,8 @@ const process_interaction = async (
         }
         hasResult = true;
         const result = await tool.tool.process(
-          JSON.parse(tool_call.function.arguments)
+          JSON.parse(tool_call.function.arguments),
+          { req }
         );
         if (
           (typeof result === "object" && Object.keys(result || {}).length) ||

package/index.js

@@ -93,8 +93,9 @@ module.exports = {
 /* 
 TODO
 
--embedding retrieval test
--promote triggers to skills (optional user confirm)
+-embedding retrieval list view
+-optional user confirm: action, insert
+-Preload data
 -sql access
 -memory
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saltcorn/agents",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "AI agents for Saltcorn",
   "main": "index.js",
   "dependencies": {

package/skills/EmbeddingRetrieval.js

@@ -90,6 +90,7 @@ class RetrievalByEmbedding {
         name: "add_sys_prompt",
         label: "Additional prompt",
         type: "String",
+        fieldview: "textarea"
       },
     ];
   }

package/skills/FTSRetrieval.js

@@ -26,6 +26,10 @@ class RetrievalByFullTextSearch {
       return `Use the ${this.toolName} tool to search the ${
         this.table_name
       } database by a search phrase which will locate rows where any field match that query.${
+        this.list_view
+          ? ` When the tool call returns rows, do not describe them or repeat the information to the user. The results are already displayed to the user automatically.`
+          : ""
+      }${
         this.add_sys_prompt
           ? ` Additional information for the ${this.toolName} tool: ${this.add_sys_prompt}`
           : ""
@@ -78,6 +82,7 @@ class RetrievalByFullTextSearch {
         name: "add_sys_prompt",
         label: "Additional prompt",
         type: "String",
+        fieldview: "textarea",
       },
       /*{
         name: "contents_expr",

package/skills/Table.js

@@ -0,0 +1,241 @@
+const { div, pre } = require("@saltcorn/markup/tags");
+const Workflow = require("@saltcorn/data/models/workflow");
+const Form = require("@saltcorn/data/models/form");
+const Table = require("@saltcorn/data/models/table");
+const View = require("@saltcorn/data/models/view");
+const { getState } = require("@saltcorn/data/db/state");
+const db = require("@saltcorn/data/db");
+const { fieldProperties } = require("./helpers");
+
+class TableToSkill {
+  static skill_name = "Table";
+
+  get skill_label() {
+    return `${this.table_name} table`;
+  }
+
+  constructor(cfg) {
+    Object.assign(this, cfg);
+  }
+
+  systemPrompt() {
+    return `Use the query_${this.table_name} tool to search the ${
+      this.table_name
+    } database by a search phrase which will locate rows where any field match that query.${
+      this.add_sys_prompt ? ` ${this.add_sys_prompt}` : ""
+    }`;
+  }
+
+  static async configFields() {
+    const allTables = await Table.find();
+    const list_view_opts = {};
+    for (const t of allTables) {
+      const lviews = await View.find_table_views_where(
+        t.id,
+        ({ state_fields, viewrow }) =>
+          viewrow.viewtemplate !== "Edit" &&
+          state_fields.every((sf) => !sf.required)
+      );
+      list_view_opts[t.name] = ["", ...lviews.map((v) => v.name)];
+    }
+    return [
+      {
+        name: "table_name",
+        label: "Table",
+        sublabel: "Which table to link to the agent",
+        type: "String",
+        required: true,
+        attributes: { options: allTables.map((t) => t.name) },
+      },
+      {
+        name: "query",
+        label: "Query",
+        type: "Bool",
+        sublabel: "Allow the agent to query from this table",
+      },
+      {
+        name: "insert",
+        label: "Insert",
+        type: "Bool",
+        sublabel: "Allow the agent to insert new rows into this table",
+      },
+      {
+        name: "list_view",
+        label: "List view",
+        type: "String",
+        attributes: {
+          calcOptions: ["table_name", list_view_opts],
+        },
+      },
+      {
+        name: "hidden_fields",
+        label: "Hide fields",
+        type: "String",
+        sublabel: "Comma-separated list of fields to hide from the prompt",
+        showIf: { query: true },
+      },
+      {
+        name: "add_sys_prompt",
+        label: "Additional system prompt",
+        type: "String",
+        fieldview: "textarea"
+      },
+    ];
+  }
+
+  provideTools() {
+    const table = Table.findOne(this.table_name);
+    const tools = [];
+    let queryProperties = {};
+    let required = [];
+
+    table.fields
+      .filter((f) => !f.primary_key)
+      .forEach((field) => {
+        if (field.required && !field.primary_key) required.push(field.name);
+        queryProperties[field.name] = {
+          description: field.label + " " + field.description || "",
+          ...fieldProperties(field),
+        };
+      });
+
+    if (this.query)
+      tools.push({
+        type: "function",
+        process: async (q) => {
+          console.log("Table search", q);
+
+          let rows = [];
+          if (q.query?.full_text_search || q.full_text_search) {
+            const scState = getState();
+            const language = scState.pg_ts_config;
+            const use_websearch = scState.getConfig(
+              "search_use_websearch",
+              false
+            );
+            rows = await table.getRows({
+              _fts: {
+                fields: table.fields,
+                searchTerm: q.query?.full_text_search || q.full_text_search,
+                language,
+                use_websearch,
+                table: table.name,
+                schema: db.isSQLite ? undefined : db.getTenantSchema(),
+              },
+            });
+          } else {
+            rows = await table.getRows(q.query || q);
+          }
+          if (this.hidden_fields) {
+            const hidden_fields = this.hidden_fields
+              .split(",")
+              .map((s) => s.trim());
+            rows.forEach((r) => {
+              hidden_fields.forEach((k) => {
+                delete r[k];
+              });
+            });
+          }
+
+          if (rows.length) return { rows };
+          else
+            return {
+              response: "No rows found",
+            };
+        },
+        /*renderToolCall({ phrase }, { req }) {
+        return div({ class: "border border-primary p-2 m-2" }, phrase);
+      },*/
+        renderToolResponse: async ({ response, rows }, { req }) => {
+          if (rows) {
+            const view = View.findOne({ name: this.list_view });
+
+            if (view) {
+              const viewRes = await view.run(
+                { [table.pk_name]: { in: rows.map((r) => r[table.pk_name]) } },
+                { req }
+              );
+              return viewRes;
+            } else return "";
+          }
+          return div({ class: "border border-success p-2 m-2" }, response);
+        },
+        function: {
+          name: `query_${this.table_name}`,
+          description: `Search the ${this.table_name} database table${
+            table.description ? ` (${table.description})` : ""
+          } by a search phrase matched against all fields in the table with full text search or a more specific query. The retrieved rows will be returned`,
+          parameters: {
+            type: "object",
+            properties: {
+              query: {
+                anyOf: [
+                  {
+                    type: "object",
+                    description:
+                      "Search the table by a phrase matched against any string field",
+                    properties: {
+                      full_text_search: {
+                        type: "string",
+                        description: "A phrase to search the table with",
+                      },
+                    },
+                  },
+                  {
+                    type: "object",
+                    description: "Search the table by individual fields",
+                    properties: queryProperties,
+                  },
+                ],
+              },
+            },
+          },
+        },
+      });
+
+    if (this.insert)
+      tools.push({
+        type: "function",
+        process: async (rows, { req }) => {
+          const ids = [];
+          if (Array.isArray(rows)) {
+            for (const row of rows)
+              ids.push(await table.insertRow(row, req?.user));
+          } else ids.push(await table.insertRow(rows, req?.user));
+          return { created_ids: ids };
+        },
+        /*renderToolCall({ phrase }, { req }) {
+        return div({ class: "border border-primary p-2 m-2" }, phrase);
+      },*/
+        renderToolResponse: async ({ created_ids }, { req }) => {
+          if (created_ids) {
+            const view = View.findOne({ name: this.list_view });
+
+            if (view) {
+              const viewRes = await view.run(
+                { [table.pk_name]: { in: created_ids } },
+                { req }
+              );
+              return viewRes;
+            } else return "";
+          }
+        },
+        function: {
+          name: `insert_${this.table_name}`,
+          description: `Insert rows into the  ${
+            this.table_name
+          } database table${
+            table.description ? ` (${table.description})` : ""
+          }`,
+          parameters: {
+            type: "object",
+            required,
+            properties: queryProperties,
+          },
+        },
+      });
+    return tools;
+  }
+}
+
+module.exports = TableToSkill;

package/skills/Trigger.js

@@ -0,0 +1,101 @@
+const { div, pre, a } = require("@saltcorn/markup/tags");
+const Workflow = require("@saltcorn/data/models/workflow");
+const Form = require("@saltcorn/data/models/form");
+const Table = require("@saltcorn/data/models/table");
+const View = require("@saltcorn/data/models/view");
+const Trigger = require("@saltcorn/data/models/trigger");
+const { getState } = require("@saltcorn/data/db/state");
+const db = require("@saltcorn/data/db");
+const { fieldProperties } = require("./helpers");
+
+class TriggerToSkill {
+  static skill_name = "Trigger";
+
+  get skill_label() {
+    return this.trigger_name;
+  }
+
+  constructor(cfg) {
+    Object.assign(this, cfg);
+  }
+
+  systemPrompt() {
+    const trigger = Trigger.findOne({ name: this.trigger_name });
+
+    return `${this.trigger_name} tool: ${trigger.description}`;
+  }
+
+  static async configFields() {
+    const actions = (await Trigger.find({})).filter(
+      (action) => action.description
+    );
+    const hasTable = actions.filter((a) => a.table_id).map((a) => a.name);
+    const confirm_view_opts = {};
+    for (const a of actions) {
+      if (!a.table_id) continue;
+      const views = await View.find({ table_id: a.table_id });
+      confirm_view_opts[a.name] = views.map((v) => v.name);
+    }
+    return [
+      {
+        name: "trigger_name",
+        label: "Action",
+        sublabel:
+          "Only actions with a description can be enabled. " +
+          a(
+            {
+              "data-dyn-href": `\`/actions/configure/\${trigger_name}\``,
+              target: "_blank",
+            },
+            "Configure"
+          ),
+        type: "String",
+        required: true,
+        attributes: { options: actions.map((a) => a.name) },
+      },
+      // TODO: confirm, show response, show argument
+    ];
+  }
+
+  provideTools = () => {
+    let properties = {};
+
+    const trigger = Trigger.findOne({ name: this.trigger_name });
+    if (trigger.table_id) {
+      const table = Table.findOne({ id: trigger.table_id });
+
+      table.fields
+        .filter((f) => !f.primary_key)
+        .forEach((field) => {
+          properties[field.name] = {
+            description: field.label + " " + field.description || "",
+            ...fieldProperties(field),
+          };
+        });
+    }
+    return {
+      type: "function",
+      process: async (row, { req }) => {
+        const result = await trigger.runWithoutRow({ user: req?.user, row });
+        return result;
+      },
+      /*renderToolCall({ phrase }, { req }) {
+        return div({ class: "border border-primary p-2 m-2" }, phrase);
+      },*/
+      renderToolResponse: async (response, { req }) => {
+        return div({ class: "border border-success p-2 m-2" }, response);
+      },
+      function: {
+        name: trigger.name,
+        description: trigger.description,
+        parameters: {
+          type: "object",
+          //required: ["action_javascript_code", "action_name"],
+          properties,
+        },
+      },
+    };
+  };
+}
+
+module.exports = TriggerToSkill;

package/skills/helpers.js

@@ -0,0 +1,54 @@
+const toArrayOfStrings = (opts) => {
+  if (typeof opts === "string") return opts.split(",").map((s) => s.trim());
+  if (Array.isArray(opts))
+    return opts.map((o) => (typeof o === "string" ? o : o.value || o.name));
+};
+
+const fieldProperties = (field) => {
+  const props = {};
+  const typeName = field.type?.name || field.type || field.input_type;
+  if (field.isRepeat) {
+    props.type = "array";
+    const properties = {};
+    field.fields.map((f) => {
+      properties[f.name] = {
+        description: f.sublabel || f.label,
+        ...fieldProperties(f),
+      };
+    });
+    props.items = {
+      type: "object",
+      properties,
+    };
+  }
+  switch (typeName) {
+    case "String":
+      props.type = "string";
+      if (field.attributes?.options)
+        props.enum = toArrayOfStrings(field.attributes.options);
+      break;
+    case "Bool":
+      props.type = "boolean";
+      break;
+    case "Integer":
+      props.type = "integer";
+      break;
+    case "Float":
+      props.type = "number";
+      break;
+    case "select":
+      props.type = "string";
+      if (field.options) props.enum = toArrayOfStrings(field.options);
+      break;
+  }
+  if (!props.type) {
+    switch (field.input_type) {
+      case "code":
+        props.type = "string";
+        break;
+    }
+  }
+  return props;
+};
+
+module.exports = { fieldProperties };