@ztimson/ai-utils 0.5.4 → 0.5.6

package/dist/index.mjs

@@ -1,37 +1,43 @@
 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 A } from "openai";
+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 $ } from "@ztimson/utils";
+import { Anthropic as A } from "@anthropic-ai/sdk";
+import { OpenAI as E } 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 { createWorker as N } from "tesseract.js";
 import "./embedder.mjs";
-import * as N from "cheerio";
-import { $ as C, $Sync as D } from "@ztimson/node-utils";
+import * as C from "cheerio";
+import { $ as I, $Sync as D } from "@ztimson/node-utils";
 class j {
 }
 class J extends j {
   constructor(t, e, s) {
-    super(), this.ai = t, this.apiToken = e, this.model = s, this.client = new $({ apiKey: e });
+    super(), this.ai = t, this.apiToken = e, this.model = s, this.client = new A({ apiKey: e });
   }
   client;
   toStandard(t) {
-    for (let e = 0; e < t.length; e++) {
-      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(`
+    const e = Date.now(), s = [];
+    for (let o of t)
+      if (typeof o.content == "string")
+        s.push({ timestamp: e, ...o });
+      else {
+        const n = o.content?.filter((r) => r.type == "text").map((r) => r.text).join(`
 
-`), t[s].content || t.splice(s, 1)), t[s].timestamp || (t[s].timestamp = Date.now());
-    }
-    return t.filter((e) => !!e.content);
+`);
+        n && s.push({ timestamp: e, role: o.role, content: n }), o.content.forEach((r) => {
+          if (r.type == "tool_use")
+            s.push({ timestamp: e, role: "tool", id: r.id, name: r.name, args: r.input, content: void 0 });
+          else if (r.type == "tool_result") {
+            const i = s.findLast((c) => c.id == r.tool_use_id);
+            i && (i[r.is_error ? "error" : "content"] = r.content);
+          }
+        });
+      }
+    return s;
   }
   fromStandard(t) {
     for (let e = 0; e < t.length; e++)
@@ -48,78 +54,78 @@ class J extends j {
   }
   ask(t, e = {}) {
     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 = {
+    return Object.assign(new Promise(async (o) => {
+      let n = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
+      const r = e.tools || this.ai.options.llm?.tools || [], i = {
         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: a.map((l) => ({
-          name: l.name,
-          description: l.description,
+        tools: r.map((m) => ({
+          name: m.name,
+          description: m.description,
           input_schema: {
             type: "object",
-            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]) : []
+            properties: m.args ? k(m.args, (l, d) => ({ ...d, required: void 0 })) : {},
+            required: m.args ? Object.entries(m.args).filter((l) => l[1].required).map((l) => l[0]) : []
           },
           fn: void 0
         })),
-        messages: o,
+        messages: n,
         stream: !!e.stream
       };
-      let n, d = !0;
+      let c, a = !0;
       do {
-        if (n = await this.client.messages.create(m).catch((i) => {
-          throw i.message += `
+        if (c = await this.client.messages.create(i).catch((l) => {
+          throw l.message += `
 
 Messages:
-${JSON.stringify(o, null, 2)}`, i;
+${JSON.stringify(n, null, 2)}`, l;
         }), e.stream) {
-          d ? d = !1 : e.stream({ text: `
+          a ? a = !1 : e.stream({ text: `
 
-` }), n.content = [];
-          for await (const i of n) {
+` }), c.content = [];
+          for await (const l of c) {
             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")
+            if (l.type === "content_block_start")
+              l.content_block.type === "text" ? c.content.push({ type: "text", text: "" }) : l.content_block.type === "tool_use" && c.content.push({ type: "tool_use", id: l.content_block.id, name: l.content_block.name, input: "" });
+            else if (l.type === "content_block_delta")
+              if (l.delta.type === "text_delta") {
+                const d = l.delta.text;
+                c.content.at(-1).text += d, e.stream({ text: d });
+              } else l.delta.type === "input_json_delta" && (c.content.at(-1).input += l.delta.partial_json);
+            else if (l.type === "content_block_stop") {
+              const d = c.content.at(-1);
+              d.input != null && (d.input = d.input ? y(d.input, {}) : {});
+            } else if (l.type === "message_stop")
               break;
           }
         }
-        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" };
+        const m = c.content.filter((l) => l.type === "tool_use");
+        if (m.length && !s.signal.aborted) {
+          n.push({ role: "assistant", content: c.content });
+          const l = await Promise.all(m.map(async (d) => {
+            const p = r.find(x("name", d.name));
+            if (e.stream && e.stream({ tool: d.name }), !p) return { tool_use_id: d.id, is_error: !0, content: "Tool not found" };
             try {
-              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: u.id, is_error: !0, content: f?.message || f?.toString() || "Unknown" };
+              const u = await p.fn(d.input, e?.stream, this.ai);
+              return { type: "tool_result", tool_use_id: d.id, content: b(u) };
+            } catch (u) {
+              return { type: "tool_result", tool_use_id: d.id, is_error: !0, content: u?.message || u?.toString() || "Unknown" };
             }
           }));
-          o.push({ role: "user", content: i }), m.messages = o;
+          n.push({ role: "user", content: l }), i.messages = n;
         }
-      } 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(`
+      } while (!s.signal.aborted && c.content.some((m) => m.type === "tool_use"));
+      n.push({ role: "assistant", content: c.content.filter((m) => m.type == "text").map((m) => m.text).join(`
 
-`) }), this.toStandard(o), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...o), r(o.at(-1)?.content);
+`) }), n = this.toStandard(n), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...n), o(n.at(-1)?.content);
     }), { abort: () => s.abort() });
   }
 }
 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({
+  constructor(t, e, s, o) {
+    super(), this.ai = t, this.host = e, this.token = s, this.model = o, this.client = new E(T({
       baseURL: e,
       apiKey: s
     }));
@@ -129,17 +135,17 @@ class _ extends j {
     for (let e = 0; e < t.length; e++) {
       const s = t[e];
       if (s.role === "assistant" && s.tool_calls) {
-        const r = s.tool_calls.map((c) => ({
+        const o = s.tool_calls.map((n) => ({
           role: "tool",
-          id: c.id,
-          name: c.function.name,
-          args: y(c.function.arguments, {}),
+          id: n.id,
+          name: n.function.name,
+          args: y(n.function.arguments, {}),
           timestamp: s.timestamp
         }));
-        t.splice(e, 1, ...r), e += r.length - 1;
+        t.splice(e, 1, ...o), e += o.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--;
+        const o = t.find((n) => s.tool_call_id == n.id);
+        o && (s.content.includes('"error":') ? o.error = s.content : o.content = s.content), t.splice(e, 1), e--;
       }
       t[e]?.timestamp || (t[e].timestamp = Date.now());
     }
@@ -160,76 +166,77 @@ class _ extends j {
           content: s.error || s.content
         });
       else {
-        const { timestamp: r, ...c } = s;
-        e.push(c);
+        const { timestamp: o, ...n } = s;
+        e.push(n);
       }
       return e;
     }, []);
   }
   ask(t, e = {}) {
     const s = new AbortController();
-    return Object.assign(new Promise(async (r, c) => {
+    return Object.assign(new Promise(async (o, n) => {
       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 = {
+      let r = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
+      const i = e.tools || this.ai.options.llm?.tools || [], c = {
         model: e.model || this.model,
-        messages: o,
+        messages: r,
         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: a.map((l) => ({
+        tools: i.map((l) => ({
           type: "function",
           function: {
             name: l.name,
             description: l.description,
             parameters: {
               type: "object",
-              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]) : []
+              properties: l.args ? k(l.args, (d, p) => ({ ...p, required: void 0 })) : {},
+              required: l.args ? Object.entries(l.args).filter((d) => d[1].required).map((d) => d[0]) : []
             }
           }
         }))
       };
-      let n, d = !0;
+      let a, m = !0;
       do {
-        if (n = await this.client.chat.completions.create(m).catch((i) => {
-          throw i.message += `
+        if (a = await this.client.chat.completions.create(c).catch((d) => {
+          throw d.message += `
 
 Messages:
-${JSON.stringify(o, null, 2)}`, i;
+${JSON.stringify(r, null, 2)}`, d;
         }), e.stream) {
-          d ? d = !1 : e.stream({ text: `
+          m ? m = !1 : e.stream({ text: `
 
-` }), n.choices = [{ message: { content: "", tool_calls: [] } }];
-          for await (const i of n) {
+` }), a.choices = [{ message: { content: "", tool_calls: [] } }];
+          for await (const d of a) {
             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);
+            d.choices[0].delta.content && (a.choices[0].message.content += d.choices[0].delta.content, e.stream({ text: d.choices[0].delta.content })), d.choices[0].delta.tool_calls && (a.choices[0].message.tool_calls = d.choices[0].delta.tool_calls);
           }
         }
-        const l = n.choices[0].message.tool_calls || [];
+        const l = a.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"}' };
+          r.push(a.choices[0].message);
+          const d = await Promise.all(l.map(async (p) => {
+            const u = i?.find(x("name", p.function.name));
+            if (e.stream && e.stream({ tool: p.function.name }), !u) return { role: "tool", tool_call_id: p.id, content: '{"error": "Tool not found"}' };
             try {
-              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) };
+              const f = y(p.function.arguments, {}), g = await u.fn(f, e.stream, this.ai);
+              return { role: "tool", tool_call_id: p.id, content: b(g) };
             } catch (f) {
-              return { role: "tool", tool_call_id: u.id, content: b({ error: f?.message || f?.toString() || "Unknown" }) };
+              return { role: "tool", tool_call_id: p.id, content: b({ error: f?.message || f?.toString() || "Unknown" }) };
             }
           }));
-          o.push(...i), m.messages = o;
+          r.push(...d), c.messages = r;
         }
-      } 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);
+      } while (!s.signal.aborted && a.choices?.[0]?.message?.tool_calls?.length);
+      r.push({ role: "assistant", content: a.choices[0].message.content || "" }), r = this.toStandard(r), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...r), o(r.at(-1)?.content);
     }), { abort: () => s.abort() });
   }
 }
 class H {
   constructor(t) {
     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));
+      const o = this.embedQueue.get(e);
+      o && (o.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));
     });
@@ -248,22 +255,22 @@ class H {
   ask(t, e = {}) {
     const s = e.model || this.defaultModel;
     if (!this.models[s]) throw new Error(`Model does not exist: ${s}`);
-    let r = () => {
+    let o = () => {
     };
-    return Object.assign(new Promise(async (c) => {
+    return Object.assign(new Promise(async (n) => {
       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)
+        const i = async (a, m, l = 50) => {
+          const [d, p] = await Promise.all([
+            m ? this.embedding(m) : Promise.resolve(null),
+            a ? this.embedding(a) : 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(`
+          return (e.memory || []).map((u) => ({ ...u, score: d ? this.cosineSimilarity(u.embeddings[0], d[0].embedding) : 1 })).filter((u) => u.score >= 0.8).map((u) => ({ ...u, score: p ? this.cosineSimilarity(u.embeddings[1], p[0].embedding) : u.score })).filter((u) => u.score >= 0.2).toSorted((u, f) => u.score - f.score).slice(0, l);
+        }, c = await i(t);
+        c.length && e.history.push({ role: "assistant", content: `Things I remembered:
+` + c.map((a) => `${a.owner}: ${a.fact}`).join(`
 `) }), e.tools = [...e.tools || [], {
           name: "read_memory",
           description: "Check your long-term memory for more information",
@@ -272,32 +279,32 @@ You have passive persistent memory never make any mention of your memory capabil
             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);
+          fn: (a) => {
+            if (!a.subject && !a.query) throw new Error("Either a subject or query argument is required");
+            return i(a.query, a.subject, a.limit || 5);
           }
         }];
       }
-      const o = await this.models[s].ask(t, e);
+      const r = 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);
+        const i = e.history?.findIndex((c) => c.role == "assistant" && c.content.startsWith("Things I remembered:"));
+        i != null && i >= 0 && e.history?.splice(i, 1);
       }
       if (e.compress || e.memory) {
-        let a = null;
+        let i = 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);
+          i = await this.ai.language.compressHistory(e.history, e.compress.max, e.compress.min, e), e.history.splice(0, e.history.length, ...i.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);
+          const c = e.history?.findLastIndex((a) => a.role == "user") ?? -1;
+          i = await this.ai.language.compressHistory(c != -1 ? e.history.slice(c) : 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);
+          const c = e.memory.filter((a) => !i.memory.some((m) => this.cosineSimilarity(a.embeddings[1], m.embeddings[1]) > 0.8)).concat(i.memory);
+          e.memory.splice(0, e.memory.length, ...c);
         }
       }
-      return c(o);
-    }), { abort: r });
+      return n(r);
+    }), { abort: o });
   }
   /**
    * Compress chat history to reduce context size
@@ -307,22 +314,22 @@ You have passive persistent memory never make any mention of your memory capabil
    * @param {LLMRequest} options LLM options
    * @returns {Promise<LLMMessage[]>} New chat history will summary at index 0
    */
-  async compressHistory(t, e, s, r) {
+  async compressHistory(t, e, s, o) {
     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++;
+    let n = 0, r = 0;
+    for (let u of t.toReversed())
+      if (r += this.estimateTokens(u.content), r < s) n++;
       else break;
-    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]]}
+    if (t.length <= n) return { history: t, memory: [] };
+    const i = t[0].role == "system" ? t[0] : null, c = n == 0 ? [] : t.slice(-n), a = (n == 0 ? t : t.slice(0, -n)).filter((u) => u.role === "assistant" || u.role === "user"), m = 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]]}
 
-${n.map((h) => `${h.role}: ${h.content}`).join(`
+${a.map((u) => `${u.role}: ${u.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 };
+`)}`, { model: o?.model, temperature: o?.temperature || 0.3 }), l = /* @__PURE__ */ new Date(), d = await Promise.all((m?.facts || [])?.map(async ([u, f]) => {
+      const g = await Promise.all([this.embedding(u), this.embedding(`${u}: ${f}`)]);
+      return { owner: u, fact: f, embeddings: [g[0][0].embedding, g[1][0].embedding], timestamp: l };
+    })), p = [{ role: "assistant", content: `Conversation Summary: ${m?.summary}`, timestamp: Date.now() }, ...c];
+    return i && p.splice(0, 0, i), { history: p, memory: d };
   }
   /**
    * Compare the difference between embeddings (calculates the angle between two vectors)
@@ -332,11 +339,11 @@ ${n.map((h) => `${h.role}: ${h.content}`).join(`
    */
   cosineSimilarity(t, e) {
     if (t.length !== e.length) throw new Error("Vectors must be same length");
-    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;
+    let s = 0, o = 0, n = 0;
+    for (let i = 0; i < t.length; i++)
+      s += t[i] * e[i], o += t[i] * t[i], n += e[i] * e[i];
+    const r = Math.sqrt(o) * Math.sqrt(n);
+    return r === 0 ? 0 : s / r;
   }
   /**
    * Chunk text into parts for AI digestion
@@ -346,25 +353,25 @@ ${n.map((h) => `${h.role}: ${h.content}`).join(`
    * @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 o = (c, a = "") => c ? Object.entries(c).flatMap(([m, l]) => {
+      const d = a ? `${a}${isNaN(+m) ? `.${m}` : `[${m}]`}` : m;
+      return typeof l == "object" && !Array.isArray(l) ? o(l, d) : `${d}: ${Array.isArray(l) ? l.join(", ") : l}`;
+    }) : [], r = (typeof t == "object" ? o(t) : t.split(`
+`)).flatMap((c) => [...c.split(/\s+/).filter(Boolean), `
+`]), i = [];
+    for (let c = 0; c < r.length; ) {
+      let a = "", m = c;
+      for (; m < r.length; ) {
+        const d = a + (a ? " " : "") + r[m];
+        if (this.estimateTokens(d.replace(/\s*\n\s*/g, `
+`)) > e && a) break;
+        a = d, m++;
       }
-      const l = n.replace(/\s*\n\s*/g, `
+      const l = a.replace(/\s*\n\s*/g, `
 `).trim();
-      l && a.push(l), m = Math.max(d - s, d === m ? m + 1 : d);
+      l && i.push(l), c = Math.max(m - s, m === c ? c + 1 : m);
     }
-    return a;
+    return i;
   }
   /**
    * Create a vector representation of a string
@@ -374,20 +381,20 @@ ${n.map((h) => `${h.role}: ${h.content}`).join(`
    * @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,
+    const o = (r) => new Promise((i, c) => {
+      const a = this.embedId++;
+      this.embedQueue.set(a, { resolve: i, reject: c }), this.embedWorker?.postMessage({
+        id: a,
+        text: r,
         model: this.ai.options?.embedder || "bge-small-en-v1.5",
         path: this.ai.options.path
       });
-    }), 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)
+    }), n = this.chunk(t, e, s);
+    return Promise.all(n.map(async (r, i) => ({
+      index: i,
+      embedding: await o(r),
+      text: r,
+      tokens: this.estimateTokens(r)
     })));
   }
   /**
@@ -407,8 +414,8 @@ ${n.map((h) => `${h.role}: ${h.content}`).join(`
    */
   fuzzyMatch(t, ...e) {
     if (e.length < 2) throw new Error("Requires at least 2 strings to compare");
-    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 };
+    const s = (r, i = 10) => r.toLowerCase().split("").map((c, a) => c.charCodeAt(0) * (a + 1) % i / i).slice(0, i), o = s(t), n = e.map((r) => s(r)).map((r) => this.cosineSimilarity(o, r));
+    return { avg: n.reduce((r, i) => r + i, 0) / n.length, max: Math.max(...n), similarities: n };
   }
   /**
    * Ask a question with JSON response
@@ -419,8 +426,8 @@ ${n.map((h) => `${h.role}: ${h.content}`).join(`
   async json(t, e) {
     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, {});
+    const o = /```(?:.+)?\s*([\s\S]*?)```/.exec(s), n = o ? o[1].trim() : s;
+    return y(n, {});
   }
   /**
    * Create a summary of some text
@@ -443,15 +450,15 @@ class z {
     if (!this.ai.options.whisper?.binary) throw new Error("Whisper not configured");
     let s = () => {
     };
-    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}`));
+    const o = new Promise(async (n, r) => {
+      const i = await this.downloadAsrModel(e);
+      let c = "";
+      const a = W(this.ai.options.whisper?.binary, ["-nt", "-np", "-m", i, "-f", t], { stdio: ["ignore", "pipe", "ignore"] });
+      s = () => a.kill("SIGTERM"), a.on("error", (m) => r(m)), a.stdout.on("data", (m) => c += m.toString()), a.on("close", (m) => {
+        m === 0 ? n(c.trim() || null) : r(new Error(`Exit code ${m}`));
       });
     });
-    return Object.assign(r, { abort: s });
+    return Object.assign(o, { abort: s });
   }
   async downloadAsrModel(t = this.whisperModel) {
     if (!this.ai.options.whisper?.binary) throw new Error("Whisper not configured");
@@ -471,10 +478,10 @@ class F {
    */
   ocr(t) {
     let e;
-    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);
+    const s = new Promise(async (o) => {
+      e = await N(this.ai.options.tesseract?.model || "eng", 2, { cachePath: this.ai.options.path });
+      const { data: n } = await e.recognize(t);
+      await e.terminate(), o(n.text.trim() || null);
     });
     return Object.assign(s, { abort: () => e?.terminate() });
   }
@@ -494,7 +501,7 @@ const B = {
   name: "cli",
   description: "Use the command line interface, returns any output",
   args: { command: { type: "string", description: "Command to run", required: !0 } },
-  fn: (p) => C`${p.command}`
+  fn: (h) => I`${h.command}`
 }, ce = {
   name: "get_datetime",
   description: "Get current UTC date / time",
@@ -507,15 +514,15 @@ const B = {
     language: { type: "string", description: "Execution language", enum: ["cli", "node", "python"], required: !0 },
     code: { type: "string", description: "Code to execute", required: !0 }
   },
-  fn: async (p, t, e) => {
+  fn: async (h, t, e) => {
     try {
-      switch (p.type) {
+      switch (h.type) {
         case "bash":
-          return await B.fn({ command: p.code }, t, e);
+          return await B.fn({ command: h.code }, t, e);
         case "node":
-          return await G.fn({ code: p.code }, t, e);
+          return await G.fn({ code: h.code }, t, e);
         case "python":
-          return await Q.fn({ code: p.code }, t, e);
+          return await Q.fn({ code: h.code }, t, e);
       }
     } catch (s) {
       return { error: s?.message || s.toString() };
@@ -530,15 +537,15 @@ const B = {
     headers: { type: "object", description: "HTTP headers to send", default: {} },
     body: { type: "object", description: "HTTP body to send" }
   },
-  fn: (p) => new M({ url: p.url, headers: p.headers }).request({ method: p.method || "GET", body: p.body })
+  fn: (h) => new M({ url: h.url, headers: h.headers }).request({ method: h.method || "GET", body: h.body })
 }, G = {
   name: "exec_javascript",
   description: "Execute commonjs javascript",
   args: {
     code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
-  fn: async (p) => {
-    const t = q(null), e = await P({ console: t }, p.code, !0).catch((s) => t.output.error.push(s));
+  fn: async (h) => {
+    const t = q(null), e = await P({ console: t }, h.code, !0).catch((s) => t.output.error.push(s));
     return { ...t.output, return: e, stdout: void 0, stderr: void 0 };
   }
 }, Q = {
@@ -547,7 +554,7 @@ const B = {
   args: {
     code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
-  fn: async (p) => ({ result: D`python -c "${p.code}"` })
+  fn: async (h) => ({ result: D`python -c "${h.code}"` })
 }, de = {
   name: "read_webpage",
   description: "Extract clean, structured content from a webpage. Use after web_search to read specific URLs",
@@ -555,25 +562,25 @@ const B = {
     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 (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);
+  fn: async (h) => {
+    const t = await fetch(h.url, { headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" } }).then((r) => r.text()).catch((r) => {
+      throw new Error(`Failed to fetch: ${r.message}`);
+    }), e = C.load(t);
     e('script, style, nav, footer, header, aside, iframe, noscript, [role="navigation"], [role="banner"], .ad, .ads, .cookie, .popup').remove();
     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 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();
+    let o = "";
+    const n = ["article", "main", '[role="main"]', ".content", ".post", ".entry", "body"];
+    for (const r of n) {
+      const i = e(r).first();
+      if (i.length && i.text().trim().length > 200) {
+        o = i.text();
         break;
       }
     }
-    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 };
+    return o || (o = e("body").text()), o = o.replace(/\s+/g, " ").trim().slice(0, 8e3), { url: h.url, title: s.title.trim(), description: s.description.trim(), content: o, focus: h.focus };
   }
 }, ue = {
   name: "web_search",
@@ -582,17 +589,17 @@ const B = {
     query: { type: "string", description: "Search string", required: !0 },
     length: { type: "string", description: "Number of results to return", default: 5 }
   },
-  fn: async (p) => {
-    const t = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(p.query)}`, {
+  fn: async (h) => {
+    const t = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(h.query)}`, {
       headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)", "Accept-Language": "en-US,en;q=0.9" }
-    }).then((c) => c.text());
+    }).then((n) => n.text());
     let e, s = /<a .*?href="(.+?)".+?<\/a>/g;
-    const r = new E();
+    const o = new $();
     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;
+      let n = /uddg=(.+)&amp?/.exec(decodeURIComponent(e[1]))?.[1];
+      if (n && (n = decodeURIComponent(n)), n && o.add(n), o.size >= (h.length || 5)) break;
     }
-    return r;
+    return o;
   }
 };
 export {