@ztimson/ai-utils 0.7.9 → 0.7.10

package/dist/index.mjs

@@ -6,8 +6,8 @@ import { OpenAI as U } from "openai";
 import { fileURLToPath as z } from "url";
 import { join as N, dirname as L } from "path";
 import { spawn as g, execSync as C } from "node:child_process";
-import { mkdtempSync as J, rmSync as W } from "node:fs";
-import k from "node:fs/promises";
+import { mkdtempSync as J } from "node:fs";
+import k, { rm as W } from "node:fs/promises";
 import _, { join as x } from "node:path";
 import { createWorker as D } from "tesseract.js";
 import * as I from "cheerio";
@@ -21,19 +21,19 @@ class G extends E {
   client;
   toStandard(r) {
     const e = Date.now(), t = [];
-    for (let l of r)
-      if (typeof l.content == "string")
-        t.push({ timestamp: e, ...l });
+    for (let m of r)
+      if (typeof m.content == "string")
+        t.push({ timestamp: e, ...m });
       else {
-        const n = l.content?.filter((s) => s.type == "text").map((s) => s.text).join(`
+        const n = m.content?.filter((s) => s.type == "text").map((s) => s.text).join(`
 
 `);
-        n && t.push({ timestamp: e, role: l.role, content: n }), l.content.forEach((s) => {
+        n && t.push({ timestamp: e, role: m.role, content: n }), m.content.forEach((s) => {
           if (s.type == "tool_use")
             t.push({ timestamp: e, role: "tool", id: s.id, name: s.name, args: s.input, content: void 0 });
           else if (s.type == "tool_result") {
-            const o = t.findLast((c) => c.id == s.tool_use_id);
-            o && (o[s.is_error ? "error" : "content"] = s.content);
+            const i = t.findLast((l) => l.id == s.tool_use_id);
+            i && (i[s.is_error ? "error" : "content"] = s.content);
           }
         });
       }
@@ -54,78 +54,78 @@ class G extends E {
   }
   ask(r, e = {}) {
     const t = new AbortController();
-    return Object.assign(new Promise(async (l) => {
+    return Object.assign(new Promise(async (m) => {
       let n = this.fromStandard([...e.history || [], { role: "user", content: r, timestamp: Date.now() }]);
-      const s = e.tools || this.ai.options.llm?.tools || [], o = {
+      const s = 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: s.map((m) => ({
-          name: m.name,
-          description: m.description,
+        tools: s.map((a) => ({
+          name: a.name,
+          description: a.description,
           input_schema: {
             type: "object",
-            properties: m.args ? j(m.args, (i, d) => ({ ...d, required: void 0 })) : {},
-            required: m.args ? Object.entries(m.args).filter((i) => i[1].required).map((i) => i[0]) : []
+            properties: a.args ? j(a.args, (o, c) => ({ ...c, required: void 0 })) : {},
+            required: a.args ? Object.entries(a.args).filter((o) => o[1].required).map((o) => o[0]) : []
           },
           fn: void 0
         })),
         messages: n,
         stream: !!e.stream
       };
-      let c, a = !0;
+      let l, d = !0;
       do {
-        if (c = await this.client.messages.create(o).catch((i) => {
-          throw i.message += `
+        if (l = await this.client.messages.create(i).catch((o) => {
+          throw o.message += `
 
 Messages:
-${JSON.stringify(n, null, 2)}`, i;
+${JSON.stringify(n, null, 2)}`, o;
         }), e.stream) {
-          a ? a = !1 : e.stream({ text: `
+          d ? d = !1 : e.stream({ text: `
 
-` }), c.content = [];
-          for await (const i of c) {
+` }), l.content = [];
+          for await (const o of l) {
             if (t.signal.aborted) break;
-            if (i.type === "content_block_start")
-              i.content_block.type === "text" ? c.content.push({ type: "text", text: "" }) : i.content_block.type === "tool_use" && c.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 d = i.delta.text;
-                c.content.at(-1).text += d, e.stream({ text: d });
-              } else i.delta.type === "input_json_delta" && (c.content.at(-1).input += i.delta.partial_json);
-            else if (i.type === "content_block_stop") {
-              const d = c.content.at(-1);
-              d.input != null && (d.input = d.input ? w(d.input, {}) : {});
-            } else if (i.type === "message_stop")
+            if (o.type === "content_block_start")
+              o.content_block.type === "text" ? l.content.push({ type: "text", text: "" }) : o.content_block.type === "tool_use" && l.content.push({ type: "tool_use", id: o.content_block.id, name: o.content_block.name, input: "" });
+            else if (o.type === "content_block_delta")
+              if (o.delta.type === "text_delta") {
+                const c = o.delta.text;
+                l.content.at(-1).text += c, e.stream({ text: c });
+              } else o.delta.type === "input_json_delta" && (l.content.at(-1).input += o.delta.partial_json);
+            else if (o.type === "content_block_stop") {
+              const c = l.content.at(-1);
+              c.input != null && (c.input = c.input ? w(c.input, {}) : {});
+            } else if (o.type === "message_stop")
               break;
           }
         }
-        const m = c.content.filter((i) => i.type === "tool_use");
-        if (m.length && !t.signal.aborted) {
-          n.push({ role: "assistant", content: c.content });
-          const i = await Promise.all(m.map(async (d) => {
-            const p = s.find(T("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" };
+        const a = l.content.filter((o) => o.type === "tool_use");
+        if (a.length && !t.signal.aborted) {
+          n.push({ role: "assistant", content: l.content });
+          const o = await Promise.all(a.map(async (c) => {
+            const p = s.find(T("name", c.name));
+            if (e.stream && e.stream({ tool: c.name }), !p) return { tool_use_id: c.id, is_error: !0, content: "Tool not found" };
             try {
-              const u = await p.fn(d.input, e?.stream, this.ai);
-              return { type: "tool_result", tool_use_id: d.id, content: b(u) };
+              const u = await p.fn(c.input, e?.stream, this.ai);
+              return { type: "tool_result", tool_use_id: c.id, content: b(u) };
             } catch (u) {
-              return { type: "tool_result", tool_use_id: d.id, is_error: !0, content: u?.message || u?.toString() || "Unknown" };
+              return { type: "tool_result", tool_use_id: c.id, is_error: !0, content: u?.message || u?.toString() || "Unknown" };
             }
           }));
-          n.push({ role: "user", content: i }), o.messages = n;
+          n.push({ role: "user", content: o }), i.messages = n;
         }
-      } while (!t.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(`
+      } while (!t.signal.aborted && l.content.some((a) => a.type === "tool_use"));
+      n.push({ role: "assistant", content: l.content.filter((a) => a.type == "text").map((a) => a.text).join(`
 
-`) }), n = this.toStandard(n), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...n), l(n.at(-1)?.content);
+`) }), n = this.toStandard(n), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...n), m(n.at(-1)?.content);
     }), { abort: () => t.abort() });
   }
 }
 class S extends E {
-  constructor(r, e, t, l) {
-    super(), this.ai = r, this.host = e, this.token = t, this.model = l, this.client = new U(M({
+  constructor(r, e, t, m) {
+    super(), this.ai = r, this.host = e, this.token = t, this.model = m, this.client = new U(M({
       baseURL: e,
       apiKey: t
     }));
@@ -135,17 +135,17 @@ class S extends E {
     for (let e = 0; e < r.length; e++) {
       const t = r[e];
       if (t.role === "assistant" && t.tool_calls) {
-        const l = t.tool_calls.map((n) => ({
+        const m = t.tool_calls.map((n) => ({
           role: "tool",
           id: n.id,
           name: n.function.name,
           args: w(n.function.arguments, {}),
           timestamp: t.timestamp
         }));
-        r.splice(e, 1, ...l), e += l.length - 1;
+        r.splice(e, 1, ...m), e += m.length - 1;
       } else if (t.role === "tool" && t.content) {
-        const l = r.find((n) => t.tool_call_id == n.id);
-        l && (t.content.includes('"error":') ? l.error = t.content : l.content = t.content), r.splice(e, 1), e--;
+        const m = r.find((n) => t.tool_call_id == n.id);
+        m && (t.content.includes('"error":') ? m.error = t.content : m.content = t.content), r.splice(e, 1), e--;
       }
       r[e]?.timestamp || (r[e].timestamp = Date.now());
     }
@@ -166,7 +166,7 @@ class S extends E {
           content: t.error || t.content
         });
       else {
-        const { timestamp: l, ...n } = t;
+        const { timestamp: m, ...n } = t;
         e.push(n);
       }
       return e;
@@ -174,49 +174,49 @@ class S extends E {
   }
   ask(r, e = {}) {
     const t = new AbortController();
-    return Object.assign(new Promise(async (l, n) => {
+    return Object.assign(new Promise(async (m, n) => {
       e.system && e.history?.[0]?.role != "system" && e.history?.splice(0, 0, { role: "system", content: e.system, timestamp: Date.now() });
       let s = this.fromStandard([...e.history || [], { role: "user", content: r, timestamp: Date.now() }]);
-      const o = e.tools || this.ai.options.llm?.tools || [], c = {
+      const i = e.tools || this.ai.options.llm?.tools || [], l = {
         model: e.model || this.model,
         messages: s,
         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: o.map((i) => ({
+        tools: i.map((o) => ({
           type: "function",
           function: {
-            name: i.name,
-            description: i.description,
+            name: o.name,
+            description: o.description,
             parameters: {
               type: "object",
-              properties: i.args ? j(i.args, (d, p) => ({ ...p, required: void 0 })) : {},
-              required: i.args ? Object.entries(i.args).filter((d) => d[1].required).map((d) => d[0]) : []
+              properties: o.args ? j(o.args, (c, p) => ({ ...p, required: void 0 })) : {},
+              required: o.args ? Object.entries(o.args).filter((c) => c[1].required).map((c) => c[0]) : []
             }
           }
         }))
       };
-      let a, m = !0;
+      let d, a = !0;
       do {
-        if (a = await this.client.chat.completions.create(c).catch((d) => {
-          throw d.message += `
+        if (d = await this.client.chat.completions.create(l).catch((c) => {
+          throw c.message += `
 
 Messages:
-${JSON.stringify(s, null, 2)}`, d;
+${JSON.stringify(s, null, 2)}`, c;
         }), e.stream) {
-          m ? m = !1 : e.stream({ text: `
+          a ? a = !1 : e.stream({ text: `
 
-` }), a.choices = [{ message: { content: "", tool_calls: [] } }];
-          for await (const d of a) {
+` }), d.choices = [{ message: { content: "", tool_calls: [] } }];
+          for await (const c of d) {
             if (t.signal.aborted) break;
-            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);
+            c.choices[0].delta.content && (d.choices[0].message.content += c.choices[0].delta.content, e.stream({ text: c.choices[0].delta.content })), c.choices[0].delta.tool_calls && (d.choices[0].message.tool_calls = c.choices[0].delta.tool_calls);
           }
         }
-        const i = a.choices[0].message.tool_calls || [];
-        if (i.length && !t.signal.aborted) {
-          s.push(a.choices[0].message);
-          const d = await Promise.all(i.map(async (p) => {
-            const u = o?.find(T("name", p.function.name));
+        const o = d.choices[0].message.tool_calls || [];
+        if (o.length && !t.signal.aborted) {
+          s.push(d.choices[0].message);
+          const c = await Promise.all(o.map(async (p) => {
+            const u = i?.find(T("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 = w(p.function.arguments, {}), y = await u.fn(f, e.stream, this.ai);
@@ -225,10 +225,10 @@ ${JSON.stringify(s, null, 2)}`, d;
               return { role: "tool", tool_call_id: p.id, content: b({ error: f?.message || f?.toString() || "Unknown" }) };
             }
           }));
-          s.push(...d), c.messages = s;
+          s.push(...c), l.messages = s;
         }
-      } while (!t.signal.aborted && a.choices?.[0]?.message?.tool_calls?.length);
-      s.push({ role: "assistant", content: a.choices[0].message.content || "" }), s = this.toStandard(s), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...s), l(s.at(-1)?.content);
+      } while (!t.signal.aborted && d.choices?.[0]?.message?.tool_calls?.length);
+      s.push({ role: "assistant", content: d.choices[0].message.content || "" }), s = this.toStandard(s), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...s), m(s.at(-1)?.content);
     }), { abort: () => t.abort() });
   }
 }
@@ -249,22 +249,22 @@ class B {
   ask(r, e = {}) {
     const t = e.model || this.defaultModel;
     if (!this.models[t]) throw new Error(`Model does not exist: ${t}`);
-    let l = () => {
+    let m = () => {
     };
     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 o = async (a, m, i = 50) => {
-          const [d, p] = await Promise.all([
-            m ? this.embedding(m) : Promise.resolve(null),
-            a ? this.embedding(a) : Promise.resolve(null)
+        const i = async (d, a, o = 50) => {
+          const [c, p] = await Promise.all([
+            a ? this.embedding(a) : Promise.resolve(null),
+            d ? this.embedding(d) : Promise.resolve(null)
           ]);
-          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, i);
-        }, c = await o(r);
-        c.length && e.history.push({ role: "assistant", content: `Things I remembered:
-` + c.map((a) => `${a.owner}: ${a.fact}`).join(`
+          return (e.memory || []).map((u) => ({ ...u, score: c ? this.cosineSimilarity(u.embeddings[0], c[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, o);
+        }, l = await i(r);
+        l.length && e.history.push({ role: "assistant", content: `Things I remembered:
+` + l.map((d) => `${d.owner}: ${d.fact}`).join(`
 `) }), e.tools = [...e.tools || [], {
           name: "read_memory",
           description: "Check your long-term memory for more information",
@@ -273,32 +273,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: (a) => {
-            if (!a.subject && !a.query) throw new Error("Either a subject or query argument is required");
-            return o(a.query, a.subject, a.limit || 5);
+          fn: (d) => {
+            if (!d.subject && !d.query) throw new Error("Either a subject or query argument is required");
+            return i(d.query, d.subject, d.limit || 5);
           }
         }];
       }
       const s = await this.models[t].ask(r, e);
       if (e.memory) {
-        const o = e.history?.findIndex((c) => c.role == "assistant" && c.content.startsWith("Things I remembered:"));
-        o != null && o >= 0 && e.history?.splice(o, 1);
+        const i = e.history?.findIndex((l) => l.role == "assistant" && l.content.startsWith("Things I remembered:"));
+        i != null && i >= 0 && e.history?.splice(i, 1);
       }
       if (e.compress || e.memory) {
-        let o = null;
+        let i = null;
         if (e.compress)
-          o = await this.ai.language.compressHistory(e.history, e.compress.max, e.compress.min, e), e.history.splice(0, e.history.length, ...o.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 c = e.history?.findLastIndex((a) => a.role == "user") ?? -1;
-          o = await this.ai.language.compressHistory(c != -1 ? e.history.slice(c) : e.history, 0, 0, e);
+          const l = e.history?.findLastIndex((d) => d.role == "user") ?? -1;
+          i = await this.ai.language.compressHistory(l != -1 ? e.history.slice(l) : e.history, 0, 0, e);
         }
         if (e.memory) {
-          const c = e.memory.filter((a) => !o.memory.some((m) => this.cosineSimilarity(a.embeddings[1], m.embeddings[1]) > 0.8)).concat(o.memory);
-          e.memory.splice(0, e.memory.length, ...c);
+          const l = e.memory.filter((d) => !i.memory.some((a) => this.cosineSimilarity(d.embeddings[1], a.embeddings[1]) > 0.8)).concat(i.memory);
+          e.memory.splice(0, e.memory.length, ...l);
         }
       }
       return n(s);
-    }), { abort: l });
+    }), { abort: m });
   }
   /**
    * Compress chat history to reduce context size
@@ -308,24 +308,24 @@ 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(r, e, t, l) {
+  async compressHistory(r, e, t, m) {
     if (this.estimateTokens(r) < e) return { history: r, memory: [] };
     let n = 0, s = 0;
     for (let u of r.toReversed())
       if (s += this.estimateTokens(u.content), s < t) n++;
       else break;
     if (r.length <= n) return { history: r, memory: [] };
-    const o = r[0].role == "system" ? r[0] : null, c = n == 0 ? [] : r.slice(-n), a = (n == 0 ? r : r.slice(0, -n)).filter((u) => u.role === "assistant" || u.role === "user"), m = await this.json(a.map((u) => `${u.role}: ${u.content}`).join(`
+    const i = r[0].role == "system" ? r[0] : null, l = n == 0 ? [] : r.slice(-n), d = (n == 0 ? r : r.slice(0, -n)).filter((u) => u.role === "assistant" || u.role === "user"), a = await this.json(d.map((u) => `${u.role}: ${u.content}`).join(`
 
 `), "{summary: string, facts: [[subject, fact]]}", {
       system: "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.",
-      model: l?.model,
-      temperature: l?.temperature || 0.3
-    }), i = /* @__PURE__ */ new Date(), d = await Promise.all((m?.facts || [])?.map(async ([u, f]) => {
+      model: m?.model,
+      temperature: m?.temperature || 0.3
+    }), o = /* @__PURE__ */ new Date(), c = await Promise.all((a?.facts || [])?.map(async ([u, f]) => {
       const y = await Promise.all([this.embedding(u), this.embedding(`${u}: ${f}`)]);
-      return { owner: u, fact: f, embeddings: [y[0][0].embedding, y[1][0].embedding], timestamp: i };
-    })), p = [{ role: "assistant", content: `Conversation Summary: ${m?.summary}`, timestamp: Date.now() }, ...c];
-    return o && p.splice(0, 0, o), { history: p, memory: d };
+      return { owner: u, fact: f, embeddings: [y[0][0].embedding, y[1][0].embedding], timestamp: o };
+    })), p = [{ role: "assistant", content: `Conversation Summary: ${a?.summary}`, timestamp: Date.now() }, ...l];
+    return i && p.splice(0, 0, i), { history: p, memory: c };
   }
   /**
    * Compare the difference between embeddings (calculates the angle between two vectors)
@@ -335,10 +335,10 @@ You have passive persistent memory never make any mention of your memory capabil
    */
   cosineSimilarity(r, e) {
     if (r.length !== e.length) throw new Error("Vectors must be same length");
-    let t = 0, l = 0, n = 0;
-    for (let o = 0; o < r.length; o++)
-      t += r[o] * e[o], l += r[o] * r[o], n += e[o] * e[o];
-    const s = Math.sqrt(l) * Math.sqrt(n);
+    let t = 0, m = 0, n = 0;
+    for (let i = 0; i < r.length; i++)
+      t += r[i] * e[i], m += r[i] * r[i], n += e[i] * e[i];
+    const s = Math.sqrt(m) * Math.sqrt(n);
     return s === 0 ? 0 : t / s;
   }
   /**
@@ -349,25 +349,25 @@ You have passive persistent memory never make any mention of your memory capabil
    * @returns {string[]} Chunked strings
    */
   chunk(r, e = 500, t = 50) {
-    const l = (c, a = "") => c ? Object.entries(c).flatMap(([m, i]) => {
-      const d = a ? `${a}${isNaN(+m) ? `.${m}` : `[${m}]`}` : m;
-      return typeof i == "object" && !Array.isArray(i) ? l(i, d) : `${d}: ${Array.isArray(i) ? i.join(", ") : i}`;
-    }) : [], s = (typeof r == "object" ? l(r) : r.split(`
-`)).flatMap((c) => [...c.split(/\s+/).filter(Boolean), `
-`]), o = [];
-    for (let c = 0; c < s.length; ) {
-      let a = "", m = c;
-      for (; m < s.length; ) {
-        const d = a + (a ? " " : "") + s[m];
-        if (this.estimateTokens(d.replace(/\s*\n\s*/g, `
-`)) > e && a) break;
-        a = d, m++;
+    const m = (l, d = "") => l ? Object.entries(l).flatMap(([a, o]) => {
+      const c = d ? `${d}${isNaN(+a) ? `.${a}` : `[${a}]`}` : a;
+      return typeof o == "object" && !Array.isArray(o) ? m(o, c) : `${c}: ${Array.isArray(o) ? o.join(", ") : o}`;
+    }) : [], s = (typeof r == "object" ? m(r) : r.split(`
+`)).flatMap((l) => [...l.split(/\s+/).filter(Boolean), `
+`]), i = [];
+    for (let l = 0; l < s.length; ) {
+      let d = "", a = l;
+      for (; a < s.length; ) {
+        const c = d + (d ? " " : "") + s[a];
+        if (this.estimateTokens(c.replace(/\s*\n\s*/g, `
+`)) > e && d) break;
+        d = c, a++;
       }
-      const i = a.replace(/\s*\n\s*/g, `
+      const o = d.replace(/\s*\n\s*/g, `
 `).trim();
-      i && o.push(i), c = Math.max(m - t, m === c ? c + 1 : m);
+      o && i.push(o), l = Math.max(a - t, a === l ? l + 1 : a);
     }
-    return o;
+    return i;
   }
   /**
    * Create a vector representation of a string
@@ -376,39 +376,39 @@ You have passive persistent memory never make any mention of your memory capabil
    * @returns {Promise<Awaited<{index: number, embedding: number[], text: string, tokens: number}>[]>} Chunked embeddings
    */
   embedding(r, e = {}) {
-    let { maxTokens: t = 500, overlapTokens: l = 50 } = e, n = !1;
+    let { maxTokens: t = 500, overlapTokens: m = 50 } = e, n = !1;
     const s = () => {
       n = !0;
-    }, o = (a) => new Promise((m, i) => {
-      if (n) return i(new Error("Aborted"));
-      const d = [
+    }, i = (d) => new Promise((a, o) => {
+      if (n) return o(new Error("Aborted"));
+      const c = [
         N(L(z(import.meta.url)), "embedder.js"),
         this.ai.options.path,
         this.ai.options?.embedder || "bge-small-en-v1.5"
-      ], p = g("node", d, { stdio: ["pipe", "pipe", "ignore"] });
-      p.stdin.write(a), p.stdin.end();
+      ], p = g("node", c, { stdio: ["pipe", "pipe", "ignore"] });
+      p.stdin.write(d), p.stdin.end();
       let u = "";
       p.stdout.on("data", (f) => u += f.toString()), p.on("close", (f) => {
-        if (n) return i(new Error("Aborted"));
+        if (n) return o(new Error("Aborted"));
         if (f === 0)
           try {
             const y = JSON.parse(u);
-            m(y.embedding);
+            a(y.embedding);
           } catch {
-            i(new Error("Failed to parse embedding output"));
+            o(new Error("Failed to parse embedding output"));
           }
         else
-          i(new Error(`Embedder process exited with code ${f}`));
-      }), p.on("error", i);
-    }), c = (async () => {
-      const a = this.chunk(r, t, l), m = [];
-      for (let i = 0; i < a.length && !n; i++) {
-        const d = a[i], p = await o(d);
-        m.push({ index: i, embedding: p, text: d, tokens: this.estimateTokens(d) });
+          o(new Error(`Embedder process exited with code ${f}`));
+      }), p.on("error", o);
+    }), l = (async () => {
+      const d = this.chunk(r, t, m), a = [];
+      for (let o = 0; o < d.length && !n; o++) {
+        const c = d[o], p = await i(c);
+        a.push({ index: o, embedding: p, text: c, tokens: this.estimateTokens(c) });
       }
-      return m;
+      return a;
     })();
-    return Object.assign(c, { abort: s });
+    return Object.assign(l, { abort: s });
   }
   /**
    * Estimate variable as tokens
@@ -427,8 +427,8 @@ You have passive persistent memory never make any mention of your memory capabil
    */
   fuzzyMatch(r, ...e) {
     if (e.length < 2) throw new Error("Requires at least 2 strings to compare");
-    const t = (s, o = 10) => s.toLowerCase().split("").map((c, a) => c.charCodeAt(0) * (a + 1) % o / o).slice(0, o), l = t(r), n = e.map((s) => t(s)).map((s) => this.cosineSimilarity(l, s));
-    return { avg: n.reduce((s, o) => s + o, 0) / n.length, max: Math.max(...n), similarities: n };
+    const t = (s, i = 10) => s.toLowerCase().split("").map((l, d) => l.charCodeAt(0) * (d + 1) % i / i).slice(0, i), m = t(r), n = e.map((s) => t(s)).map((s) => this.cosineSimilarity(m, s));
+    return { avg: n.reduce((s, i) => s + i, 0) / n.length, max: Math.max(...n), similarities: n };
   }
   /**
    * Ask a question with JSON response
@@ -438,13 +438,13 @@ You have passive persistent memory never make any mention of your memory capabil
    * @returns {Promise<{} | {} | RegExpExecArray | null>}
    */
   async json(r, e, t) {
-    let l = await this.ask(r, { ...t, system: (t?.system ? `${t.system}
+    let m = await this.ask(r, { ...t, system: (t?.system ? `${t.system}
 ` : "") + `Only respond using a JSON code block matching this schema:
 \`\`\`json
 ${e}
 \`\`\`` });
-    if (!l) return {};
-    const n = /```(?:.+)?\s*([\s\S]*?)```/.exec(l), s = n ? n[1].trim() : l;
+    if (!m) return {};
+    const n = /```(?:.+)?\s*([\s\S]*?)```/.exec(m), s = n ? n[1].trim() : m;
     return w(s, {});
   }
   /**
@@ -482,96 +482,98 @@ print(json.dumps(segments))
   whisperModel;
   runAsr(r, e = {}) {
     let t;
-    const l = new Promise((n, s) => {
-      this.downloadAsrModel(e.model).then((o) => {
-        let c = "";
-        const a = [e.diarization ? "-owts" : "-nt", "-m", o, "-f", r];
-        t = g(this.ai.options.whisper, a, { stdio: ["ignore", "pipe", "ignore"] }), t.on("error", (m) => s(m)), t.stdout.on("data", (m) => c += m.toString()), t.on("close", (m) => {
-          if (m === 0)
+    const m = new Promise((n, s) => {
+      this.downloadAsrModel(e.model).then((i) => {
+        let l = "";
+        const d = [e.diarization ? "-owts" : "-nt", "-m", i, "-f", r];
+        console.log(this.ai.options.whisper + " " + d.join(" ")), t = g(this.ai.options.whisper, d, { stdio: ["ignore", "pipe", "ignore"] }), t.on("error", (a) => s(a)), t.stdout.on("data", (a) => l += a.toString()), t.on("close", (a) => {
+          if (a === 0)
             if (e.diarization)
               try {
-                n(JSON.parse(c));
+                n(JSON.parse(l));
               } catch {
                 s(new Error("Failed to parse whisper JSON"));
               }
             else
-              n(c.trim() || null);
+              n(l.trim() || null);
           else
-            s(new Error(`Exit code ${m}`));
+            s(new Error(`Exit code ${a}`));
         });
       });
     });
-    return Object.assign(l, { abort: () => t?.kill("SIGTERM") });
+    return Object.assign(m, { abort: () => t?.kill("SIGTERM") });
   }
   runDiarization(r) {
     let e = !1, t = () => {
       e = !0;
     };
-    const l = (s) => new Promise((o) => {
-      const c = g(s, ["-c", "import pyannote.audio"]);
-      c.on("close", (a) => o(a === 0)), c.on("error", () => o(!1));
+    const m = (s) => new Promise((i) => {
+      const l = g(s, ["-c", "import pyannote.audio"]);
+      l.on("close", (d) => i(d === 0)), l.on("error", () => i(!1));
     }), n = Promise.all([
-      l("python"),
-      l("python3")
-    ]).then((async ([s, o]) => {
+      m("python"),
+      m("python3")
+    ]).then((async ([s, i]) => {
       if (e) return;
-      if (!s && !o) throw new Error("Pyannote is not installed: pip install pyannote.audio");
-      const c = o ? "python3" : "python";
-      let a = null;
-      return new Promise((m, i) => {
-        if (a = x(J(x(P(), "audio-")), "converted.wav"), C(`ffmpeg -i "${r}" -ar 16000 -ac 1 -f wav "${a}"`, { stdio: "ignore" }), e) return;
-        let d = "";
-        const p = g(c, ["-c", this.pyannote, a]);
-        p.stdout.on("data", (u) => d += u.toString()), p.stderr.on("data", (u) => console.error(u.toString())), p.on("close", (u) => {
-          if (u === 0)
+      if (!s && !i) throw new Error("Pyannote is not installed: pip install pyannote.audio");
+      const l = i ? "python3" : "python";
+      return new Promise((d, a) => {
+        if (e) return;
+        let o = "";
+        const c = g(l, ["-c", this.pyannote, r]);
+        c.stdout.on("data", (p) => o += p.toString()), c.stderr.on("data", (p) => console.error(p.toString())), c.on("close", (p) => {
+          if (p === 0)
             try {
-              m(JSON.parse(d));
+              d(JSON.parse(o));
             } catch {
-              i(new Error("Failed to parse diarization output"));
+              a(new Error("Failed to parse diarization output"));
             }
           else
-            i(new Error(`Python process exited with code ${u}`));
-        }), p.on("error", i), t = () => p.kill("SIGTERM");
-      }).finally(() => {
-        a && W(_.dirname(a), { recursive: !0, force: !0 });
+            a(new Error(`Python process exited with code ${p}`));
+        }), c.on("error", a), t = () => c.kill("SIGTERM");
       });
     }));
     return Object.assign(n, { abort: t });
   }
   combineSpeakerTranscript(r, e) {
     const t = /* @__PURE__ */ new Map();
-    let l = 0;
-    e.forEach((c) => {
-      t.has(c.speaker) || t.set(c.speaker, ++l);
+    let m = 0;
+    e.forEach((l) => {
+      t.has(l.speaker) || t.set(l.speaker, ++m);
     });
     const n = [];
-    let s = -1, o = "";
-    return r.transcription.forEach((c) => {
-      const a = c.offsets.from / 1e3, m = e.find((d) => a >= d.start && a <= d.end), i = m ? t.get(m.speaker) : 1;
-      i !== s ? (o && n.push(`[Speaker ${s}]: ${o.trim()}`), s = i, o = c.text) : o += " " + c.text;
-    }), o && n.push(`[Speaker ${s}]: ${o.trim()}`), n.join(`
+    let s = -1, i = "";
+    return r.transcription.forEach((l) => {
+      const d = l.offsets.from / 1e3, a = e.find((c) => d >= c.start && d <= c.end), o = a ? t.get(a.speaker) : 1;
+      o !== s ? (i && n.push(`[Speaker ${s}]: ${i.trim()}`), s = o, i = l.text) : i += " " + l.text;
+    }), i && n.push(`[Speaker ${s}]: ${i.trim()}`), n.join(`
 `);
   }
   asr(r, e = {}) {
     if (!this.ai.options.whisper) throw new Error("Whisper not configured");
-    const t = this.runAsr(r, { model: e.model, diarization: !!e.diarization }), l = e.diarization ? this.runDiarization(r) : Promise.resolve(null), n = () => {
-      t.abort(), l?.abort?.();
-    }, s = Promise.all([t, l]).then(async ([o, c]) => {
-      if (!e.diarization) return o;
-      if (o = this.combineSpeakerTranscript(o, c), e.diarization === "id") {
+    const t = x(J(x(P(), "audio-")), "converted.wav");
+    C(`ffmpeg -i "${r}" -ar 16000 -ac 1 -f wav "${t}"`, { stdio: "ignore" });
+    const m = () => W(_.dirname(t), { recursive: !0, force: !0 }).catch(() => {
+    }), n = this.runAsr(t, { model: e.model, diarization: !!e.diarization }), s = e.diarization ? this.runDiarization(t) : Promise.resolve(null);
+    let i = !1, l = () => {
+      i = !0, n.abort(), s?.abort?.(), m();
+    };
+    const d = Promise.all([n, s]).then(async ([a, o]) => {
+      if (i || !e.diarization) return a;
+      if (a = this.combineSpeakerTranscript(a, o), !i && e.diarization === "id") {
         if (!this.ai.language.defaultModel) throw new Error("Configure an LLM for advanced ASR speaker detection");
-        let a = this.ai.language.chunk(o, 500, 0);
-        a.length > 4 && (a = [...a.slice(0, 3), a.at(-1)]);
-        const m = await this.ai.language.json(a.join(`
+        let c = this.ai.language.chunk(a, 500, 0);
+        c.length > 4 && (c = [...c.slice(0, 3), c.at(-1)]);
+        const p = await this.ai.language.json(c.join(`
 `), '{1: "Detected Name", 2: "Second Name"}', {
           system: "Use the following transcript to identify speakers. Only identify speakers you are positive about, dont mention speakers you are unsure about in your response",
           temperature: 0.1
         });
-        Object.entries(m).forEach(([i, d]) => o = o.replaceAll(`[Speaker ${i}]`, `[${d}]`));
+        Object.entries(p).forEach(([u, f]) => a = a.replaceAll(`[Speaker ${u}]`, `[${f}]`));
       }
-      return o;
-    });
-    return Object.assign(s, { abort: n });
+      return a;
+    }).finally(() => m());
+    return Object.assign(d, { abort: l });
   }
   async downloadAsrModel(r = this.whisperModel) {
     if (!this.ai.options.whisper) throw new Error("Whisper not configured");
@@ -591,10 +593,10 @@ class V {
    */
   ocr(r) {
     let e;
-    const t = new Promise(async (l) => {
+    const t = new Promise(async (m) => {
       e = await D(this.ai.options.ocr || "eng", 2, { cachePath: this.ai.options.path });
       const { data: n } = await e.recognize(r);
-      await e.terminate(), l(n.text.trim() || null);
+      await e.terminate(), m(n.text.trim() || null);
     });
     return Object.assign(t, { abort: () => e?.terminate() });
   }
@@ -684,16 +686,16 @@ const Y = {
       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 l = "";
+    let m = "";
     const n = ["article", "main", '[role="main"]', ".content", ".post", ".entry", "body"];
     for (const s of n) {
-      const o = e(s).first();
-      if (o.length && o.text().trim().length > 200) {
-        l = o.text();
+      const i = e(s).first();
+      if (i.length && i.text().trim().length > 200) {
+        m = i.text();
         break;
       }
     }
-    return l || (l = e("body").text()), l = l.replace(/\s+/g, " ").trim().slice(0, 8e3), { url: h.url, title: t.title.trim(), description: t.description.trim(), content: l, focus: h.focus };
+    return m || (m = e("body").text()), m = m.replace(/\s+/g, " ").trim().slice(0, 8e3), { url: h.url, title: t.title.trim(), description: t.description.trim(), content: m, focus: h.focus };
   }
 }, ye = {
   name: "web_search",
@@ -707,12 +709,12 @@ const Y = {
       headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)", "Accept-Language": "en-US,en;q=0.9" }
     }).then((n) => n.text());
     let e, t = /<a .*?href="(.+?)".+?<\/a>/g;
-    const l = new v();
+    const m = new v();
     for (; (e = t.exec(r)) !== null; ) {
       let n = /uddg=(.+)&amp?/.exec(decodeURIComponent(e[1]))?.[1];
-      if (n && (n = decodeURIComponent(n)), n && l.add(n), l.size >= (h.length || 5)) break;
+      if (n && (n = decodeURIComponent(n)), n && m.add(n), m.size >= (h.length || 5)) break;
     }
-    return l;
+    return m;
   }
 };
 export {