@saltcorn/agents 0.8.4 → 0.8.6

package/agent-view.js

@@ -49,6 +49,7 @@ const {
   get_initial_interactions,
   get_skill_instances,
   saveInteractions,
+  extractText,
 } = require("./common");
 const MarkdownIt = require("markdown-it"),
   md = new MarkdownIt({ html: true, breaks: true, linkify: true });
@@ -306,12 +307,13 @@ const run = async (
           },
           { orderBy: "started_at", orderDesc: true, limit: 30 },
         )
-      ).filter((r) => r.context.interactions)
+      ).filter((r) => r.context.interactions || r.context.html_interactions)
     : null;
 
   const cfgMsg = incompleteCfgMsg();
   if (cfgMsg) return cfgMsg;
   let runInteractions = "";
+  let hasInputForm = true;
 
   const initial_q = state.run_id ? undefined : state._q;
   if (state.run_id) {
@@ -325,6 +327,9 @@ const run = async (
     const interactMarkups = [];
     if (run.context.html_interactions) {
       interactMarkups.push(...run.context.html_interactions);
+      // no input if interactions deleted
+      if (!run.context.interactions && run.context.html_interactions.length)
+        hasInputForm = false;
     } else
       for (const interact of run.context.interactions) {
         //legacy
@@ -596,11 +601,11 @@ const run = async (
             ),
         prevRuns.map((run) => {
           const isActive = state.run_id && +state.run_id === run.id;
-          const preview = escapeHtml(
-            run.context.interactions
-              .find((ix) => typeof ix?.content === "string")
-              ?.content?.substring?.(0, 80),
-          );
+          const previewHtml =
+            (run.context.interactions || []).find(
+              (ix) => typeof ix?.content === "string",
+            )?.content || extractText(run.context.html_interactions[0] || "");
+          const preview = escapeHtml(previewHtml?.substring?.(0, 80));
           return isModernSidebar
             ? div(
                 {
@@ -661,7 +666,7 @@ const run = async (
     ),
     div({ id: "copilotinteractions" }, runInteractions),
     stream ? div({ class: "next_response_scratch" }) : "",
-    input_form,
+    hasInputForm && input_form,
     style(agents_css),
     script(domReady(`$( "#inputuserinput" ).autogrow({paddingBottom: 20});`)),
     script(

package/agents.css

@@ -149,7 +149,7 @@ p.prevrun_content {
   height: 100%;
 }
 .modern-chat-layout #copilotinteractions {
-  max-height: 70vh;
+  /*max-height: 70vh;*/
   overflow-y: auto;
   padding: 1rem;
   display: flex;

package/common.js

@@ -43,6 +43,7 @@ const get_skills = () => {
     require("./skills/Subagent"),
     require("./skills/ExternalSkill"),
     require("./skills/PlanApproval"),
+    require("./skills/LongTermMemory"),
     //require("./skills/AdaptiveFeedback"),
     ...exchange_skills,
   ];
@@ -57,8 +58,10 @@ 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);
+    if (klass) {
+      const skill = new klass(skillCfg);
+      instances.push(skill);
+    }
   }
   return instances;
 };
@@ -237,6 +240,10 @@ const wrapCard = (title, ...inners) =>
 
 const is_debug_mode = (config, user) => user?.role_id === 1;
 
+function extractText(html) {
+  return html.replace(/<[^>]*>/g, '');
+}
+
 const process_interaction = async (
   run,
   config,
@@ -414,6 +421,7 @@ const process_interaction = async (
           myHasResult = true;
           let result = await tool.tool.process(tool_call.input, {
             req,
+            run,
           });
           const tool_response = result.add_response || result;
           toolResults[tool_call.tool_call_id] = result;
@@ -744,4 +752,5 @@ module.exports = {
   is_debug_mode,
   get_initial_interactions,
   nubBy,
+  extractText
 };

package/consolidate_agent_memory.js

@@ -0,0 +1,65 @@
+const FieldRepeat = require("@saltcorn/data/models/fieldrepeat");
+const Table = require("@saltcorn/data/models/table");
+const View = require("@saltcorn/data/models/view");
+const { p } = require("@saltcorn/markup/tags");
+const { get_skills, process_interaction, wrapSegment } = require("./common");
+const { applyAsync } = require("@saltcorn/data/utils");
+const WorkflowRun = require("@saltcorn/data/models/workflow_run");
+const { interpolate, escapeHtml } = require("@saltcorn/data/utils");
+const { getState } = require("@saltcorn/data/db/state");
+
+module.exports = {
+  //configFields: async ({ table, mode }) => [],
+  run: async ({ configuration, user, table, req, ...rest }) => {
+    const memtable = Table.findOne("AgentLongTermMemory");
+    if (!memtable) return;
+    // write personal preferences
+
+    // get all personal observations
+    const personalmems = await memtable.getRows(
+      { personal: true },
+      { orderBy: "written_at" },
+    );
+
+    const user_ids = new Set(personalmems.map((p) => p.user_id));
+
+    for (const uid of user_ids.values()) {
+      const all_umems = personalmems.filter((m) => m.user_id === uid);
+      const existingPP = all_umems.find(
+        (m) => m.memory_type === "PersonalPreferences",
+      );
+      const nonPPs = all_umems.filter(
+        (m) => m.memory_type !== "PersonalPreferences",
+      );
+
+      if (
+        existingPP &&
+        nonPPs.every((m) => m.written_at < existingPP.written_at)
+      )
+        continue; // no new memories
+      const prompt = `This is a set of observations about a user:
+${nonPPs.map((m) => `* ${m.contents}`).join("\n")}
+
+They are in ascending chronological order so if there are any contradictions, the latter observation take precedence.
+
+Write a succinct summary of these observations which captures all the essential facts. Start the summary with the words
+"The user..." (in the language in which the observations appear) and then write what you have learned about the user.`;
+
+      const answer = await getState().functions.llm_generate.run(prompt);
+
+      if (answer && typeof answer === "string") {
+        await memtable.deleteRows({
+          memory_type: "PersonalPreferences",
+          user_id: uid,
+        });
+        await memtable.insertRow({
+          user_id: uid,
+          written_at: new Date(),
+          memory_type: "PersonalPreferences",
+          contents: answer,
+          personal: true,
+        });
+      }
+    }
+  },
+};

package/index.js

@@ -36,6 +36,7 @@ module.exports = {
   ],
   actions: {
     Agent: require("./action"),
+    consolidate_agent_memory: require("./consolidate_agent_memory"),
   },
   functions: {
     inspect_agent: {
@@ -69,6 +70,7 @@ module.exports = {
         };
       },
       isAsync: true,
+      hidden: true,
       description: "Return system prompt, tools and action of an agent",
     },
     agent_generate: {
@@ -115,6 +117,7 @@ module.exports = {
         };
       },
       isAsync: true,
+      hidden: true,
       description: "Run an agent on a prompt",
       arguments: [
         { name: "agent_name", type: "String" },

package/package.json

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

package/skills/Fetch.js

@@ -15,9 +15,69 @@ const { features } = require("@saltcorn/data/db/state");
 const { button } = require("@saltcorn/markup/tags");
 const { validID } = require("@saltcorn/markup/layout_utils");
 
-const vm = require("vm");
+class CookieJar {
+  constructor(source) {
+    this.cookies = new Map();
 
-//const { fieldProperties } = require("./helpers");
+    if (source instanceof CookieJar) {
+      // Copy from another CookieJar instance
+      for (const [name, value] of source.cookies) {
+        this.cookies.set(name, value);
+      }
+    } else if (source && typeof source === "object") {
+      // Hydrate from a plain object (e.g. output of toObject())
+      for (const [name, value] of Object.entries(source)) {
+        this.cookies.set(name, String(value));
+      }
+    }
+    // If source is undefined/null, start empty
+  }
+
+  // Parse Set-Cookie headers from a response and store them
+  storeFromResponse(response) {
+    const setCookieHeaders = response.headers.getSetCookie
+      ? response.headers.getSetCookie()
+      : [response.headers.get("set-cookie")].filter(Boolean);
+
+    for (const header of setCookieHeaders) {
+      this._parseAndStore(header);
+    }
+  }
+
+  // Parse a single "name=value; Path=/; HttpOnly; ..." string
+  _parseAndStore(header) {
+    const [nameValue] = header.split(";");
+    const eqIdx = nameValue.indexOf("=");
+    if (eqIdx > 0) {
+      const name = nameValue.slice(0, eqIdx).trim();
+      const value = nameValue.slice(eqIdx + 1).trim();
+      this.cookies.set(name, value);
+    }
+  }
+
+  // Build a Cookie header string suitable for outgoing requests
+  toHeader() {
+    return Array.from(this.cookies.entries())
+      .map(([name, value]) => `${name}=${value}`)
+      .join("; ");
+  }
+
+  // Apply cookies to a headers object (mutates and returns it)
+  applyTo(headers = {}) {
+    if (this.cookies.size > 0) {
+      headers["Cookie"] = this.toHeader();
+    }
+    return headers;
+  }
+
+  get size() {
+    return this.cookies.size;
+  }
+
+  toObject() {
+    return Object.fromEntries(this.cookies);
+  }
+}
 
 class FetchSkill {
   static skill_name = "Fetch";
@@ -31,7 +91,7 @@ class FetchSkill {
   }
 
   static async configFields() {
-    return [];
+    return [{ name: "cookiejar", label: "Cookie Jar", type: "Bool" }];
   }
   systemPrompt() {
     return "If you need to retrieve the contents of a web page, use the fetch_web_page to make a GET request to a specified URL.";
@@ -40,8 +100,29 @@ class FetchSkill {
   provideTools = () => {
     return {
       type: "function",
-      process: async (row) => {
-        const resp = await fetch(row.url);
+      process: async (row, { run }) => {
+        const opts = { headers: {} };
+        const jar = new CookieJar(run.context.cookiejar || {});
+        if (this.cookiejar) {
+          opts.headers = jar.applyTo();
+          opts.credentials = "same-origin";
+          opts.redirect = "manual";
+        }
+
+        if (row.method) opts.method = row.method;
+        if (row.content_type) opts.headers["Content-Type"] = row.content_type;
+        if (row.body) opts.body = row.body;
+
+        let resp = await fetch(row.url, opts);
+        if (resp.status == 302 && (!row.method || row.method === "GET")) {
+          if (this.cookiejar) jar.storeFromResponse(resp);
+          resp = await fetch(resp.headers.get("location"), opts);
+        }
+
+        if (this.cookiejar) {
+          jar.storeFromResponse(resp);
+          run.context.cookiejar = jar.toObject();
+        }
         return await resp.text();
       },
       function: {
@@ -55,6 +136,20 @@ class FetchSkill {
               description: "The URL to fetch with HTTP",
               type: "string",
             },
+            method: {
+              description: "The HTTP method",
+              type: "string",
+              enum: ["GET", "POST", "PUT", "DELETE"],
+            },
+            body: {
+              description: "The request body as a string (POST and PUT only)",
+              type: "string",
+            },
+            content_type: {
+              description:
+                "The request body content type, e.g. application/x-www-form-urlencoded or application/json (POST and PUT only)",
+              type: "string",
+            },
           },
         },
       },

package/skills/LongTermMemory.js

@@ -0,0 +1,247 @@
+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 Field = require("@saltcorn/data/models/field");
+const View = require("@saltcorn/data/models/view");
+const { getState } = require("@saltcorn/data/db/state");
+const db = require("@saltcorn/data/db");
+const { interpolate } = require("@saltcorn/data/utils");
+const { nubBy } = require("../common");
+
+class LongTermMemory {
+  static skill_name = "Memory";
+
+  get skill_label() {
+    return `Memory`;
+  }
+
+  constructor(cfg) {
+    Object.assign(this, cfg);
+  }
+
+  async systemPrompt({ user }) {
+    let pp = "";
+    if (this.inject_personal_prefs && user?.id) {
+      const table = Table.findOne("AgentLongTermMemory");
+      if (table) {
+        const ppRow = await table.getRow({
+          memory_type: "PersonalPreferences",
+          user_id: user.id,
+        });
+        if (ppRow) pp = "\n\n" + ppRow.contents;
+      }
+    }
+    return `You have access to a memory bank you can read from or write to. You should search the memory bank with the search_memory tool with any search terms that might be relevant to the user's query or the result of a tool call. When you learn something noteworthy (from the user or from the result of a tool call) store it in memory with the store_in_memory tool. Mark it as personal if it is only true or relevant for the specific user. Don't tell the user when you are storing to and retrieving from memory. ${
+      this.add_sys_prompt
+        ? ` Additional instructions for the memory tools: ${this.add_sys_prompt}`
+        : ""
+    }${pp}`;
+  }
+
+  static async configFields() {
+    return [
+      {
+        name: "add_sys_prompt",
+        label: "Additional prompt",
+        type: "String",
+        fieldview: "textarea",
+      },
+      {
+        name: "inject_personal_prefs",
+        label: "Personal preferences",
+        type: "Bool",
+        sublabel:
+          "Inject personal preferences generated by the consolidate_agent_memory action in the system prompt",
+      },
+    ];
+  }
+
+  async get_table() {
+    const table0 = Table.findOne("AgentLongTermMemory");
+    if (table0) return table0;
+    const tables = await Table.find({ name: "AgentLongTermMemory" });
+    if (tables.length) return tables[0];
+
+    //does not exist, create it
+    const table = await Table.create("AgentLongTermMemory", {});
+    await getState().refresh_tables(true);
+    await Field.create({
+      table,
+      name: "run_id",
+      label: "Run ID",
+      type: "Integer",
+    });
+    const uid_field = await Field.create({
+      table,
+      name: "user_id",
+      label: "User ID",
+      type: "Key to users",
+      attributes: {
+        on_delete: "Set null",
+        include_fts: false,
+        summary_field: "email",
+      },
+    });
+    await Field.create({
+      table,
+      name: "written_at",
+      label: "Written at",
+      type: "Date",
+    });
+    await Field.create({
+      table,
+      name: "agent_trigger_id",
+      label: "Agent trigger ID",
+      type: "Integer",
+    });
+    await Field.create({
+      table,
+      name: "memory_type",
+      label: "Memory type",
+      type: "String",
+    });
+    await Field.create({
+      table,
+      name: "personal",
+      label: "Personal",
+      type: "Bool",
+    });
+    await Field.create({
+      table,
+      name: "topic",
+      label: "Topic",
+      type: "String",
+    });
+    await Field.create({
+      table,
+      name: "contents",
+      label: "Contents",
+      type: "String",
+    });
+    await table.update({ ownership_field_id: uid_field.id });
+    await getState().refresh_tables();
+    return Table.findOne("AgentLongTermMemory");
+  }
+
+  provideTools() {
+    return [
+      {
+        type: "function",
+        function: {
+          name: "store_in_memory",
+          description: `Store a fact or observation in long-term memory`,
+          parameters: {
+            type: "object",
+            required: ["contents"],
+            properties: {
+              contents: {
+                type: "string",
+                description: "The contents of the fact or observations",
+              },
+              personal: {
+                type: "boolean",
+                description:
+                  "Is this a fact or observation specifically about the person interacting with you now, which may not be true or relevant for another person",
+              },
+            },
+          },
+        },
+        process: async (arg, { req, run }) => {
+          const table = await this.get_table();
+          await table.insertRow({
+            run_id: run.id,
+            user_id: req.user?.id,
+            written_at: new Date(),
+            agent_trigger_id: run.trigger_id,
+            memory_type: "Episodic",
+            contents: arg.contents,
+            personal: arg.personal,
+          });
+          return "Recorded";
+        },
+      },
+      {
+        type: "function",
+        process: async (arg, { req }) => {
+          const table = await this.get_table();
+
+          const scState = getState();
+          const language = scState.pg_ts_config;
+          const use_websearch = scState.getConfig(
+            "search_use_websearch",
+            false,
+          );
+          let rows = [];
+          const user_id = req.user?.id;
+          const phrases =
+            typeof arg.phrases === "string" ? [arg.phrases] : arg.phrases;
+
+          if (use_websearch)
+            rows = await table.getRows({
+              _fts: {
+                fields: table.fields,
+                searchTerm: phrases.join(" OR "),
+                language,
+                use_websearch,
+                table: table.name,
+                schema: db.isSQLite ? undefined : db.getTenantSchema(),
+              },
+              ...(user_id
+                ? { or: [{ personal: false }, { personal: true, user_id }] }
+                : [{ personal: false }]),
+            });
+          else
+            for (const phrase of phrases) {
+              const my_rows = await table.getRows({
+                _fts: {
+                  fields: table.fields,
+                  searchTerm: phrase,
+                  language,
+                  use_websearch,
+                  table: table.name,
+                  schema: db.isSQLite ? undefined : db.getTenantSchema(),
+                },
+                ...(user_id
+                  ? { or: [{ personal: false }, { personal: true, user_id }] }
+                  : [{ personal: false }]),
+              });
+              rows.push(...my_rows);
+            }
+          const pk = table.pk_name;
+          rows = nubBy((r) => r[pk], rows);
+          //TODO sort most recent, only N memories
+          if (rows.length)
+            return (
+              "These memories were retrieved:\n\n" +
+              rows.map((r) => r.contents).join("\n")
+            );
+          else
+            return "There are no memories related to: " + phrases.join(" or ");
+        },
+        function: {
+          name: "search_memory",
+          description: `Search the memory bank by a search phrase`,
+          parameters: {
+            type: "object",
+            required: ["phrases"],
+            description:
+              "Search the memory bank by any of a number of phrases. This will return any memories that matches one or the other of the phrases",
+            properties: {
+              phrases: {
+                type: "array",
+                description:
+                  "A phrase to search the memory bank with. The search phrase is the synatx used by web search engines: use double quotes for exact match, unquoted text for words in any order, dash (minus sign) to exclude a word. Do not use SQL or any other formal query language.",
+                items: {
+                  type: "string",
+                },
+              },
+            },
+          },
+        },
+      },
+    ];
+  }
+}
+
+module.exports = LongTermMemory;