@ztimson/ai-utils 0.7.0 → 0.7.2

package/dist/index.mjs

@@ -1,20 +1,20 @@
-import * as $ from "node:os";
-import { objectMap as _, JSONAttemptParse as g, findByProp as k, JSONSanitize as b, clean as M, Http as E, consoleInterceptor as P, fn as A, ASet as O } from "@ztimson/utils";
-import { Anthropic as v } from "@anthropic-ai/sdk";
-import { OpenAI as U } from "openai";
-import { Worker as x } from "worker_threads";
-import { fileURLToPath as j } from "url";
-import { join as S, dirname as T } from "path";
-import { canDiarization as R } from "./asr.mjs";
-import { createWorker as L } from "tesseract.js";
+import * as M from "node:os";
+import { objectMap as _, JSONAttemptParse as b, findByProp as x, JSONSanitize as w, clean as E, Http as P, consoleInterceptor as A, fn as O, ASet as v } from "@ztimson/utils";
+import { Anthropic as U } from "@anthropic-ai/sdk";
+import { OpenAI as R } from "openai";
+import { Worker as j } from "worker_threads";
+import { fileURLToPath as S } from "url";
+import { join as T, dirname as q } from "path";
+import { canDiarization as L } from "./asr.mjs";
+import { createWorker as D } from "tesseract.js";
 import "./embedder.mjs";
-import * as D from "cheerio";
-import { $ as N, $Sync as C } from "@ztimson/node-utils";
-class q {
+import * as N from "cheerio";
+import { $ as C, $Sync as W } from "@ztimson/node-utils";
+class $ {
 }
-class W extends q {
+class z extends $ {
   constructor(s, e, t) {
-    super(), this.ai = s, this.apiToken = e, this.model = t, this.client = new v({ apiKey: e });
+    super(), this.ai = s, this.apiToken = e, this.model = t, this.client = new U({ apiKey: e });
   }
   client;
   toStandard(s) {
@@ -23,15 +23,15 @@ class W extends q {
       if (typeof l.content == "string")
         t.push({ timestamp: e, ...l });
       else {
-        const r = l.content?.filter((n) => n.type == "text").map((n) => n.text).join(`
+        const r = l.content?.filter((o) => o.type == "text").map((o) => o.text).join(`
 
 `);
-        r && t.push({ timestamp: e, role: l.role, content: r }), l.content.forEach((n) => {
-          if (n.type == "tool_use")
-            t.push({ timestamp: e, role: "tool", id: n.id, name: n.name, args: n.input, content: void 0 });
-          else if (n.type == "tool_result") {
-            const i = t.findLast((o) => o.id == n.tool_use_id);
-            i && (i[n.is_error ? "error" : "content"] = n.content);
+        r && t.push({ timestamp: e, role: l.role, content: r }), l.content.forEach((o) => {
+          if (o.type == "tool_use")
+            t.push({ timestamp: e, role: "tool", id: o.id, name: o.name, args: o.input, content: void 0 });
+          else if (o.type == "tool_result") {
+            const m = t.findLast((i) => i.id == o.tool_use_id);
+            m && (m[o.is_error ? "error" : "content"] = o.content);
           }
         });
       }
@@ -54,76 +54,76 @@ class W extends q {
     const t = new AbortController();
     return Object.assign(new Promise(async (l) => {
       let r = this.fromStandard([...e.history || [], { role: "user", content: s, timestamp: Date.now() }]);
-      const n = e.tools || this.ai.options.llm?.tools || [], i = {
+      const o = 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: n.map((d) => ({
+        tools: o.map((d) => ({
           name: d.name,
           description: d.description,
           input_schema: {
             type: "object",
-            properties: d.args ? _(d.args, (c, m) => ({ ...m, required: void 0 })) : {},
-            required: d.args ? Object.entries(d.args).filter((c) => c[1].required).map((c) => c[0]) : []
+            properties: d.args ? _(d.args, (n, a) => ({ ...a, required: void 0 })) : {},
+            required: d.args ? Object.entries(d.args).filter((n) => n[1].required).map((n) => n[0]) : []
           },
           fn: void 0
         })),
         messages: r,
         stream: !!e.stream
       };
-      let o, a = !0;
+      let i, c = !0;
       do {
-        if (o = await this.client.messages.create(i).catch((c) => {
-          throw c.message += `
+        if (i = await this.client.messages.create(m).catch((n) => {
+          throw n.message += `
 
 Messages:
-${JSON.stringify(r, null, 2)}`, c;
+${JSON.stringify(r, null, 2)}`, n;
         }), e.stream) {
-          a ? a = !1 : e.stream({ text: `
+          c ? c = !1 : e.stream({ text: `
 
-` }), o.content = [];
-          for await (const c of o) {
+` }), i.content = [];
+          for await (const n of i) {
             if (t.signal.aborted) break;
-            if (c.type === "content_block_start")
-              c.content_block.type === "text" ? o.content.push({ type: "text", text: "" }) : c.content_block.type === "tool_use" && o.content.push({ type: "tool_use", id: c.content_block.id, name: c.content_block.name, input: "" });
-            else if (c.type === "content_block_delta")
-              if (c.delta.type === "text_delta") {
-                const m = c.delta.text;
-                o.content.at(-1).text += m, e.stream({ text: m });
-              } else c.delta.type === "input_json_delta" && (o.content.at(-1).input += c.delta.partial_json);
-            else if (c.type === "content_block_stop") {
-              const m = o.content.at(-1);
-              m.input != null && (m.input = m.input ? g(m.input, {}) : {});
-            } else if (c.type === "message_stop")
+            if (n.type === "content_block_start")
+              n.content_block.type === "text" ? i.content.push({ type: "text", text: "" }) : n.content_block.type === "tool_use" && i.content.push({ type: "tool_use", id: n.content_block.id, name: n.content_block.name, input: "" });
+            else if (n.type === "content_block_delta")
+              if (n.delta.type === "text_delta") {
+                const a = n.delta.text;
+                i.content.at(-1).text += a, e.stream({ text: a });
+              } else n.delta.type === "input_json_delta" && (i.content.at(-1).input += n.delta.partial_json);
+            else if (n.type === "content_block_stop") {
+              const a = i.content.at(-1);
+              a.input != null && (a.input = a.input ? b(a.input, {}) : {});
+            } else if (n.type === "message_stop")
               break;
           }
         }
-        const d = o.content.filter((c) => c.type === "tool_use");
+        const d = i.content.filter((n) => n.type === "tool_use");
         if (d.length && !t.signal.aborted) {
-          r.push({ role: "assistant", content: o.content });
-          const c = await Promise.all(d.map(async (m) => {
-            const p = n.find(k("name", m.name));
-            if (e.stream && e.stream({ tool: m.name }), !p) return { tool_use_id: m.id, is_error: !0, content: "Tool not found" };
+          r.push({ role: "assistant", content: i.content });
+          const n = await Promise.all(d.map(async (a) => {
+            const p = o.find(x("name", a.name));
+            if (e.stream && e.stream({ tool: a.name }), !p) return { tool_use_id: a.id, is_error: !0, content: "Tool not found" };
             try {
-              const u = await p.fn(m.input, e?.stream, this.ai);
-              return { type: "tool_result", tool_use_id: m.id, content: b(u) };
+              const u = await p.fn(a.input, e?.stream, this.ai);
+              return { type: "tool_result", tool_use_id: a.id, content: w(u) };
             } catch (u) {
-              return { type: "tool_result", tool_use_id: m.id, is_error: !0, content: u?.message || u?.toString() || "Unknown" };
+              return { type: "tool_result", tool_use_id: a.id, is_error: !0, content: u?.message || u?.toString() || "Unknown" };
             }
           }));
-          r.push({ role: "user", content: c }), i.messages = r;
+          r.push({ role: "user", content: n }), m.messages = r;
         }
-      } while (!t.signal.aborted && o.content.some((d) => d.type === "tool_use"));
-      r.push({ role: "assistant", content: o.content.filter((d) => d.type == "text").map((d) => d.text).join(`
+      } while (!t.signal.aborted && i.content.some((d) => d.type === "tool_use"));
+      r.push({ role: "assistant", content: i.content.filter((d) => d.type == "text").map((d) => d.text).join(`
 
 `) }), r = this.toStandard(r), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...r), l(r.at(-1)?.content);
     }), { abort: () => t.abort() });
   }
 }
-class w extends q {
+class k extends $ {
   constructor(s, e, t, l) {
-    super(), this.ai = s, this.host = e, this.token = t, this.model = l, this.client = new U(M({
+    super(), this.ai = s, this.host = e, this.token = t, this.model = l, this.client = new R(E({
       baseURL: e,
       apiKey: t
     }));
@@ -137,7 +137,7 @@ class w extends q {
           role: "tool",
           id: r.id,
           name: r.function.name,
-          args: g(r.function.arguments, {}),
+          args: b(r.function.arguments, {}),
           timestamp: t.timestamp
         }));
         s.splice(e, 1, ...l), e += l.length - 1;
@@ -174,66 +174,66 @@ class w extends q {
     const t = new AbortController();
     return Object.assign(new Promise(async (l, r) => {
       e.system && e.history?.[0]?.role != "system" && e.history?.splice(0, 0, { role: "system", content: e.system, timestamp: Date.now() });
-      let n = this.fromStandard([...e.history || [], { role: "user", content: s, timestamp: Date.now() }]);
-      const i = e.tools || this.ai.options.llm?.tools || [], o = {
+      let o = this.fromStandard([...e.history || [], { role: "user", content: s, timestamp: Date.now() }]);
+      const m = e.tools || this.ai.options.llm?.tools || [], i = {
         model: e.model || this.model,
-        messages: n,
+        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: i.map((c) => ({
+        tools: m.map((n) => ({
           type: "function",
           function: {
-            name: c.name,
-            description: c.description,
+            name: n.name,
+            description: n.description,
             parameters: {
               type: "object",
-              properties: c.args ? _(c.args, (m, p) => ({ ...p, required: void 0 })) : {},
-              required: c.args ? Object.entries(c.args).filter((m) => m[1].required).map((m) => m[0]) : []
+              properties: n.args ? _(n.args, (a, p) => ({ ...p, required: void 0 })) : {},
+              required: n.args ? Object.entries(n.args).filter((a) => a[1].required).map((a) => a[0]) : []
             }
           }
         }))
       };
-      let a, d = !0;
+      let c, d = !0;
       do {
-        if (a = await this.client.chat.completions.create(o).catch((m) => {
-          throw m.message += `
+        if (c = await this.client.chat.completions.create(i).catch((a) => {
+          throw a.message += `
 
 Messages:
-${JSON.stringify(n, null, 2)}`, m;
+${JSON.stringify(o, null, 2)}`, a;
         }), e.stream) {
           d ? d = !1 : e.stream({ text: `
 
-` }), a.choices = [{ message: { content: "", tool_calls: [] } }];
-          for await (const m of a) {
+` }), c.choices = [{ message: { content: "", tool_calls: [] } }];
+          for await (const a of c) {
             if (t.signal.aborted) break;
-            m.choices[0].delta.content && (a.choices[0].message.content += m.choices[0].delta.content, e.stream({ text: m.choices[0].delta.content })), m.choices[0].delta.tool_calls && (a.choices[0].message.tool_calls = m.choices[0].delta.tool_calls);
+            a.choices[0].delta.content && (c.choices[0].message.content += a.choices[0].delta.content, e.stream({ text: a.choices[0].delta.content })), a.choices[0].delta.tool_calls && (c.choices[0].message.tool_calls = a.choices[0].delta.tool_calls);
           }
         }
-        const c = a.choices[0].message.tool_calls || [];
-        if (c.length && !t.signal.aborted) {
-          n.push(a.choices[0].message);
-          const m = await Promise.all(c.map(async (p) => {
-            const u = i?.find(k("name", p.function.name));
+        const n = c.choices[0].message.tool_calls || [];
+        if (n.length && !t.signal.aborted) {
+          o.push(c.choices[0].message);
+          const a = await Promise.all(n.map(async (p) => {
+            const u = m?.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 = g(p.function.arguments, {}), y = await u.fn(f, e.stream, this.ai);
-              return { role: "tool", tool_call_id: p.id, content: b(y) };
+              const f = b(p.function.arguments, {}), y = await u.fn(f, e.stream, this.ai);
+              return { role: "tool", tool_call_id: p.id, content: w(y) };
             } catch (f) {
-              return { role: "tool", tool_call_id: p.id, content: b({ error: f?.message || f?.toString() || "Unknown" }) };
+              return { role: "tool", tool_call_id: p.id, content: w({ error: f?.message || f?.toString() || "Unknown" }) };
             }
           }));
-          n.push(...m), o.messages = n;
+          o.push(...a), i.messages = o;
         }
-      } while (!t.signal.aborted && a.choices?.[0]?.message?.tool_calls?.length);
-      n.push({ role: "assistant", content: a.choices[0].message.content || "" }), 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);
+      } while (!t.signal.aborted && c.choices?.[0]?.message?.tool_calls?.length);
+      o.push({ role: "assistant", content: c.choices[0].message.content || "" }), o = this.toStandard(o), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...o), l(o.at(-1)?.content);
     }), { abort: () => t.abort() });
   }
 }
-class z {
+class I {
   constructor(s) {
     this.ai = s, s.options.llm?.models && Object.entries(s.options.llm.models).forEach(([e, t]) => {
-      this.defaultModel || (this.defaultModel = e), t.proto == "anthropic" ? this.models[e] = new W(this.ai, t.token, e) : t.proto == "ollama" ? this.models[e] = new w(this.ai, t.host, "not-needed", e) : t.proto == "openai" && (this.models[e] = new w(this.ai, t.host || null, t.token, e));
+      this.defaultModel || (this.defaultModel = e), t.proto == "anthropic" ? this.models[e] = new z(this.ai, t.token, e) : t.proto == "ollama" ? this.models[e] = new k(this.ai, t.host, "not-needed", e) : t.proto == "openai" && (this.models[e] = new k(this.ai, t.host || null, t.token, e));
     });
   }
   defaultModel;
@@ -254,15 +254,15 @@ class z {
         e.system = (e.system || "") + `
 You have passive persistent memory never make any mention of your memory capabilities and what you can/cannot remember
 `;
-        const i = async (a, d, c = 50) => {
-          const [m, p] = await Promise.all([
+        const m = async (c, d, n = 50) => {
+          const [a, p] = await Promise.all([
             d ? this.embedding(d) : Promise.resolve(null),
-            a ? this.embedding(a) : Promise.resolve(null)
+            c ? this.embedding(c) : Promise.resolve(null)
           ]);
-          return (e.memory || []).map((u) => ({ ...u, score: m ? this.cosineSimilarity(u.embeddings[0], m[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, c);
-        }, o = await i(s);
-        o.length && e.history.push({ role: "assistant", content: `Things I remembered:
-` + o.map((a) => `${a.owner}: ${a.fact}`).join(`
+          return (e.memory || []).map((u) => ({ ...u, score: a ? this.cosineSimilarity(u.embeddings[0], a[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, n);
+        }, i = await m(s);
+        i.length && e.history.push({ role: "assistant", content: `Things I remembered:
+` + i.map((c) => `${c.owner}: ${c.fact}`).join(`
 `) }), e.tools = [...e.tools || [], {
           name: "read_memory",
           description: "Check your long-term memory for more information",
@@ -271,31 +271,31 @@ 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 i(a.query, a.subject, a.limit || 5);
+          fn: (c) => {
+            if (!c.subject && !c.query) throw new Error("Either a subject or query argument is required");
+            return m(c.query, c.subject, c.limit || 5);
           }
         }];
       }
-      const n = await this.models[t].ask(s, e);
+      const o = await this.models[t].ask(s, e);
       if (e.memory) {
-        const i = e.history?.findIndex((o) => o.role == "assistant" && o.content.startsWith("Things I remembered:"));
-        i != null && i >= 0 && e.history?.splice(i, 1);
+        const m = e.history?.findIndex((i) => i.role == "assistant" && i.content.startsWith("Things I remembered:"));
+        m != null && m >= 0 && e.history?.splice(m, 1);
       }
       if (e.compress || e.memory) {
-        let i = null;
+        let m = null;
         if (e.compress)
-          i = await this.ai.language.compressHistory(e.history, e.compress.max, e.compress.min, e), e.history.splice(0, e.history.length, ...i.history);
+          m = await this.ai.language.compressHistory(e.history, e.compress.max, e.compress.min, e), e.history.splice(0, e.history.length, ...m.history);
         else {
-          const o = e.history?.findLastIndex((a) => a.role == "user") ?? -1;
-          i = await this.ai.language.compressHistory(o != -1 ? e.history.slice(o) : e.history, 0, 0, e);
+          const i = e.history?.findLastIndex((c) => c.role == "user") ?? -1;
+          m = await this.ai.language.compressHistory(i != -1 ? e.history.slice(i) : e.history, 0, 0, e);
         }
         if (e.memory) {
-          const o = e.memory.filter((a) => !i.memory.some((d) => this.cosineSimilarity(a.embeddings[1], d.embeddings[1]) > 0.8)).concat(i.memory);
-          e.memory.splice(0, e.memory.length, ...o);
+          const i = e.memory.filter((c) => !m.memory.some((d) => this.cosineSimilarity(c.embeddings[1], d.embeddings[1]) > 0.8)).concat(m.memory);
+          e.memory.splice(0, e.memory.length, ...i);
         }
       }
-      return r(n);
+      return r(o);
     }), { abort: l });
   }
   /**
@@ -308,22 +308,22 @@ You have passive persistent memory never make any mention of your memory capabil
    */
   async compressHistory(s, e, t, l) {
     if (this.estimateTokens(s) < e) return { history: s, memory: [] };
-    let r = 0, n = 0;
+    let r = 0, o = 0;
     for (let u of s.toReversed())
-      if (n += this.estimateTokens(u.content), n < t) r++;
+      if (o += this.estimateTokens(u.content), o < t) r++;
       else break;
     if (s.length <= r) return { history: s, memory: [] };
-    const i = s[0].role == "system" ? s[0] : null, o = r == 0 ? [] : s.slice(-r), a = (r == 0 ? s : s.slice(0, -r)).filter((u) => u.role === "assistant" || u.role === "user"), d = await this.json(a.map((u) => `${u.role}: ${u.content}`).join(`
+    const m = s[0].role == "system" ? s[0] : null, i = r == 0 ? [] : s.slice(-r), c = (r == 0 ? s : s.slice(0, -r)).filter((u) => u.role === "assistant" || u.role === "user"), d = await this.json(c.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
-    }), c = /* @__PURE__ */ new Date(), m = await Promise.all((d?.facts || [])?.map(async ([u, f]) => {
+    }), n = /* @__PURE__ */ new Date(), a = await Promise.all((d?.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: c };
-    })), p = [{ role: "assistant", content: `Conversation Summary: ${d?.summary}`, timestamp: Date.now() }, ...o];
-    return i && p.splice(0, 0, i), { history: p, memory: m };
+      return { owner: u, fact: f, embeddings: [y[0][0].embedding, y[1][0].embedding], timestamp: n };
+    })), p = [{ role: "assistant", content: `Conversation Summary: ${d?.summary}`, timestamp: Date.now() }, ...i];
+    return m && p.splice(0, 0, m), { history: p, memory: a };
   }
   /**
    * Compare the difference between embeddings (calculates the angle between two vectors)
@@ -334,10 +334,10 @@ You have passive persistent memory never make any mention of your memory capabil
   cosineSimilarity(s, e) {
     if (s.length !== e.length) throw new Error("Vectors must be same length");
     let t = 0, l = 0, r = 0;
-    for (let i = 0; i < s.length; i++)
-      t += s[i] * e[i], l += s[i] * s[i], r += e[i] * e[i];
-    const n = Math.sqrt(l) * Math.sqrt(r);
-    return n === 0 ? 0 : t / n;
+    for (let m = 0; m < s.length; m++)
+      t += s[m] * e[m], l += s[m] * s[m], r += e[m] * e[m];
+    const o = Math.sqrt(l) * Math.sqrt(r);
+    return o === 0 ? 0 : t / o;
   }
   /**
    * Chunk text into parts for AI digestion
@@ -347,50 +347,52 @@ You have passive persistent memory never make any mention of your memory capabil
    * @returns {string[]} Chunked strings
    */
   chunk(s, e = 500, t = 50) {
-    const l = (o, a = "") => o ? Object.entries(o).flatMap(([d, c]) => {
-      const m = a ? `${a}${isNaN(+d) ? `.${d}` : `[${d}]`}` : d;
-      return typeof c == "object" && !Array.isArray(c) ? l(c, m) : `${m}: ${Array.isArray(c) ? c.join(", ") : c}`;
-    }) : [], n = (typeof s == "object" ? l(s) : s.split(`
-`)).flatMap((o) => [...o.split(/\s+/).filter(Boolean), `
-`]), i = [];
-    for (let o = 0; o < n.length; ) {
-      let a = "", d = o;
-      for (; d < n.length; ) {
-        const m = a + (a ? " " : "") + n[d];
-        if (this.estimateTokens(m.replace(/\s*\n\s*/g, `
-`)) > e && a) break;
-        a = m, d++;
+    const l = (i, c = "") => i ? Object.entries(i).flatMap(([d, n]) => {
+      const a = c ? `${c}${isNaN(+d) ? `.${d}` : `[${d}]`}` : d;
+      return typeof n == "object" && !Array.isArray(n) ? l(n, a) : `${a}: ${Array.isArray(n) ? n.join(", ") : n}`;
+    }) : [], o = (typeof s == "object" ? l(s) : s.split(`
+`)).flatMap((i) => [...i.split(/\s+/).filter(Boolean), `
+`]), m = [];
+    for (let i = 0; i < o.length; ) {
+      let c = "", d = i;
+      for (; d < o.length; ) {
+        const a = c + (c ? " " : "") + o[d];
+        if (this.estimateTokens(a.replace(/\s*\n\s*/g, `
+`)) > e && c) break;
+        c = a, d++;
       }
-      const c = a.replace(/\s*\n\s*/g, `
+      const n = c.replace(/\s*\n\s*/g, `
 `).trim();
-      c && i.push(c), o = Math.max(d - t, d === o ? o + 1 : d);
+      n && m.push(n), i = Math.max(d - t, d === i ? i + 1 : d);
     }
-    return i;
+    return m;
   }
   /**
    * 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)
+   * @param {maxTokens?: number, overlapTokens?: number, parellel?: number} opts Options for embedding such as chunk sizes and parallel processing
    * @returns {Promise<Awaited<{index: number, embedding: number[], text: string, tokens: number}>[]>} Chunked embeddings
    */
-  embedding(s, e = 500, t = 50) {
-    const l = (n) => new Promise((i, o) => {
-      const a = new x(S(T(j(import.meta.url)), "embedder.js")), d = ({ embedding: m }) => {
-        a.terminate(), i(m);
-      }, c = (m) => {
-        a.terminate(), o(m);
+  async embedding(s, e = {}) {
+    let { maxTokens: t = 500, overlapTokens: l = 50, parallel: r = 1 } = e;
+    const o = (n) => new Promise((a, p) => {
+      const u = new j(T(q(S(import.meta.url)), "embedder.js")), f = ({ embedding: g }) => {
+        u.terminate(), a(g);
+      }, y = (g) => {
+        u.terminate(), p(g);
       };
-      a.on("message", d), a.on("error", c), a.on("exit", (m) => {
-        m !== 0 && o(new Error(`Worker exited with code ${m}`));
-      }), a.postMessage({ text: n, model: this.ai.options?.embedder || "bge-small-en-v1.5", modelDir: this.ai.options.path });
-    }), r = this.chunk(s, e, t);
-    return Promise.all(r.map(async (n, i) => ({
-      index: i,
-      embedding: await l(n),
-      text: n,
-      tokens: this.estimateTokens(n)
-    })));
+      u.on("message", f), u.on("error", y), u.on("exit", (g) => {
+        g !== 0 && p(new Error(`Worker exited with code ${g}`));
+      }), u.postMessage({ text: n, model: this.ai.options?.embedder || "bge-small-en-v1.5", modelDir: this.ai.options.path });
+    });
+    let m = 0, i = this.chunk(s, t, l), c = [];
+    const d = () => {
+      const n = m++;
+      if (n >= i.length) return;
+      const a = i[n];
+      return o(a).then((p) => (c.push({ index: n, embedding: p, text: a, tokens: this.estimateTokens(a) }), d()));
+    };
+    return await Promise.all(Array(r).fill(null).map(() => d())), c.toSorted((n, a) => n.index - a.index);
   }
   /**
    * Estimate variable as tokens
@@ -409,8 +411,8 @@ You have passive persistent memory never make any mention of your memory capabil
    */
   fuzzyMatch(s, ...e) {
     if (e.length < 2) throw new Error("Requires at least 2 strings to compare");
-    const t = (n, i = 10) => n.toLowerCase().split("").map((o, a) => o.charCodeAt(0) * (a + 1) % i / i).slice(0, i), l = t(s), r = e.map((n) => t(n)).map((n) => this.cosineSimilarity(l, n));
-    return { avg: r.reduce((n, i) => n + i, 0) / r.length, max: Math.max(...r), similarities: r };
+    const t = (o, m = 10) => o.toLowerCase().split("").map((i, c) => i.charCodeAt(0) * (c + 1) % m / m).slice(0, m), l = t(s), r = e.map((o) => t(o)).map((o) => this.cosineSimilarity(l, o));
+    return { avg: r.reduce((o, m) => o + m, 0) / r.length, max: Math.max(...r), similarities: r };
   }
   /**
    * Ask a question with JSON response
@@ -426,8 +428,8 @@ You have passive persistent memory never make any mention of your memory capabil
 ${e}
 \`\`\`` });
     if (!l) return {};
-    const r = /```(?:.+)?\s*([\s\S]*?)```/.exec(l), n = r ? r[1].trim() : l;
-    return g(n, {});
+    const r = /```(?:.+)?\s*([\s\S]*?)```/.exec(l), o = r ? r[1].trim() : l;
+    return b(o, {});
   }
   /**
    * Create a summary of some text
@@ -440,44 +442,47 @@ ${e}
     return this.ask(s, { system: `Generate a brief summary <= ${e} tokens. Output nothing else`, temperature: 0.3, ...t });
   }
 }
-class I {
+class J {
   constructor(s) {
     this.ai = s;
   }
   asr(s, e = {}) {
     const { model: t = this.ai.options.asr || "whisper-base", speaker: l = !1 } = e;
     let r = !1;
-    const n = () => {
+    const o = () => {
       r = !0;
     };
-    let i = new Promise((o, a) => {
-      const d = new x(S(T(j(import.meta.url)), "asr.js")), c = ({ text: p, warning: u, error: f }) => {
-        d.terminate(), !r && (f ? a(new Error(f)) : (u && console.warn(u), o(p)));
-      }, m = (p) => {
-        d.terminate(), r || a(p);
+    let m = new Promise((i, c) => {
+      const d = new j(T(q(S(import.meta.url)), "asr.js")), n = ({ text: p, warning: u, error: f }) => {
+        d.terminate(), !r && (f ? c(new Error(f)) : (u && console.warn(u), i(p)));
+      }, a = (p) => {
+        d.terminate(), r || c(p);
       };
-      d.on("message", c), d.on("error", m), d.on("exit", (p) => {
-        p !== 0 && !r && a(new Error(`Worker exited with code ${p}`));
+      d.on("message", n), d.on("error", a), d.on("exit", (p) => {
+        p !== 0 && !r && c(new Error(`Worker exited with code ${p}`));
       }), d.postMessage({ file: s, model: t, speaker: l, modelDir: this.ai.options.path, token: this.ai.options.hfToken });
     });
     if (e.speaker == "id") {
       if (!this.ai.language.defaultModel) throw new Error("Configure an LLM for advanced ASR speaker detection");
-      i = i.then(async (o) => {
-        if (!o) return o;
-        const a = await this.ai.language.json(o, '{1: "Detected Name"}', {
+      m = m.then(async (i) => {
+        if (!i) return i;
+        let c = this.ai.language.chunk(i, 500, 0);
+        c.length > 4 && (c = [...c.slice(0, 3), c.at(-1)]);
+        const d = await this.ai.language.json(c.join(`
+`), '{1: "Detected Name"}', {
           system: "Use this following transcript to identify speakers. Only identify speakers you are sure about",
-          temperature: 0.2
+          temperature: 0.1
         });
-        return Object.entries(a).forEach(([d, c]) => {
-          o = o.replaceAll(`[Speaker ${d}]`, `[${c}]`);
-        }), o;
+        return Object.entries(d).forEach(([n, a]) => {
+          i = i.replaceAll(`[Speaker ${n}]`, `[${a}]`);
+        }), i;
       });
     }
-    return Object.assign(i, { abort: n });
+    return Object.assign(m, { abort: o });
   }
-  canDiarization = R;
+  canDiarization = L;
 }
-class J {
+class H {
   constructor(s) {
     this.ai = s;
   }
@@ -489,16 +494,16 @@ class J {
   ocr(s) {
     let e;
     const t = new Promise(async (l) => {
-      e = await L(this.ai.options.ocr || "eng", 2, { cachePath: this.ai.options.path });
+      e = await D(this.ai.options.ocr || "eng", 2, { cachePath: this.ai.options.path });
       const { data: r } = await e.recognize(s);
       await e.terminate(), l(r.text.trim() || null);
     });
     return Object.assign(t, { abort: () => e?.terminate() });
   }
 }
-class re {
+class ne {
   constructor(s) {
-    this.options = s, s.path || (s.path = $.tmpdir()), process.env.TRANSFORMERS_CACHE = s.path, this.audio = new I(this), this.language = new z(this), this.vision = new J(this);
+    this.options = s, s.path || (s.path = M.tmpdir()), process.env.TRANSFORMERS_CACHE = s.path, this.audio = new J(this), this.language = new I(this), this.vision = new H(this);
   }
   /** Audio processing AI */
   audio;
@@ -507,17 +512,17 @@ class re {
   /** Vision processing AI */
   vision;
 }
-const H = {
+const F = {
   name: "cli",
   description: "Use the command line interface, returns any output",
   args: { command: { type: "string", description: "Command to run", required: !0 } },
-  fn: (h) => N`${h.command}`
-}, ne = {
+  fn: (h) => C`${h.command}`
+}, oe = {
   name: "get_datetime",
   description: "Get current UTC date / time",
   args: {},
   fn: async () => (/* @__PURE__ */ new Date()).toUTCString()
-}, oe = {
+}, ie = {
   name: "exec",
   description: "Run code/scripts",
   args: {
@@ -528,17 +533,17 @@ const H = {
     try {
       switch (h.type) {
         case "bash":
-          return await H.fn({ command: h.code }, s, e);
+          return await F.fn({ command: h.code }, s, e);
         case "node":
-          return await F.fn({ code: h.code }, s, e);
-        case "python":
           return await G.fn({ code: h.code }, s, e);
+        case "python":
+          return await B.fn({ code: h.code }, s, e);
       }
     } catch (t) {
       return { error: t?.message || t.toString() };
     }
   }
-}, ie = {
+}, ae = {
   name: "fetch",
   description: "Make HTTP request to URL",
   args: {
@@ -547,25 +552,25 @@ const H = {
     headers: { type: "object", description: "HTTP headers to send", default: {} },
     body: { type: "object", description: "HTTP body to send" }
   },
-  fn: (h) => new E({ url: h.url, headers: h.headers }).request({ method: h.method || "GET", body: h.body })
-}, F = {
+  fn: (h) => new P({ 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 (h) => {
-    const s = P(null), e = await A({ console: s }, h.code, !0).catch((t) => s.output.error.push(t));
+    const s = A(null), e = await O({ console: s }, h.code, !0).catch((t) => s.output.error.push(t));
     return { ...s.output, return: e, stdout: void 0, stderr: void 0 };
   }
-}, G = {
+}, B = {
   name: "exec_javascript",
   description: "Execute commonjs javascript",
   args: {
     code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
-  fn: async (h) => ({ result: C`python -c "${h.code}"` })
-}, ae = {
+  fn: async (h) => ({ result: W`python -c "${h.code}"` })
+}, ce = {
   name: "read_webpage",
   description: "Extract clean, structured content from a webpage. Use after web_search to read specific URLs",
   args: {
@@ -573,9 +578,9 @@ const H = {
     focus: { type: "string", description: 'Optional: What aspect to focus on (e.g., "pricing", "features", "contact info")' }
   },
   fn: async (h) => {
-    const s = await fetch(h.url, { headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" } }).then((n) => n.text()).catch((n) => {
-      throw new Error(`Failed to fetch: ${n.message}`);
-    }), e = D.load(s);
+    const s = await fetch(h.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(s);
     e('script, style, nav, footer, header, aside, iframe, noscript, [role="navigation"], [role="banner"], .ad, .ads, .cookie, .popup').remove();
     const t = {
       title: e('meta[property="og:title"]').attr("content") || e("title").text() || "",
@@ -583,16 +588,16 @@ const H = {
     };
     let l = "";
     const r = ["article", "main", '[role="main"]', ".content", ".post", ".entry", "body"];
-    for (const n of r) {
-      const i = e(n).first();
-      if (i.length && i.text().trim().length > 200) {
-        l = i.text();
+    for (const o of r) {
+      const m = e(o).first();
+      if (m.length && m.text().trim().length > 200) {
+        l = m.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 };
   }
-}, ce = {
+}, le = {
   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: {
@@ -604,7 +609,7 @@ const H = {
       headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)", "Accept-Language": "en-US,en;q=0.9" }
     }).then((r) => r.text());
     let e, t = /<a .*?href="(.+?)".+?<\/a>/g;
-    const l = new O();
+    const l = new v();
     for (; (e = t.exec(s)) !== null; ) {
       let r = /uddg=(.+)&amp?/.exec(decodeURIComponent(e[1]))?.[1];
       if (r && (r = decodeURIComponent(r)), r && l.add(r), l.size >= (h.length || 5)) break;
@@ -613,20 +618,20 @@ const H = {
   }
 };
 export {
-  re as Ai,
-  W as Anthropic,
-  I as Audio,
-  H as CliTool,
-  ne as DateTimeTool,
-  oe as ExecTool,
-  ie as FetchTool,
-  F as JSTool,
-  q as LLMProvider,
-  w as OpenAi,
-  G as PythonTool,
-  ae as ReadWebpageTool,
-  J as Vision,
-  ce as WebSearchTool,
-  R as canDiarization
+  ne as Ai,
+  z as Anthropic,
+  J as Audio,
+  F as CliTool,
+  oe as DateTimeTool,
+  ie as ExecTool,
+  ae as FetchTool,
+  G as JSTool,
+  $ as LLMProvider,
+  k as OpenAi,
+  B as PythonTool,
+  ce as ReadWebpageTool,
+  H as Vision,
+  le as WebSearchTool,
+  L as canDiarization
 };
 //# sourceMappingURL=index.mjs.map