@ztimson/ai-utils 0.4.1 → 0.5.2

package/dist/index.mjs

@@ -1,239 +1,237 @@
-import * as j from "node:os";
-import { objectMap as k, JSONAttemptParse as w, findByProp as x, JSONSanitize as b, clean as M, Http as E, consoleInterceptor as q, fn as A, ASet as P } from "@ztimson/utils";
+import * as S from "node:os";
+import { objectMap as k, JSONAttemptParse as y, findByProp as x, JSONSanitize as b, clean as T, Http as M, consoleInterceptor as q, fn as P, ASet as E } from "@ztimson/utils";
 import { Anthropic as $ } from "@anthropic-ai/sdk";
-import { OpenAI as O } from "openai";
-import { Worker as R } from "worker_threads";
-import { fileURLToPath as U } from "url";
-import { join as W, dirname as v } from "path";
-import { spawn as L } from "node:child_process";
-import y from "node:fs/promises";
-import N from "node:path";
-import { createWorker as J } from "tesseract.js";
+import { OpenAI as A } from "openai";
+import { Worker as v } from "worker_threads";
+import { fileURLToPath as O } from "url";
+import { join as R, dirname as U } from "path";
+import { spawn as W } from "node:child_process";
+import w from "node:fs/promises";
+import L from "node:path";
+import { createWorker as I } from "tesseract.js";
 import "./embedder.mjs";
-import * as z from "cheerio";
+import * as N from "cheerio";
 import { $ as C, $Sync as D } from "@ztimson/node-utils";
-class S {
+class j {
 }
-class H extends S {
-  constructor(t, e, n) {
-    super(), this.ai = t, this.apiToken = e, this.model = n, this.client = new $({ apiKey: e });
+class J extends j {
+  constructor(t, e, s) {
+    super(), this.ai = t, this.apiToken = e, this.model = s, this.client = new $({ apiKey: e });
   }
   client;
   toStandard(t) {
     for (let e = 0; e < t.length; e++) {
-      const n = e;
-      typeof t[n].content != "string" && (t[n].role == "assistant" ? t[n].content.filter((o) => o.type == "tool_use").forEach((o) => {
-        e++, t.splice(e, 0, { role: "tool", id: o.id, name: o.name, args: o.input, timestamp: Date.now() });
-      }) : t[n].role == "user" && t[n].content.filter((o) => o.type == "tool_result").forEach((o) => {
-        const i = t.find((c) => c.id == o.tool_use_id);
-        i[o.is_error ? "error" : "content"] = o.content;
-      }), t[n].content = t[n].content.filter((o) => o.type == "text").map((o) => o.text).join(`
+      const s = e;
+      typeof t[s].content != "string" && (t[s].role == "assistant" ? t[s].content.filter((r) => r.type == "tool_use").forEach((r) => {
+        t.splice(e + 1, 0, { role: "tool", id: r.id, name: r.name, args: r.input, timestamp: Date.now() });
+      }) : t[s].role == "user" && t[s].content.filter((r) => r.type == "tool_result").forEach((r) => {
+        const c = t.find((o) => o.id == r.tool_use_id);
+        c[r.is_error ? "error" : "content"] = r.content;
+      }), t[s].content = t[s].content.filter((r) => r.type == "text").map((r) => r.text).join(`
 
-`)), t[n].timestamp || (t[n].timestamp = Date.now());
+`), t[s].content || t.splice(s, 1)), t[s].timestamp || (t[s].timestamp = Date.now());
     }
     return t.filter((e) => !!e.content);
   }
   fromStandard(t) {
     for (let e = 0; e < t.length; e++)
       if (t[e].role == "tool") {
-        const n = t[e];
+        const s = t[e];
         t.splice(
           e,
           1,
-          { role: "assistant", content: [{ type: "tool_use", id: n.id, name: n.name, input: n.args }] },
-          { role: "user", content: [{ type: "tool_result", tool_use_id: n.id, is_error: !!n.error, content: n.error || n.content }] }
+          { role: "assistant", content: [{ type: "tool_use", id: s.id, name: s.name, input: s.args }] },
+          { role: "user", content: [{ type: "tool_result", tool_use_id: s.id, is_error: !!s.error, content: s.error || s.content }] }
         ), e++;
       }
-    return t.map(({ timestamp: e, ...n }) => n);
+    return t.map(({ timestamp: e, ...s }) => s);
   }
   ask(t, e = {}) {
-    const n = new AbortController(), o = new Promise(async (i, c) => {
-      let s = [...e.history || [], { role: "user", content: t, timestamp: Date.now() }];
-      e.compress && (s = await this.ai.language.compressHistory(s, e.compress.max, e.compress.min, e)), s = this.fromStandard(s);
-      const d = e.tools || this.ai.options.llm?.tools || [], u = {
+    const s = new AbortController();
+    return Object.assign(new Promise(async (r, c) => {
+      const o = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]), a = e.tools || this.ai.options.llm?.tools || [], m = {
         model: e.model || this.model,
         max_tokens: e.max_tokens || this.ai.options.llm?.max_tokens || 4096,
         system: e.system || this.ai.options.llm?.system || "",
         temperature: e.temperature || this.ai.options.llm?.temperature || 0.7,
-        tools: d.map((l) => ({
+        tools: a.map((l) => ({
           name: l.name,
           description: l.description,
           input_schema: {
             type: "object",
-            properties: l.args ? k(l.args, (a, p) => ({ ...p, required: void 0 })) : {},
-            required: l.args ? Object.entries(l.args).filter((a) => a[1].required).map((a) => a[0]) : []
+            properties: l.args ? k(l.args, (i, u) => ({ ...u, required: void 0 })) : {},
+            required: l.args ? Object.entries(l.args).filter((i) => i[1].required).map((i) => i[0]) : []
           },
           fn: void 0
         })),
-        messages: s,
+        messages: o,
         stream: !!e.stream
       };
-      let r, h = !0;
+      let n, d = !0;
       do {
-        if (r = await this.client.messages.create(u).catch((a) => {
-          throw a.message += `
+        if (n = await this.client.messages.create(m).catch((i) => {
+          throw i.message += `
 
 Messages:
-${JSON.stringify(s, null, 2)}`, a;
+${JSON.stringify(o, null, 2)}`, i;
         }), e.stream) {
-          h ? h = !1 : e.stream({ text: `
+          d ? d = !1 : e.stream({ text: `
 
-` }), r.content = [];
-          for await (const a of r) {
-            if (n.signal.aborted) break;
-            if (a.type === "content_block_start")
-              a.content_block.type === "text" ? r.content.push({ type: "text", text: "" }) : a.content_block.type === "tool_use" && r.content.push({ type: "tool_use", id: a.content_block.id, name: a.content_block.name, input: "" });
-            else if (a.type === "content_block_delta")
-              if (a.delta.type === "text_delta") {
-                const p = a.delta.text;
-                r.content.at(-1).text += p, e.stream({ text: p });
-              } else a.delta.type === "input_json_delta" && (r.content.at(-1).input += a.delta.partial_json);
-            else if (a.type === "content_block_stop") {
-              const p = r.content.at(-1);
-              p.input != null && (p.input = p.input ? w(p.input, {}) : {});
-            } else if (a.type === "message_stop")
+` }), n.content = [];
+          for await (const i of n) {
+            if (s.signal.aborted) break;
+            if (i.type === "content_block_start")
+              i.content_block.type === "text" ? n.content.push({ type: "text", text: "" }) : i.content_block.type === "tool_use" && n.content.push({ type: "tool_use", id: i.content_block.id, name: i.content_block.name, input: "" });
+            else if (i.type === "content_block_delta")
+              if (i.delta.type === "text_delta") {
+                const u = i.delta.text;
+                n.content.at(-1).text += u, e.stream({ text: u });
+              } else i.delta.type === "input_json_delta" && (n.content.at(-1).input += i.delta.partial_json);
+            else if (i.type === "content_block_stop") {
+              const u = n.content.at(-1);
+              u.input != null && (u.input = u.input ? y(u.input, {}) : {});
+            } else if (i.type === "message_stop")
               break;
           }
         }
-        const l = r.content.filter((a) => a.type === "tool_use");
-        if (l.length && !n.signal.aborted) {
-          s.push({ role: "assistant", content: r.content });
-          const a = await Promise.all(l.map(async (p) => {
-            const g = d.find(x("name", p.name));
-            if (e.stream && e.stream({ tool: p.name }), !g) return { tool_use_id: p.id, is_error: !0, content: "Tool not found" };
+        const l = n.content.filter((i) => i.type === "tool_use");
+        if (l.length && !s.signal.aborted) {
+          o.push({ role: "assistant", content: n.content });
+          const i = await Promise.all(l.map(async (u) => {
+            const h = a.find(x("name", u.name));
+            if (e.stream && e.stream({ tool: u.name }), !h) return { tool_use_id: u.id, is_error: !0, content: "Tool not found" };
             try {
-              const f = await g.fn(p.input, this.ai);
-              return { type: "tool_result", tool_use_id: p.id, content: b(f) };
+              console.log(typeof h.fn);
+              const f = await h.fn(u.input, e?.stream, this.ai);
+              return { type: "tool_result", tool_use_id: u.id, content: b(f) };
             } catch (f) {
-              return { type: "tool_result", tool_use_id: p.id, is_error: !0, content: f?.message || f?.toString() || "Unknown" };
+              return { type: "tool_result", tool_use_id: u.id, is_error: !0, content: f?.message || f?.toString() || "Unknown" };
             }
           }));
-          s.push({ role: "user", content: a }), u.messages = s;
+          o.push({ role: "user", content: i }), m.messages = o;
         }
-      } while (!n.signal.aborted && r.content.some((l) => l.type === "tool_use"));
-      e.stream && e.stream({ done: !0 }), i(this.toStandard([...s, { role: "assistant", content: r.content.filter((l) => l.type == "text").map((l) => l.text).join(`
+      } while (!s.signal.aborted && n.content.some((l) => l.type === "tool_use"));
+      o.push({ role: "assistant", content: n.content.filter((l) => l.type == "text").map((l) => l.text).join(`
 
-`) }]));
-    });
-    return Object.assign(o, { abort: () => n.abort() });
+`) }), this.toStandard(o), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...o), r(o.at(-1)?.content);
+    }), { abort: () => s.abort() });
   }
 }
-class _ extends S {
-  constructor(t, e, n, o) {
-    super(), this.ai = t, this.host = e, this.token = n, this.model = o, this.client = new O(M({
+class _ extends j {
+  constructor(t, e, s, r) {
+    super(), this.ai = t, this.host = e, this.token = s, this.model = r, this.client = new A(T({
       baseURL: e,
-      apiKey: n
+      apiKey: s
     }));
   }
   client;
   toStandard(t) {
     for (let e = 0; e < t.length; e++) {
-      const n = t[e];
-      if (n.role === "assistant" && n.tool_calls) {
-        const o = n.tool_calls.map((i) => ({
+      const s = t[e];
+      if (s.role === "assistant" && s.tool_calls) {
+        const r = s.tool_calls.map((c) => ({
           role: "tool",
-          id: i.id,
-          name: i.function.name,
-          args: w(i.function.arguments, {}),
-          timestamp: n.timestamp
+          id: c.id,
+          name: c.function.name,
+          args: y(c.function.arguments, {}),
+          timestamp: s.timestamp
         }));
-        t.splice(e, 1, ...o), e += o.length - 1;
-      } else if (n.role === "tool" && n.content) {
-        const o = t.find((i) => n.tool_call_id == i.id);
-        o && (n.content.includes('"error":') ? o.error = n.content : o.content = n.content), t.splice(e, 1), e--;
+        t.splice(e, 1, ...r), e += r.length - 1;
+      } else if (s.role === "tool" && s.content) {
+        const r = t.find((c) => s.tool_call_id == c.id);
+        r && (s.content.includes('"error":') ? r.error = s.content : r.content = s.content), t.splice(e, 1), e--;
       }
       t[e]?.timestamp || (t[e].timestamp = Date.now());
     }
     return t;
   }
   fromStandard(t) {
-    return t.reduce((e, n) => {
-      if (n.role === "tool")
+    return t.reduce((e, s) => {
+      if (s.role === "tool")
         e.push({
           role: "assistant",
           content: null,
-          tool_calls: [{ id: n.id, type: "function", function: { name: n.name, arguments: JSON.stringify(n.args) } }],
+          tool_calls: [{ id: s.id, type: "function", function: { name: s.name, arguments: JSON.stringify(s.args) } }],
           refusal: null,
           annotations: []
         }, {
           role: "tool",
-          tool_call_id: n.id,
-          content: n.error || n.content
+          tool_call_id: s.id,
+          content: s.error || s.content
         });
       else {
-        const { timestamp: o, ...i } = n;
-        e.push(i);
+        const { timestamp: r, ...c } = s;
+        e.push(c);
       }
       return e;
     }, []);
   }
   ask(t, e = {}) {
-    const n = new AbortController(), o = new Promise(async (i, c) => {
-      let s = [...e.history || [], { role: "user", content: t, timestamp: Date.now() }];
-      e.compress && (s = await this.ai.language.compressHistory(s, e.compress.max, e.compress.min, e)), s = this.fromStandard(s);
-      const d = e.tools || this.ai.options.llm?.tools || [], u = {
+    const s = new AbortController();
+    return Object.assign(new Promise(async (r, c) => {
+      e.system && e.history?.[0]?.role != "system" && e.history?.splice(0, 0, { role: "system", content: e.system, timestamp: Date.now() });
+      const o = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]), a = e.tools || this.ai.options.llm?.tools || [], m = {
         model: e.model || this.model,
-        messages: s,
+        messages: o,
         stream: !!e.stream,
         max_tokens: e.max_tokens || this.ai.options.llm?.max_tokens || 4096,
         temperature: e.temperature || this.ai.options.llm?.temperature || 0.7,
-        tools: d.map((l) => ({
+        tools: a.map((l) => ({
           type: "function",
           function: {
             name: l.name,
             description: l.description,
             parameters: {
               type: "object",
-              properties: l.args ? k(l.args, (a, p) => ({ ...p, required: void 0 })) : {},
-              required: l.args ? Object.entries(l.args).filter((a) => a[1].required).map((a) => a[0]) : []
+              properties: l.args ? k(l.args, (i, u) => ({ ...u, required: void 0 })) : {},
+              required: l.args ? Object.entries(l.args).filter((i) => i[1].required).map((i) => i[0]) : []
             }
           }
         }))
       };
-      let r, h = !0;
+      let n, d = !0;
       do {
-        if (r = await this.client.chat.completions.create(u).catch((a) => {
-          throw a.message += `
+        if (n = await this.client.chat.completions.create(m).catch((i) => {
+          throw i.message += `
 
 Messages:
-${JSON.stringify(s, null, 2)}`, a;
+${JSON.stringify(o, null, 2)}`, i;
         }), e.stream) {
-          h ? h = !1 : e.stream({ text: `
+          d ? d = !1 : e.stream({ text: `
 
-` }), r.choices = [{ message: { content: "", tool_calls: [] } }];
-          for await (const a of r) {
-            if (n.signal.aborted) break;
-            a.choices[0].delta.content && (r.choices[0].message.content += a.choices[0].delta.content, e.stream({ text: a.choices[0].delta.content })), a.choices[0].delta.tool_calls && (r.choices[0].message.tool_calls = a.choices[0].delta.tool_calls);
+` }), n.choices = [{ message: { content: "", tool_calls: [] } }];
+          for await (const i of n) {
+            if (s.signal.aborted) break;
+            i.choices[0].delta.content && (n.choices[0].message.content += i.choices[0].delta.content, e.stream({ text: i.choices[0].delta.content })), i.choices[0].delta.tool_calls && (n.choices[0].message.tool_calls = i.choices[0].delta.tool_calls);
           }
         }
-        const l = r.choices[0].message.tool_calls || [];
-        if (l.length && !n.signal.aborted) {
-          s.push(r.choices[0].message);
-          const a = await Promise.all(l.map(async (p) => {
-            const g = d?.find(x("name", p.function.name));
-            if (e.stream && e.stream({ tool: p.function.name }), !g) return { role: "tool", tool_call_id: p.id, content: '{"error": "Tool not found"}' };
+        const l = n.choices[0].message.tool_calls || [];
+        if (l.length && !s.signal.aborted) {
+          o.push(n.choices[0].message);
+          const i = await Promise.all(l.map(async (u) => {
+            const h = a?.find(x("name", u.function.name));
+            if (e.stream && e.stream({ tool: u.function.name }), !h) return { role: "tool", tool_call_id: u.id, content: '{"error": "Tool not found"}' };
             try {
-              const f = w(p.function.arguments, {}), T = await g.fn(f, this.ai);
-              return { role: "tool", tool_call_id: p.id, content: b(T) };
+              const f = y(u.function.arguments, {}), g = await h.fn(f, e.stream, this.ai);
+              return { role: "tool", tool_call_id: u.id, content: b(g) };
             } catch (f) {
-              return { role: "tool", tool_call_id: p.id, content: b({ error: f?.message || f?.toString() || "Unknown" }) };
+              return { role: "tool", tool_call_id: u.id, content: b({ error: f?.message || f?.toString() || "Unknown" }) };
             }
           }));
-          s.push(...a), u.messages = s;
+          o.push(...i), m.messages = o;
         }
-      } while (!n.signal.aborted && r.choices?.[0]?.message?.tool_calls?.length);
-      e.stream && e.stream({ done: !0 }), i(this.toStandard([...s, { role: "assistant", content: r.choices[0].message.content || "" }]));
-    });
-    return Object.assign(o, { abort: () => n.abort() });
+      } while (!s.signal.aborted && n.choices?.[0]?.message?.tool_calls?.length);
+      o.push({ role: "assistant", content: n.choices[0].message.content || "" }), this.toStandard(o), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...o), r(o.at(-1)?.content);
+    }), { abort: () => s.abort() });
   }
 }
-class I {
+class H {
   constructor(t) {
-    this.ai = t, this.embedWorker = new R(W(v(U(import.meta.url)), "embedder.js")), this.embedWorker.on("message", ({ id: e, embedding: n }) => {
-      const o = this.embedQueue.get(e);
-      o && (o.resolve(n), this.embedQueue.delete(e));
-    }), t.options.llm?.models && Object.entries(t.options.llm.models).forEach(([e, n]) => {
-      this.defaultModel || (this.defaultModel = e), n.proto == "anthropic" ? this.models[e] = new H(this.ai, n.token, e) : n.proto == "ollama" ? this.models[e] = new _(this.ai, n.host, "not-needed", e) : n.proto == "openai" && (this.models[e] = new _(this.ai, n.host || null, n.token, e));
+    this.ai = t, this.embedWorker = new v(R(U(O(import.meta.url)), "embedder.js")), this.embedWorker.on("message", ({ id: e, embedding: s }) => {
+      const r = this.embedQueue.get(e);
+      r && (r.resolve(s), this.embedQueue.delete(e));
+    }), t.options.llm?.models && Object.entries(t.options.llm.models).forEach(([e, s]) => {
+      this.defaultModel || (this.defaultModel = e), s.proto == "anthropic" ? this.models[e] = new J(this.ai, s.token, e) : s.proto == "ollama" ? this.models[e] = new _(this.ai, s.host, "not-needed", e) : s.proto == "openai" && (this.models[e] = new _(this.ai, s.host || null, s.token, e));
     });
   }
   embedWorker = null;
@@ -245,72 +243,146 @@ class I {
    * Chat with LLM
    * @param {string} message Question
    * @param {LLMRequest} options Configuration options and chat history
-   * @returns {{abort: () => void, response: Promise<LLMMessage[]>}} Function to abort response and chat history
+   * @returns {{abort: () => void, response: Promise<string>}} Function to abort response and chat history
    */
   ask(t, e = {}) {
-    const n = e.model || this.defaultModel;
-    if (!this.models[n]) throw new Error(`Model does not exist: ${n}`);
-    return this.models[n].ask(t, e);
+    const s = e.model || this.defaultModel;
+    if (!this.models[s]) throw new Error(`Model does not exist: ${s}`);
+    let r = () => {
+    };
+    return Object.assign(new Promise(async (c) => {
+      if (e.history || (e.history = []), e.memory) {
+        e.system = (e.system || "") + `
+You have passive persistent memory never make any mention of your memory capabilities and what you can/cannot remember
+`;
+        const a = async (n, d, l = 50) => {
+          const [i, u] = await Promise.all([
+            d ? this.embedding(d) : Promise.resolve(null),
+            n ? this.embedding(n) : Promise.resolve(null)
+          ]);
+          return (e.memory || []).map((h) => ({ ...h, score: i ? this.cosineSimilarity(h.embeddings[0], i[0].embedding) : 1 })).filter((h) => h.score >= 0.8).map((h) => ({ ...h, score: u ? this.cosineSimilarity(h.embeddings[1], u[0].embedding) : h.score })).filter((h) => h.score >= 0.2).toSorted((h, f) => h.score - f.score).slice(0, l);
+        }, m = await a(t);
+        m.length && e.history.push({ role: "assistant", content: `Things I remembered:
+` + m.map((n) => `${n.owner}: ${n.fact}`).join(`
+`) }), e.tools = [...e.tools || [], {
+          name: "read_memory",
+          description: "Check your long-term memory for more information",
+          args: {
+            subject: { type: "string", description: "Find information by a subject topic, can be used with or without query argument" },
+            query: { type: "string", description: "Search memory based on a query, can be used with or without subject argument" },
+            limit: { type: "number", description: "Result limit, default 5" }
+          },
+          fn: (n) => {
+            if (!n.subject && !n.query) throw new Error("Either a subject or query argument is required");
+            return a(n.query, n.subject, n.limit || 5);
+          }
+        }];
+      }
+      const o = await this.models[s].ask(t, e);
+      if (e.memory) {
+        const a = e.history?.findIndex((m) => m.role == "assistant" && m.content.startsWith("Things I remembered:"));
+        a != null && a >= 0 && e.history?.splice(a, 1);
+      }
+      if (e.compress || e.memory) {
+        let a = null;
+        if (e.compress)
+          a = await this.ai.language.compressHistory(e.history, e.compress.max, e.compress.min, e), e.history.splice(0, e.history.length, ...a.history);
+        else {
+          const m = e.history?.findLastIndex((n) => n.role == "user") ?? -1;
+          a = await this.ai.language.compressHistory(m != -1 ? e.history.slice(m) : e.history, 0, 0, e);
+        }
+        if (e.memory) {
+          const m = e.memory.filter((n) => !a.memory.some((d) => this.cosineSimilarity(n.embeddings[1], d.embeddings[1]) > 0.8)).concat(a.memory);
+          e.memory.splice(0, e.memory.length, ...m);
+        }
+      }
+      return c(o);
+    }), { abort: r });
   }
   /**
    * Compress chat history to reduce context size
    * @param {LLMMessage[]} history Chatlog that will be compressed
    * @param max Trigger compression once context is larger than max
-   * @param min Summarize until context size is less than min
+   * @param min Leave messages less than the token minimum, summarize the rest
    * @param {LLMRequest} options LLM options
    * @returns {Promise<LLMMessage[]>} New chat history will summary at index 0
    */
-  async compressHistory(t, e, n, o) {
-    if (this.estimateTokens(t) < e) return t;
-    let i = 0, c = 0;
-    for (let r of t.toReversed())
-      if (c += this.estimateTokens(r.content), c < n) i++;
+  async compressHistory(t, e, s, r) {
+    if (this.estimateTokens(t) < e) return { history: t, memory: [] };
+    let c = 0, o = 0;
+    for (let h of t.toReversed())
+      if (o += this.estimateTokens(h.content), o < s) c++;
       else break;
-    if (t.length <= i) return t;
-    const s = i == 0 ? [] : t.slice(-i), d = (i == 0 ? t : t.slice(0, -i)).filter((r) => r.role === "assistant" || r.role === "user");
-    return [{ role: "assistant", content: `Conversation Summary: ${await this.summarize(d.map((r) => `${r.role}: ${r.content}`).join(`
+    if (t.length <= c) return { history: t, memory: [] };
+    const a = t[0].role == "system" ? t[0] : null, m = c == 0 ? [] : t.slice(-c), n = (c == 0 ? t : t.slice(0, -c)).filter((h) => h.role === "assistant" || h.role === "user"), d = await this.json(`Create the smallest summary possible, no more than 500 tokens. Create a list of NEW facts (split by subject [pro]noun and fact) about what you learned from this conversation that you didn't already know or get from a tool call or system prompt. Focus only on new information about people, topics, or facts. Avoid generating facts about the AI. Match this format: {summary: string, facts: [[subject, fact]]}
 
-`), 250, o)}`, timestamp: Date.now() }, ...s];
+${n.map((h) => `${h.role}: ${h.content}`).join(`
+
+`)}`, { model: r?.model, temperature: r?.temperature || 0.3 }), l = /* @__PURE__ */ new Date(), i = await Promise.all((d?.facts || [])?.map(async ([h, f]) => {
+      const g = await Promise.all([this.embedding(h), this.embedding(`${h}: ${f}`)]);
+      return { owner: h, fact: f, embeddings: [g[0][0].embedding, g[1][0].embedding], timestamp: l };
+    })), u = [{ role: "assistant", content: `Conversation Summary: ${d?.summary}`, timestamp: Date.now() }, ...m];
+    return a && u.splice(0, 0, a), { history: u, memory: i };
   }
+  /**
+   * Compare the difference between embeddings (calculates the angle between two vectors)
+   * @param {number[]} v1 First embedding / vector comparison
+   * @param {number[]} v2 Second embedding / vector for comparison
+   * @returns {number} Similarity values 0-1: 0 = unique, 1 = identical
+   */
   cosineSimilarity(t, e) {
     if (t.length !== e.length) throw new Error("Vectors must be same length");
-    let n = 0, o = 0, i = 0;
-    for (let s = 0; s < t.length; s++)
-      n += t[s] * e[s], o += t[s] * t[s], i += e[s] * e[s];
-    const c = Math.sqrt(o) * Math.sqrt(i);
-    return c === 0 ? 0 : n / c;
+    let s = 0, r = 0, c = 0;
+    for (let a = 0; a < t.length; a++)
+      s += t[a] * e[a], r += t[a] * t[a], c += e[a] * e[a];
+    const o = Math.sqrt(r) * Math.sqrt(c);
+    return o === 0 ? 0 : s / o;
   }
-  chunk(t, e = 500, n = 50) {
-    const o = (d, u = "") => d ? Object.entries(d).flatMap(([r, h]) => {
-      const l = u ? `${u}${isNaN(+r) ? `.${r}` : `[${r}]`}` : r;
-      return typeof h == "object" && !Array.isArray(h) ? o(h, l) : `${l}: ${Array.isArray(h) ? h.join(", ") : h}`;
-    }) : [], c = (typeof t == "object" ? o(t) : t.split(`
-`)).flatMap((d) => [...d.split(/\s+/).filter(Boolean), `
-`]), s = [];
-    for (let d = 0; d < c.length; ) {
-      let u = "", r = d;
-      for (; r < c.length; ) {
-        const l = u + (u ? " " : "") + c[r];
-        if (this.estimateTokens(l.replace(/\s*\n\s*/g, `
-`)) > e && u) break;
-        u = l, r++;
+  /**
+   * Chunk text into parts for AI digestion
+   * @param {object | string} target Item that will be chunked (objects get converted)
+   * @param {number} maxTokens Chunking size. More = better context, less = more specific (Search by paragraphs or lines)
+   * @param {number} overlapTokens Includes previous X tokens to provide continuity to AI (In addition to max tokens)
+   * @returns {string[]} Chunked strings
+   */
+  chunk(t, e = 500, s = 50) {
+    const r = (m, n = "") => m ? Object.entries(m).flatMap(([d, l]) => {
+      const i = n ? `${n}${isNaN(+d) ? `.${d}` : `[${d}]`}` : d;
+      return typeof l == "object" && !Array.isArray(l) ? r(l, i) : `${i}: ${Array.isArray(l) ? l.join(", ") : l}`;
+    }) : [], o = (typeof t == "object" ? r(t) : t.split(`
+`)).flatMap((m) => [...m.split(/\s+/).filter(Boolean), `
+`]), a = [];
+    for (let m = 0; m < o.length; ) {
+      let n = "", d = m;
+      for (; d < o.length; ) {
+        const i = n + (n ? " " : "") + o[d];
+        if (this.estimateTokens(i.replace(/\s*\n\s*/g, `
+`)) > e && n) break;
+        n = i, d++;
       }
-      const h = u.replace(/\s*\n\s*/g, `
+      const l = n.replace(/\s*\n\s*/g, `
 `).trim();
-      h && s.push(h), d = Math.max(r - n, r === d ? d + 1 : r);
+      l && a.push(l), m = Math.max(d - s, d === m ? m + 1 : d);
     }
-    return s;
+    return a;
   }
-  embedding(t, e = 500, n = 50) {
-    const o = (c) => new Promise((s, d) => {
-      const u = this.embedId++;
-      this.embedQueue.set(u, { resolve: s, reject: d }), this.embedWorker?.postMessage({ id: u, text: c });
-    }), i = this.chunk(t, e, n);
-    return Promise.all(i.map(async (c, s) => ({
-      index: s,
-      embedding: await o(c),
-      text: c,
-      tokens: this.estimateTokens(c)
+  /**
+   * Create a vector representation of a string
+   * @param {object | string} target Item that will be embedded (objects get converted)
+   * @param {number} maxTokens Chunking size. More = better context, less = more specific (Search by paragraphs or lines)
+   * @param {number} overlapTokens Includes previous X tokens to provide continuity to AI (In addition to max tokens)
+   * @returns {Promise<Awaited<{index: number, embedding: number[], text: string, tokens: number}>[]>} Chunked embeddings
+   */
+  embedding(t, e = 500, s = 50) {
+    const r = (o) => new Promise((a, m) => {
+      const n = this.embedId++;
+      this.embedQueue.set(n, { resolve: a, reject: m }), this.embedWorker?.postMessage({ id: n, text: o, model: this.ai.options?.embedder || "bge-small-en-v1.5" });
+    }), c = this.chunk(t, e, s);
+    return Promise.all(c.map(async (o, a) => ({
+      index: a,
+      embedding: await r(o),
+      text: o,
+      tokens: this.estimateTokens(o)
     })));
   }
   /**
@@ -324,14 +396,14 @@ class I {
   }
   /**
    * Compare the difference between two strings using tensor math
-   * @param target Text that will checked
+   * @param target Text that will be checked
    * @param {string} searchTerms Multiple search terms to check against target
    * @returns {{avg: number, max: number, similarities: number[]}} Similarity values 0-1: 0 = unique, 1 = identical
    */
   fuzzyMatch(t, ...e) {
     if (e.length < 2) throw new Error("Requires at least 2 strings to compare");
-    const n = (c, s = 10) => c.toLowerCase().split("").map((d, u) => d.charCodeAt(0) * (u + 1) % s / s).slice(0, s), o = n(t), i = e.map((c) => n(c)).map((c) => this.cosineSimilarity(o, c));
-    return { avg: i.reduce((c, s) => c + s, 0) / i.length, max: Math.max(...i), similarities: i };
+    const s = (o, a = 10) => o.toLowerCase().split("").map((m, n) => m.charCodeAt(0) * (n + 1) % a / a).slice(0, a), r = s(t), c = e.map((o) => s(o)).map((o) => this.cosineSimilarity(r, o));
+    return { avg: c.reduce((o, a) => o + a, 0) / c.length, max: Math.max(...c), similarities: c };
   }
   /**
    * Ask a question with JSON response
@@ -340,11 +412,10 @@ class I {
    * @returns {Promise<{} | {} | RegExpExecArray | null>}
    */
   async json(t, e) {
-    let n = await this.ask(t, {
-      system: "Respond using a JSON blob",
-      ...e
-    });
-    return n?.[0]?.content ? w(new RegExp("{[sS]*}").exec(n[0].content), {}) : {};
+    let s = await this.ask(t, { system: "Respond using a JSON blob matching any provided examples", ...e });
+    if (!s) return {};
+    const r = /```(?:.+)?\s*([\s\S]*?)```/.exec(s), c = r ? r[1].trim() : s;
+    return y(c, {});
   }
   /**
    * Create a summary of some text
@@ -353,11 +424,11 @@ class I {
    * @param options LLM request options
    * @returns {Promise<string>} Summary
    */
-  summarize(t, e, n) {
-    return this.ask(t, { system: `Generate a brief summary <= ${e} tokens. Output nothing else`, temperature: 0.3, ...n }).then((o) => o.pop()?.content || null);
+  summarize(t, e, s) {
+    return this.ask(t, { system: `Generate a brief summary <= ${e} tokens. Output nothing else`, temperature: 0.3, ...s });
   }
 }
-class F {
+class z {
   constructor(t) {
     this.ai = t, t.options.whisper?.binary && (this.whisperModel = t.options.whisper?.model.endsWith(".bin") ? t.options.whisper?.model : t.options.whisper?.model + ".bin", this.downloadAsrModel());
   }
@@ -365,26 +436,26 @@ class F {
   whisperModel;
   asr(t, e = this.whisperModel) {
     if (!this.ai.options.whisper?.binary) throw new Error("Whisper not configured");
-    let n = () => {
+    let s = () => {
     };
-    const o = new Promise(async (i, c) => {
-      const s = await this.downloadAsrModel(e);
-      let d = "";
-      const u = L(this.ai.options.whisper?.binary, ["-nt", "-np", "-m", s, "-f", t], { stdio: ["ignore", "pipe", "ignore"] });
-      n = () => u.kill("SIGTERM"), u.on("error", (r) => c(r)), u.stdout.on("data", (r) => d += r.toString()), u.on("close", (r) => {
-        r === 0 ? i(d.trim() || null) : c(new Error(`Exit code ${r}`));
+    const r = new Promise(async (c, o) => {
+      const a = await this.downloadAsrModel(e);
+      let m = "";
+      const n = W(this.ai.options.whisper?.binary, ["-nt", "-np", "-m", a, "-f", t], { stdio: ["ignore", "pipe", "ignore"] });
+      s = () => n.kill("SIGTERM"), n.on("error", (d) => o(d)), n.stdout.on("data", (d) => m += d.toString()), n.on("close", (d) => {
+        d === 0 ? c(m.trim() || null) : o(new Error(`Exit code ${d}`));
       });
     });
-    return Object.assign(o, { abort: n });
+    return Object.assign(r, { abort: s });
   }
   async downloadAsrModel(t = this.whisperModel) {
     if (!this.ai.options.whisper?.binary) throw new Error("Whisper not configured");
     t.endsWith(".bin") || (t += ".bin");
-    const e = N.join(this.ai.options.path, t);
-    return await y.stat(e).then(() => !0).catch(() => !1) ? e : this.downloads[t] ? this.downloads[t] : (this.downloads[t] = fetch(`https://huggingface.co/ggerganov/whisper.cpp/resolve/main/${t}`).then((n) => n.arrayBuffer()).then((n) => Buffer.from(n)).then(async (n) => (await y.writeFile(e, n), delete this.downloads[t], e)), this.downloads[t]);
+    const e = L.join(this.ai.options.path, t);
+    return await w.stat(e).then(() => !0).catch(() => !1) ? e : this.downloads[t] ? this.downloads[t] : (this.downloads[t] = fetch(`https://huggingface.co/ggerganov/whisper.cpp/resolve/main/${t}`).then((s) => s.arrayBuffer()).then((s) => Buffer.from(s)).then(async (s) => (await w.writeFile(e, s), delete this.downloads[t], e)), this.downloads[t]);
   }
 }
-class G {
+class F {
   constructor(t) {
     this.ai = t;
   }
@@ -395,17 +466,17 @@ class G {
    */
   ocr(t) {
     let e;
-    const n = new Promise(async (o) => {
-      e = await J(this.ai.options.tesseract?.model || "eng", 2, { cachePath: this.ai.options.path });
-      const { data: i } = await e.recognize(t);
-      await e.terminate(), o(i.text.trim() || null);
+    const s = new Promise(async (r) => {
+      e = await I(this.ai.options.tesseract?.model || "eng", 2, { cachePath: this.ai.options.path });
+      const { data: c } = await e.recognize(t);
+      await e.terminate(), r(c.text.trim() || null);
     });
-    return Object.assign(n, { abort: () => e?.terminate() });
+    return Object.assign(s, { abort: () => e?.terminate() });
   }
 }
-class ce {
+class ae {
   constructor(t) {
-    this.options = t, t.path || (t.path = j.tmpdir()), process.env.TRANSFORMERS_CACHE = t.path, this.audio = new F(this), this.language = new I(this), this.vision = new G(this);
+    this.options = t, t.path || (t.path = S.tmpdir()), process.env.TRANSFORMERS_CACHE = t.path, this.audio = new z(this), this.language = new H(this), this.vision = new F(this);
   }
   /** Audio processing AI */
   audio;
@@ -418,34 +489,34 @@ const B = {
   name: "cli",
   description: "Use the command line interface, returns any output",
   args: { command: { type: "string", description: "Command to run", required: !0 } },
-  fn: (m) => C`${m.command}`
-}, le = {
+  fn: (p) => C`${p.command}`
+}, ce = {
   name: "get_datetime",
   description: "Get current UTC date / time",
   args: {},
   fn: async () => (/* @__PURE__ */ new Date()).toUTCString()
-}, me = {
+}, le = {
   name: "exec",
   description: "Run code/scripts",
   args: {
     language: { type: "string", description: "Execution language", enum: ["cli", "node", "python"], required: !0 },
     code: { type: "string", description: "Code to execute", required: !0 }
   },
-  fn: async (m, t) => {
+  fn: async (p, t, e) => {
     try {
-      switch (m.type) {
+      switch (p.type) {
         case "bash":
-          return await B.fn({ command: m.code }, t);
+          return await B.fn({ command: p.code }, t, e);
         case "node":
-          return await Q.fn({ code: m.code }, t);
+          return await G.fn({ code: p.code }, t, e);
         case "python":
-          return await K.fn({ code: m.code }, t);
+          return await Q.fn({ code: p.code }, t, e);
       }
-    } catch (e) {
-      return { error: e?.message || e.toString() };
+    } catch (s) {
+      return { error: s?.message || s.toString() };
     }
   }
-}, de = {
+}, me = {
   name: "fetch",
   description: "Make HTTP request to URL",
   args: {
@@ -454,86 +525,85 @@ const B = {
     headers: { type: "object", description: "HTTP headers to send", default: {} },
     body: { type: "object", description: "HTTP body to send" }
   },
-  fn: (m) => new E({ url: m.url, headers: m.headers }).request({ method: m.method || "GET", body: m.body })
-}, Q = {
+  fn: (p) => new M({ url: p.url, headers: p.headers }).request({ method: p.method || "GET", body: p.body })
+}, G = {
   name: "exec_javascript",
   description: "Execute commonjs javascript",
   args: {
     code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
-  fn: async (m) => {
-    const t = q(null), e = await A({ console: t }, m.code, !0).catch((n) => t.output.error.push(n));
+  fn: async (p) => {
+    const t = q(null), e = await P({ console: t }, p.code, !0).catch((s) => t.output.error.push(s));
     return { ...t.output, return: e, stdout: void 0, stderr: void 0 };
   }
-}, K = {
+}, Q = {
   name: "exec_javascript",
   description: "Execute commonjs javascript",
   args: {
     code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
-  fn: async (m) => ({ result: D`python -c "${m.code}"` })
-}, ue = {
+  fn: async (p) => ({ result: D`python -c "${p.code}"` })
+}, de = {
   name: "read_webpage",
   description: "Extract clean, structured content from a webpage. Use after web_search to read specific URLs",
   args: {
     url: { type: "string", description: "URL to extract content from", required: !0 },
     focus: { type: "string", description: 'Optional: What aspect to focus on (e.g., "pricing", "features", "contact info")' }
   },
-  fn: async (m) => {
-    const t = await fetch(m.url, { headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" } }).then((c) => c.text()).catch((c) => {
-      throw new Error(`Failed to fetch: ${c.message}`);
-    }), e = z.load(t);
+  fn: async (p) => {
+    const t = await fetch(p.url, { headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" } }).then((o) => o.text()).catch((o) => {
+      throw new Error(`Failed to fetch: ${o.message}`);
+    }), e = N.load(t);
     e('script, style, nav, footer, header, aside, iframe, noscript, [role="navigation"], [role="banner"], .ad, .ads, .cookie, .popup').remove();
-    const n = {
+    const s = {
       title: e('meta[property="og:title"]').attr("content") || e("title").text() || "",
       description: e('meta[name="description"]').attr("content") || e('meta[property="og:description"]').attr("content") || ""
     };
-    let o = "";
-    const i = ["article", "main", '[role="main"]', ".content", ".post", ".entry", "body"];
-    for (const c of i) {
-      const s = e(c).first();
-      if (s.length && s.text().trim().length > 200) {
-        o = s.text();
+    let r = "";
+    const c = ["article", "main", '[role="main"]', ".content", ".post", ".entry", "body"];
+    for (const o of c) {
+      const a = e(o).first();
+      if (a.length && a.text().trim().length > 200) {
+        r = a.text();
         break;
       }
     }
-    return o || (o = e("body").text()), o = o.replace(/\s+/g, " ").trim().slice(0, 8e3), { url: m.url, title: n.title.trim(), description: n.description.trim(), content: o, focus: m.focus };
+    return r || (r = e("body").text()), r = r.replace(/\s+/g, " ").trim().slice(0, 8e3), { url: p.url, title: s.title.trim(), description: s.description.trim(), content: r, focus: p.focus };
   }
-}, pe = {
+}, ue = {
   name: "web_search",
   description: "Use duckduckgo (anonymous) to find find relevant online resources. Returns a list of URLs that works great with the `read_webpage` tool",
   args: {
     query: { type: "string", description: "Search string", required: !0 },
     length: { type: "string", description: "Number of results to return", default: 5 }
   },
-  fn: async (m) => {
-    const t = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(m.query)}`, {
+  fn: async (p) => {
+    const t = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(p.query)}`, {
       headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)", "Accept-Language": "en-US,en;q=0.9" }
-    }).then((i) => i.text());
-    let e, n = /<a .*?href="(.+?)".+?<\/a>/g;
-    const o = new P();
-    for (; (e = n.exec(t)) !== null; ) {
-      let i = /uddg=(.+)&amp?/.exec(decodeURIComponent(e[1]))?.[1];
-      if (i && (i = decodeURIComponent(i)), i && o.add(i), o.size >= (m.length || 5)) break;
+    }).then((c) => c.text());
+    let e, s = /<a .*?href="(.+?)".+?<\/a>/g;
+    const r = new E();
+    for (; (e = s.exec(t)) !== null; ) {
+      let c = /uddg=(.+)&amp?/.exec(decodeURIComponent(e[1]))?.[1];
+      if (c && (c = decodeURIComponent(c)), c && r.add(c), r.size >= (p.length || 5)) break;
     }
-    return o;
+    return r;
   }
 };
 export {
-  ce as Ai,
-  H as Anthropic,
-  F as Audio,
+  ae as Ai,
+  J as Anthropic,
+  z as Audio,
   B as CliTool,
-  le as DateTimeTool,
-  me as ExecTool,
-  de as FetchTool,
-  Q as JSTool,
-  I as LLM,
-  S as LLMProvider,
+  ce as DateTimeTool,
+  le as ExecTool,
+  me as FetchTool,
+  G as JSTool,
+  j as LLMProvider,
   _ as OpenAi,
-  K as PythonTool,
-  ue as ReadWebpageTool,
-  G as Vision,
-  pe as WebSearchTool
+  Q as PythonTool,
+  de as ReadWebpageTool,
+  F as Vision,
+  ue as WebSearchTool
 };
 //# sourceMappingURL=index.mjs.map