@saltcorn/agents 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Saltcorn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# agents
+AI Agents for Saltcorn

package/agent-view.js

@@ -0,0 +1,608 @@
+const Field = require("@saltcorn/data/models/field");
+const Table = require("@saltcorn/data/models/table");
+const Form = require("@saltcorn/data/models/form");
+const View = require("@saltcorn/data/models/view");
+const Trigger = require("@saltcorn/data/models/trigger");
+const FieldRepeat = require("@saltcorn/data/models/fieldrepeat");
+const db = require("@saltcorn/data/db");
+const WorkflowRun = require("@saltcorn/data/models/workflow_run");
+const Workflow = require("@saltcorn/data/models/workflow");
+const { localeDateTime } = require("@saltcorn/markup");
+const {
+  div,
+  script,
+  domReady,
+  pre,
+  code,
+  input,
+  h4,
+  style,
+  h5,
+  button,
+  text_attr,
+  i,
+  p,
+  span,
+  small,
+  form,
+  textarea,
+  a,
+} = require("@saltcorn/markup/tags");
+const { getState } = require("@saltcorn/data/db/state");
+const {
+  incompleteCfgMsg,
+  getCompletionArguments,
+  find_tool,
+} = require("./common");
+const MarkdownIt = require("markdown-it"),
+  md = new MarkdownIt();
+
+const configuration_workflow = (req) =>
+  new Workflow({
+    steps: [
+      {
+        name: req.__("Agent action"),
+        form: async (context) => {
+          const agent_actions = await Trigger.find({ action: "Agent" });
+          return new Form({
+            fields: [
+              {
+                name: "action_id",
+                label: "Agent action",
+                type: "String",
+                required: true,
+                attributes: {
+                  options: agent_actions.map((a) => ({
+                    label: a.name,
+                    name: a.id,
+                  })),
+                },
+                sublabel:
+                  "A trigger with <code>Agent</code> action. " +
+                  a(
+                    {
+                      "data-dyn-href": `\`/actions/configure/\${action_id}\``,
+                      target: "_blank",
+                    },
+                    req.__("Configure")
+                  ),
+              },
+              {
+                name: "show_prev_runs",
+                label: "Show previous runs",
+                type: "Bool",
+              },
+            ],
+          });
+        },
+      },
+    ],
+  });
+
+const get_state_fields = () => [];
+
+const run = async (
+  table_id,
+  viewname,
+  { action_id, show_prev_runs },
+  state,
+  { res, req }
+) => {
+  const action = await Trigger.findOne({ id: action_id });
+  const prevRuns = (
+    await WorkflowRun.find(
+      { trigger_id: action.id, started_by: req.user?.id },
+      { orderBy: "started_at", orderDesc: true, limit: 30 }
+    )
+  ).filter((r) => r.context.interactions);
+
+  const cfgMsg = incompleteCfgMsg();
+  if (cfgMsg) return cfgMsg;
+  let runInteractions = "";
+  if (state.run_id) {
+    const run = prevRuns.find((r) => r.id == state.run_id);
+    const interactMarkups = [];
+    for (const interact of run.context.interactions) {
+      switch (interact.role) {
+        case "user":
+          interactMarkups.push(
+            div(
+              { class: "interaction-segment" },
+              span({ class: "badge bg-secondary" }, "You"),
+              md.render(interact.content)
+            )
+          );
+          break;
+        case "assistant":
+        case "system":
+          if (interact.tool_calls) {
+            if (interact.content) {
+              interactMarkups.push(
+                div(
+                  { class: "interaction-segment" },
+                  span({ class: "badge bg-secondary" }, "Copilot"),
+                  typeof interact.content === "string"
+                    ? md.render(interact.content)
+                    : interact.content
+                )
+              );
+            }
+            for (const tool_call of interact.tool_calls) {
+              const toolSkill = find_tool(
+                tool_call.function.name,
+                action.configuration
+              );
+              if (toolSkill) {
+                const row = JSON.parse(tool_call.function.arguments);
+                if (toolSkill.tool.renderToolCall) {
+                  const rendered = await toolSkill.tool.renderToolCall(row, {
+                    req,
+                  });
+                  if (rendered)
+                    interactMarkups.push(
+                      wrapSegment(
+                        wrapCard(
+                          toolSkill.skill.skill_label ||
+                            toolSkill.skill.constructor.skill_name,
+                          rendered
+                        ),
+                        "Copilot"
+                      )
+                    );
+                }
+              }
+            }
+          } else
+            interactMarkups.push(
+              div(
+                { class: "interaction-segment" },
+                span({ class: "badge bg-secondary" }, "Copilot"),
+                typeof interact.content === "string"
+                  ? md.render(interact.content)
+                  : interact.content
+              )
+            );
+          break;
+        case "tool":
+          if (interact.content !== "Action run") {
+            let markupContent;
+            console.log("interact", interact);
+            const toolSkill = find_tool(interact.name, action.configuration);
+            try {
+              if (toolSkill?.tool?.renderToolResponse)
+                markupContent = await toolSkill?.tool?.renderToolResponse?.(
+                  JSON.parse(interact.content),
+                  {
+                    req,
+                  }
+                );
+            } catch {
+              markupContent = pre(interact.content);
+            }
+            if (markupContent)
+              interactMarkups.push(
+                wrapSegment(
+                  wrapCard(
+                    toolSkill?.skill?.skill_label ||
+                      toolSkill?.skill?.constructor.skill_name ||
+                      interact.name,
+                    markupContent
+                  ),
+                  "Copilot"
+                )
+              );
+          }
+          break;
+      }
+    }
+    runInteractions = interactMarkups.join("");
+  }
+  const input_form = form(
+    {
+      onsubmit: `event.preventDefault();spin_send_button();view_post('${viewname}', 'interact', $(this).serialize(), processCopilotResponse);return false;`,
+      class: "form-namespace copilot mt-2",
+      method: "post",
+    },
+    input({
+      type: "hidden",
+      name: "_csrf",
+      value: req.csrfToken(),
+    }),
+    input({
+      type: "hidden",
+      class: "form-control  ",
+      name: "run_id",
+      value: state.run_id ? +state.run_id : undefined,
+    }),
+    div(
+      { class: "copilot-entry" },
+      textarea({
+        class: "form-control",
+        name: "userinput",
+        "data-fieldname": "userinput",
+        placeholder: "How can I help you?",
+        id: "inputuserinput",
+        rows: "3",
+        autofocus: true,
+      }),
+      span(
+        { class: "submit-button p-2", onclick: "$('form.copilot').submit()" },
+        i({ id: "sendbuttonicon", class: "far fa-paper-plane" })
+      )
+    )
+  );
+
+  const prev_runs_side_bar = div(
+    div(
+      {
+        class: "d-flex justify-content-between align-middle mb-2",
+      },
+      h5("Sessions"),
+
+      button(
+        {
+          type: "button",
+          class: "btn btn-secondary btn-sm py-0",
+          style: "font-size: 0.9em;height:1.5em",
+          onclick: "unset_state_field('run_id')",
+          title: "New session",
+        },
+        i({ class: "fas fa-redo fa-sm" })
+      )
+    ),
+    prevRuns.map((run) =>
+      div(
+        {
+          onclick: `set_state_field('run_id',${run.id})`,
+          class: "prevcopilotrun border p-2",
+        },
+        div(
+          { class: "d-flex justify-content-between" },
+          localeDateTime(run.started_at),
+          i({
+            class: "far fa-trash-alt",
+            onclick: `delprevrun(event, ${run.id})`,
+          })
+        ),
+
+        p({ class: "prevrun_content" }, run.context.interactions[0]?.content)
+      )
+    )
+  );
+  const main_chat = div(
+    { class: "card" },
+    div(
+      { class: "card-body" },
+      script({
+        src: `/static_assets/${db.connectObj.version_tag}/mermaid.min.js`,
+      }),
+      script(
+        { type: "module" },
+        `mermaid.initialize({securityLevel: 'loose'${
+          getState().getLightDarkMode(req.user) === "dark"
+            ? ",theme: 'dark',"
+            : ""
+        }});`
+      ),
+      div({ id: "copilotinteractions" }, runInteractions),
+      input_form,
+      style(
+        `div.interaction-segment:not(:first-child) {border-top: 1px solid #e7e7e7; }
+              div.interaction-segment {padding-top: 5px;padding-bottom: 5px;}
+              div.interaction-segment p {margin-bottom: 0px;}
+              div.interaction-segment div.card {margin-top: 0.5rem;}            
+            div.prevcopilotrun:hover {cursor: pointer; background-color: var(--tblr-secondary-bg-subtle, var(--bs-secondary-bg-subtle, gray));}
+            div.prevcopilotrun i.fa-trash-alt {display: none;}
+            div.prevcopilotrun:hover i.fa-trash-alt {display: block;}
+            .copilot-entry .submit-button:hover { cursor: pointer}
+
+            .copilot-entry .submit-button {
+              position: relative; 
+              top: -1.8rem;
+              left: 0.1rem;              
+            }
+            .copilot-entry {margin-bottom: -1.25rem; margin-top: 1rem;}
+            p.prevrun_content {
+               white-space: nowrap;
+    overflow: hidden;
+    margin-bottom: 0px;
+    display: block;
+    text-overflow: ellipsis;}`
+      ),
+      script(`function processCopilotResponse(res) {
+        $("#sendbuttonicon").attr("class","far fa-paper-plane");
+        const $runidin= $("input[name=run_id")
+        if(res.run_id && (!$runidin.val() || $runidin.val()=="undefined"))
+          $runidin.val(res.run_id);
+        const wrapSegment = (html, who) => '<div class="interaction-segment"><span class="badge bg-secondary">'+who+'</span>'+html+'</div>'
+        $("#copilotinteractions").append(wrapSegment('<p>'+$("textarea[name=userinput]").val()+'</p>', "You"))
+        $("textarea[name=userinput]").val("")      
+
+        if(res.response)
+            $("#copilotinteractions").append(res.response)
+    }
+    function restore_old_button_elem(btn) {
+        const oldText = $(btn).data("old-text");
+        btn.html(oldText);
+        btn.css({ width: "" }).prop("disabled", false);
+        btn.removeData("old-text");
+    }
+    function delprevrun(e, runid) {
+        e.preventDefault();
+        e.stopPropagation();
+        view_post('${viewname}', 'delprevrun', {run_id:runid})
+        $(e.target).closest(".prevcopilotrun").remove()
+        return false;
+    }
+    function processExecuteResponse(res) {
+        const btn = $("#exec-"+res.fcall_id)
+        restore_old_button_elem($("#exec-"+res.fcall_id))
+        btn.prop('disabled', true);
+        btn.html('<i class="fas fa-check me-1"></i>Applied')
+        btn.removeClass("btn-primary")
+        btn.addClass("btn-secondary")
+        if(res.postExec) {
+          $('#postexec-'+res.fcall_id).html(res.postExec)
+        }
+    }
+    function submitOnEnter(event) {
+        if (event.which === 13) {
+            if (!event.repeat) {
+                const newEvent = new Event("submit", {cancelable: true});
+                event.target.form.dispatchEvent(newEvent);
+            }
+
+            event.preventDefault(); // Prevents the addition of a new line in the text field
+        }        
+    }
+    document.getElementById("inputuserinput").addEventListener("keydown", submitOnEnter);
+    function spin_send_button() {
+      $("#sendbuttonicon").attr("class","fas fa-spinner fa-spin");
+    }
+`)
+    )
+  );
+  return show_prev_runs
+    ? {
+        widths: [3, 9],
+        gx: 3,
+        besides: [
+          {
+            type: "container",
+            contents: prev_runs_side_bar,
+          },
+          {
+            type: "container",
+            contents: main_chat,
+          },
+        ],
+      }
+    : main_chat;
+};
+
+/*
+
+build a workflow that asks the user for their name and age
+
+*/
+
+const interact = async (table_id, viewname, config, body, { req, res }) => {
+  const { userinput, run_id } = body;
+  let run;
+  if (!run_id || run_id === "undefined")
+    run = await WorkflowRun.create({
+      status: "Running",
+      started_by: req.user?.id,
+      trigger_id: config.action_id,
+      context: {
+        implemented_fcall_ids: [],
+        interactions: [{ role: "user", content: userinput }],
+        funcalls: {},
+      },
+    });
+  else {
+    run = await WorkflowRun.findOne({ id: +run_id });
+    await addToContext(run, {
+      interactions: [{ role: "user", content: userinput }],
+    });
+  }
+  return await process_interaction(run, config, req);
+};
+
+const delprevrun = async (table_id, viewname, config, body, { req, res }) => {
+  const { run_id } = body;
+  let run;
+
+  run = await WorkflowRun.findOne({ id: +run_id });
+  if (req.user?.role_id === 1 || req.user?.id === run.started_by)
+    await run.delete();
+
+  return;
+};
+
+const process_interaction = async (run, config, req, prevResponses = []) => {
+  const action = await Trigger.findOne({ id: config.action_id });
+  const complArgs = await getCompletionArguments(action.configuration);
+  complArgs.chat = run.context.interactions;
+  //complArgs.debugResult = true;
+  console.log("complArgs", JSON.stringify(complArgs, null, 2));
+
+  const answer = await getState().functions.llm_generate.run("", complArgs);
+  console.log("answer", answer);
+  await addToContext(run, {
+    interactions:
+      typeof answer === "object" && answer.tool_calls
+        ? [
+            {
+              role: "assistant",
+              tool_calls: answer.tool_calls,
+              content: answer.content,
+            },
+          ]
+        : [{ role: "assistant", content: answer }],
+  });
+  const responses = [];
+
+  if (typeof answer === "object" && answer.tool_calls) {
+    if (answer.content)
+      responses.push(wrapSegment(md.render(answer.content), "Copilot"));
+    //const actions = [];
+    let hasResult = false;
+    for (const tool_call of answer.tool_calls) {
+      console.log("call function", tool_call.function);
+
+      await addToContext(run, {
+        funcalls: { [tool_call.id]: tool_call.function },
+      });
+
+      const tool = find_tool(tool_call.function.name, action.configuration);
+
+      if (tool) {
+        if (tool.tool.renderToolCall) {
+          const row = JSON.parse(tool_call.function.arguments);
+          const rendered = await tool.tool.renderToolCall(row, {
+            req,
+          });
+          if (rendered)
+            responses.push(
+              wrapSegment(
+                wrapCard(
+                  tool.skill.skill_label || tool.skill.constructor.skill_name,
+                  rendered
+                ),
+                "Copilot"
+              )
+            );
+        }
+        hasResult = true;
+        const result = await tool.tool.process(
+          JSON.parse(tool_call.function.arguments)
+        );
+        if (
+          (typeof result === "object" && Object.keys(result || {}).length) ||
+          typeof result === "string"
+        ) {
+          if (tool.tool.renderToolResponse) {
+            const rendered = await tool.tool.renderToolResponse(result, {
+              req,
+            });
+            if (rendered)
+              responses.push(
+                wrapSegment(
+                  wrapCard(
+                    tool.skill.skill_label || tool.skill.constructor.skill_name,
+                    rendered
+                  ),
+                  "Copilot"
+                )
+              );
+          }
+          hasResult = true;
+        }
+        await addToContext(run, {
+          interactions: [
+            {
+              role: "tool",
+              tool_call_id: tool_call.id,
+              name: tool_call.function.name,
+              content:
+                result && typeof result !== "string"
+                  ? JSON.stringify(result)
+                  : result || "Action run",
+            },
+          ],
+        });
+      }
+    }
+    if (hasResult)
+      return await process_interaction(run, config, req, [
+        ...prevResponses,
+        ...responses,
+      ]);
+  } else responses.push(wrapSegment(md.render(answer), "Copilot"));
+
+  return {
+    json: {
+      success: "ok",
+      response: [...prevResponses, ...responses].join(""),
+      run_id: run.id,
+    },
+  };
+};
+
+const wrapSegment = (html, who) =>
+  '<div class="interaction-segment"><span class="badge bg-secondary">' +
+  who +
+  "</span>" +
+  html +
+  "</div>";
+
+const wrapCard = (title, ...inners) =>
+  span({ class: "badge bg-info ms-1" }, title) +
+  div(
+    { class: "card mb-3 bg-secondary-subtle" },
+    div({ class: "card-body" }, inners)
+  );
+
+const wrapAction = (
+  inner_markup,
+  viewname,
+  tool_call,
+  actionClass,
+  implemented,
+  run
+) =>
+  wrapCard(
+    actionClass.title,
+    inner_markup + implemented
+      ? button(
+          {
+            type: "button",
+            class: "btn btn-secondary d-block mt-3 float-end",
+            disabled: true,
+          },
+          i({ class: "fas fa-check me-1" }),
+          "Applied"
+        )
+      : button(
+          {
+            type: "button",
+            id: "exec-" + tool_call.id,
+            class: "btn btn-primary d-block mt-3 float-end",
+            onclick: `press_store_button(this, true);view_post('${viewname}', 'execute', {fcall_id: '${tool_call.id}', run_id: ${run.id}}, processExecuteResponse)`,
+          },
+          "Apply"
+        ) + div({ id: "postexec-" + tool_call.id })
+  );
+
+const addToContext = async (run, newCtx) => {
+  if (run.addToContext) return await run.addToContext(newCtx);
+  let changed = true;
+  Object.keys(newCtx).forEach((k) => {
+    if (Array.isArray(run.context[k])) {
+      if (!Array.isArray(newCtx[k]))
+        throw new Error("Must be array to append to array");
+      run.context[k].push(...newCtx[k]);
+      changed = true;
+    } else if (typeof run.context[k] === "object") {
+      if (typeof newCtx[k] !== "object")
+        throw new Error("Must be object to append to object");
+      Object.assign(run.context[k], newCtx[k]);
+      changed = true;
+    } else {
+      run.context[k] = newCtx[k];
+      changed = true;
+    }
+  });
+  if (changed) await run.update({ context: run.context });
+};
+
+module.exports = {
+  name: "Agent Chat",
+  configuration_workflow,
+  display_state_form: false,
+  get_state_fields,
+  tableless: true,
+  run,
+  routes: { interact, delprevrun },
+};

package/common.js

@@ -0,0 +1,92 @@
+const { getState } = require("@saltcorn/data/db/state");
+
+const get_skills = () => {
+  return [
+    //require("./skills/EmbeddingRetrieval"),
+    require("./skills/FTSRetrieval"),
+    //require("./skills/AdaptiveFeedback"),
+  ];
+};
+
+const get_skill_class = (type) => {
+  const classes = get_skills();
+  return classes.find((c) => c.skill_name === type);
+};
+
+const get_skill_instances = (config) => {
+  const instances = [];
+  for (const skillCfg of config.skills) {
+    const klass = get_skill_class(skillCfg.skill_type);
+    const skill = new klass(skillCfg);
+    instances.push(skill);
+  }
+  return instances;
+};
+
+const find_tool = (name, config) => {
+  const skills = get_skill_instances(config);
+  for (const skill of skills) {
+    const skillTools = skill.provideTools();
+    const tools = !skillTools
+      ? []
+      : Array.isArray(skillTools)
+      ? skillTools
+      : [skillTools];
+    const found = tools.find((t) => t?.function.name === name);
+    if (found) return { tool: found, skill };
+  }
+};
+
+
+const getCompletionArguments = async (config) => {
+  let tools = [];
+
+  let sysPrompts = [config.sys_prompt];
+
+  const skills = get_skill_instances(config);
+  for (const skill of skills) {
+    const sysPr = skill.systemPrompt();
+    if (sysPr) sysPrompts.push(sysPr);
+    const skillTools = skill.provideTools();
+    if (skillTools && Array.isArray(skillTools)) tools.push(...skillTools);
+    else if (skillTools) tools.push(skillTools);
+  }
+  if (tools.length === 0) tools = undefined;
+  return { tools, systemPrompt: sysPrompts.join("\n\n") };
+};
+
+
+const getCompletion = async (language, prompt) => {
+  return getState().functions.llm_generate.run(prompt, {
+    systemPrompt: `You are a helpful code assistant. Your language of choice is ${language}. Do not include any explanation, just generate the code block itself.`,
+  });
+};
+
+const incompleteCfgMsg = () => {
+  const plugin_cfgs = getState().plugin_cfgs;
+
+  if (
+    !plugin_cfgs["@saltcorn/large-language-model"] &&
+    !plugin_cfgs["large-language-model"]
+  ) {
+    const modName = Object.keys(plugin_cfgs).find((m) =>
+      m.includes("large-language-model")
+    );
+    if (modName)
+      return `LLM module not configured. Please configure <a href="/plugins/configure/${encodeURIComponent(
+        modName
+      )}">here<a> before using copilot.`;
+    else
+      return `LLM module not configured. Please install and configure <a href="/plugins">here<a> before using copilot.`;
+  }
+};
+
+module.exports = {
+  get_skills,
+  get_skill_class,
+  incompleteCfgMsg,
+  getCompletion,
+  find_tool,
+  get_skill_instances,
+  getCompletionArguments
+};

package/index.js

@@ -0,0 +1,100 @@
+const Workflow = require("@saltcorn/data/models/workflow");
+const Form = require("@saltcorn/data/models/form");
+const FieldRepeat = require("@saltcorn/data/models/fieldrepeat");
+const { features } = require("@saltcorn/data/db/state");
+const { get_skills, getCompletionArguments } = require("./common");
+const { applyAsync } = require("@saltcorn/data/utils");
+const WorkflowRun = require("@saltcorn/data/models/workflow_run");
+const { interpolate } = require("@saltcorn/data/utils");
+const { getState } = require("@saltcorn/data/db/state");
+
+module.exports = {
+  sc_plugin_api_version: 1,
+  dependencies: ["@saltcorn/large-language-model"],
+  viewtemplates: [require("./agent-view")],
+  actions: {
+    Agent: {
+      disableInBuilder: true,
+      disableInList: true,
+      disableInWorkflow: true,
+      configFields: async ({ table, mode }) => {
+        const skills = get_skills();
+        const skills_fields = [];
+        for (const skill of skills) {
+          if (skill.configFields) {
+            const fields = await applyAsync(skill.configFields, undefined);
+            for (const field of fields) {
+              if (!field.showIf) field.showIf = {};
+              field.showIf.skill_type = skill.skill_name;
+              skills_fields.push(field);
+            }
+          }
+        }
+        return [
+          ...(table
+            ? [
+                {
+                  name: "prompt",
+                  label: "Prompt",
+                  sublabel:
+                    "When triggered from table event or table view button. Use handlebars <code>{{}}</code> to access table fields. Ignored if run in Agent Chat view.",
+                  type: "String",
+                  required: true,
+                  attributes: { options: table.fields.map((f) => f.name) },
+                },
+              ]
+            : []),
+          {
+            name: "sys_prompt",
+            label: "System prompt",
+            sublabel: "Additional information for the system prompt",
+            type: "String",
+            fieldview: "textarea",
+          },
+
+          new FieldRepeat({
+            name: "skills",
+            label: "Skills",
+            fields: [
+              {
+                name: "skill_type",
+                label: "Type",
+                type: "String",
+                required: true,
+                attributes: { options: skills.map((s) => s.skill_name) },
+              },
+              ...skills_fields,
+            ],
+          }),
+        ];
+      },
+      run: async ({ configuration, user, row, trigger_id, ...rest }) => {
+        const userinput = interpolate(configuration.prompt, row, user);
+        const run = await WorkflowRun.create({
+          status: "Running",
+          started_by: user?.id,
+          trigger_id: trigger_id || undefined,
+          context: {
+            implemented_fcall_ids: [],
+            interactions: [{ role: "user", content: userinput }],
+            funcalls: {},
+          },
+        });
+        const complArgs = await getCompletionArguments(configuration);
+        const answer = await getState().functions.llm_generate.run(
+          "",
+          complArgs
+        );
+      },
+    },
+  },
+};
+
+/* 
+TODO
+
+-embedding retrieval
+-run as action
+-view: set placeholder, labels
+
+*/

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@saltcorn/agents",
+  "version": "0.1.0",
+  "description": "AI agents for Saltcorn",
+  "main": "index.js",
+  "dependencies": {
+    "@saltcorn/data": "^0.9.0",
+    "underscore": "1.13.6",
+    "node-sql-parser": "4.15.0",
+    "markdown-it": "14.1.0",
+    "style-to-object": "1.0.8",
+    "node-html-parser": "7.0.1"
+  },
+  "author": "Tom Nielsen",
+  "license": "MIT",
+  "repository": "github:saltcorn/agents",
+  "eslintConfig": {
+    "extends": "eslint:recommended",
+    "parserOptions": {
+      "ecmaVersion": 2022
+    },
+    "env": {
+      "node": true,
+      "es6": true
+    },
+    "rules": {
+      "no-unused-vars": "off",
+      "no-case-declarations": "off",
+      "no-empty": "warn",
+      "no-fallthrough": "warn"
+    }
+  }
+}

package/skills/AdaptiveFeedback.js

@@ -0,0 +1,21 @@
+const Workflow = require("@saltcorn/data/models/workflow");
+const Form = require("@saltcorn/data/models/form");
+
+class AdaptiveFeedback {
+  static skill_name = "Adaptive Feedback";
+  static async configFields() {
+    return [
+      {
+        name: "label",
+        label: "Label",
+        type: "String",
+      },
+    ];
+  }
+
+  onEvolve() {}
+
+  provideTools() {}
+}
+
+module.exports = AdaptiveFeedback;

package/skills/EmbeddingRetrieval.js

@@ -0,0 +1,149 @@
+const { div } = 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");
+
+class RetrievalByEmbedding {
+  static skill_name = "Retrieval by embedding";
+
+  constructor(cfg) {
+    Object.assign(this, cfg);
+  }
+
+  get toolName() {
+    return `search_${this.table_name.replaceAll(" ", "")}`;
+  }
+
+  systemPrompt() {
+    if (this.mode === "Tool") {
+      const table = Table.findOne(this.vec_field.split["."][0]);
+
+      return `Use the ${this.toolName} tool to search an archive named ${
+        table.name
+      }${
+        table.description ? ` (${table.description})` : ""
+      } for documents related to a search phrase or a question`;
+    }
+  }
+
+  static async configFields() {
+    const allTables = await Table.find();
+    const tableOpts = [];
+    const relation_opts = {};
+    const list_view_opts = {};
+    for (const table of allTables) {
+      table.fields
+        .filter((f) => f.type?.name === "PGVector")
+        .forEach((f) => {
+          const relNm = `${table.name}.${f.name}`;
+          tableOpts.push(relNm);
+          const fkeys = table.fields
+            .filter((f) => f.is_fkey)
+            .map((f) => f.name);
+          relation_opts[relNm] = ["", ...fkeys];
+          
+          list_view_opts[relNm] = []
+        });
+    }
+    return [
+      {
+        name: "mode",
+        label: "Mode",
+        type: "String",
+        required: true,
+        attributes: { options: ["Tool", "Search on every user input"] },
+      },
+      {
+        name: "vec_field",
+        label: "Vector field",
+        sublabel: "Field to search for vector similarity",
+        type: "String",
+        required: true,
+        attributes: { options: tableOpts },
+      },
+      {
+        name: "doc_relation",
+        label: "Document relation",
+        sublabel:
+          "Optional. For each vector match, retrieve row in the table related by this key instead",
+        type: "String",
+        required: true,
+        attributes: { calcOptions: ["vec_field", relation_opts] },
+      },
+       {
+        name: "list_view",
+        label: "List view",
+        type: "String",
+        attributes: {
+          calcOptions: ["vec_field", list_view_opts],
+        },
+      },
+      {
+        name: "contents_expr",
+        label: "Contents string",
+        type: "String",
+        sublabel:
+          "Use handlebars (<code>{{ }}</code>) to access fields in the retrieved rows",
+      },
+    ];
+  }
+
+  onMessage(msgs) {
+    if (this.mode !== "Search on every user input") return;
+  }
+
+  provideTools() {
+    if (this.mode !== "Tool") return [];
+    const table0 = Table.findOne(this.vec_field.split["."][0]);
+    const table_docs = this.doc_relation
+      ? Table.findOne(table0.getField(this.doc_relation).reftable_name)
+      : table0;
+    return {
+      type: "function",
+      process({ phrase_or_question }) {
+        return {
+          response: "There are no documents related to: " + phrase_or_question,
+        };
+      },
+      renderToolResponse: async ({ response, rows }, { req }) => {
+        if (rows) {
+          const view = View.findOne({ name: this.list_view });
+
+          if (view) {
+            const viewRes = await view.run(
+              {
+                [table_docs.pk_name]: {
+                  in: rows.map((r) => r[table_docs.pk_name]),
+                },
+              },
+              { req }
+            );
+            return viewRes;
+          } else return "";
+        }
+        return div({ class: "border border-success p-2 m-2" }, response);
+      },
+      function: {
+        name: this.toolName,
+        description: `Search the ${table_docs.name``} archive${
+          table_docs.description ? ` (${table_docs.description})` : ""
+        } for information related to a search phrase or a question. The relevant documents will be returned`,
+        parameters: {
+          type: "object",
+          required: ["phrase_or_question"],
+          properties: {
+            phrase_or_question: {
+              type: "string",
+              description: "The phrase or question to search the archive with",
+            },
+          },
+        },
+      },
+    };
+  }
+}
+
+module.exports = RetrievalByEmbedding;

package/skills/FTSRetrieval.js

@@ -0,0 +1,157 @@
+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");
+
+class RetrievalByFullTextSearch {
+  static skill_name = "Retrieval by full-text search";
+
+  get skill_label() {
+    return `Search ${this.table_name}`;
+  }
+
+  constructor(cfg) {
+    Object.assign(this, cfg);
+  }
+
+  get toolName() {
+    return `search_${this.table_name.replaceAll(" ", "")}`;
+  }
+
+  systemPrompt() {
+    if (this.mode === "Tool")
+      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`;
+  }
+
+  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: "mode",
+        label: "Mode",
+        type: "String",
+        required: true,
+        attributes: { options: ["Tool", "Search on every user input"] },
+      },
+      {
+        name: "table_name",
+        label: "Table",
+        sublabel: "Which table to search",
+        type: "String",
+        required: true,
+        attributes: { options: allTables.map((t) => t.name) },
+      },
+      {
+        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",
+      },
+      /*{
+        name: "contents_expr",
+        label: "Contents string",
+        type: "String",
+        sublabel:
+          "Use handlebars (<code>{{ }}</code>) to access fields in the retrieved rows",
+      },*/
+    ];
+  }
+
+  onMessage(msgs) {
+    if (this.mode !== "Search on every user input") return;
+  }
+
+  provideTools() {
+    if (this.mode !== "Tool") return [];
+    const table = Table.findOne(this.table_name);
+    return {
+      type: "function",
+      process: async ({ phrase }) => {
+        const scState = getState();
+        const language = scState.pg_ts_config;
+        const use_websearch = scState.getConfig("search_use_websearch", false);
+        const rows = await table.getRows({
+          _fts: {
+            fields: table.fields,
+            searchTerm: phrase,
+            language,
+            use_websearch,
+            table: table.name,
+            schema: db.isSQLite ? undefined : db.getTenantSchema(),
+          },
+        });
+        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: "There are no rows related to: " + phrase,
+          };
+      },
+      /*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: this.toolName,
+        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. The retrieved rows will be returned`,
+        parameters: {
+          type: "object",
+          required: ["phrase"],
+          properties: {
+            phrase: {
+              type: "string",
+              description: "The phrase to search the table with",
+            },
+          },
+        },
+      },
+    };
+  }
+}
+
+module.exports = RetrievalByFullTextSearch;