@ztimson/ai-utils 0.6.10 → 0.7.1

package/dist/index.mjs

@@ -1,6 +1,6 @@
-import * as M from "node:os";
-import { objectMap as _, JSONAttemptParse as g, findByProp as k, JSONSanitize as b, clean as P, Http as $, consoleInterceptor as E, fn as A, ASet as v } from "@ztimson/utils";
-import { Anthropic as O } from "@anthropic-ai/sdk";
+import * as $ from "node:os";
+import { objectMap as k, JSONAttemptParse as g, findByProp as _, 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";
@@ -13,48 +13,48 @@ import { $ as N, $Sync as C } from "@ztimson/node-utils";
 class q {
 }
 class W extends q {
-  constructor(r, e, t) {
-    super(), this.ai = r, this.apiToken = e, this.model = t, this.client = new O({ apiKey: e });
+  constructor(s, e, t) {
+    super(), this.ai = s, this.apiToken = e, this.model = t, this.client = new v({ apiKey: e });
   }
   client;
-  toStandard(r) {
+  toStandard(s) {
     const e = Date.now(), t = [];
-    for (let o of r)
-      if (typeof o.content == "string")
-        t.push({ timestamp: e, ...o });
+    for (let m of s)
+      if (typeof m.content == "string")
+        t.push({ timestamp: e, ...m });
       else {
-        const s = o.content?.filter((n) => n.type == "text").map((n) => n.text).join(`
+        const r = m.content?.filter((n) => n.type == "text").map((n) => n.text).join(`
 
 `);
-        s && t.push({ timestamp: e, role: o.role, content: s }), o.content.forEach((n) => {
+        r && t.push({ timestamp: e, role: m.role, content: r }), m.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((m) => m.id == n.tool_use_id);
-            i && (i[n.is_error ? "error" : "content"] = n.content);
+            const a = t.findLast((i) => i.id == n.tool_use_id);
+            a && (a[n.is_error ? "error" : "content"] = n.content);
           }
         });
       }
     return t;
   }
-  fromStandard(r) {
-    for (let e = 0; e < r.length; e++)
-      if (r[e].role == "tool") {
-        const t = r[e];
-        r.splice(
+  fromStandard(s) {
+    for (let e = 0; e < s.length; e++)
+      if (s[e].role == "tool") {
+        const t = s[e];
+        s.splice(
           e,
           1,
           { role: "assistant", content: [{ type: "tool_use", id: t.id, name: t.name, input: t.args }] },
           { role: "user", content: [{ type: "tool_result", tool_use_id: t.id, is_error: !!t.error, content: t.error || t.content }] }
         ), e++;
       }
-    return r.map(({ timestamp: e, ...t }) => t);
+    return s.map(({ timestamp: e, ...t }) => t);
   }
-  ask(r, e = {}) {
+  ask(s, e = {}) {
     const t = new AbortController();
-    return Object.assign(new Promise(async (o) => {
-      let s = this.fromStandard([...e.history || [], { role: "user", content: r, timestamp: Date.now() }]);
-      const n = e.tools || this.ai.options.llm?.tools || [], i = {
+    return Object.assign(new Promise(async (m) => {
+      let r = this.fromStandard([...e.history || [], { role: "user", content: s, timestamp: Date.now() }]);
+      const n = e.tools || this.ai.options.llm?.tools || [], a = {
         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 || "",
@@ -64,46 +64,46 @@ class W extends q {
           description: d.description,
           input_schema: {
             type: "object",
-            properties: d.args ? _(d.args, (c, l) => ({ ...l, required: void 0 })) : {},
+            properties: d.args ? k(d.args, (c, l) => ({ ...l, required: void 0 })) : {},
             required: d.args ? Object.entries(d.args).filter((c) => c[1].required).map((c) => c[0]) : []
           },
           fn: void 0
         })),
-        messages: s,
+        messages: r,
         stream: !!e.stream
       };
-      let m, a = !0;
+      let i, o = !0;
       do {
-        if (m = await this.client.messages.create(i).catch((c) => {
+        if (i = await this.client.messages.create(a).catch((c) => {
           throw c.message += `
 
 Messages:
-${JSON.stringify(s, null, 2)}`, c;
+${JSON.stringify(r, null, 2)}`, c;
         }), e.stream) {
-          a ? a = !1 : e.stream({ text: `
+          o ? o = !1 : e.stream({ text: `
 
-` }), m.content = [];
-          for await (const c of m) {
+` }), i.content = [];
+          for await (const c of i) {
             if (t.signal.aborted) break;
             if (c.type === "content_block_start")
-              c.content_block.type === "text" ? m.content.push({ type: "text", text: "" }) : c.content_block.type === "tool_use" && m.content.push({ type: "tool_use", id: c.content_block.id, name: c.content_block.name, input: "" });
+              c.content_block.type === "text" ? i.content.push({ type: "text", text: "" }) : c.content_block.type === "tool_use" && i.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 l = c.delta.text;
-                m.content.at(-1).text += l, e.stream({ text: l });
-              } else c.delta.type === "input_json_delta" && (m.content.at(-1).input += c.delta.partial_json);
+                i.content.at(-1).text += l, e.stream({ text: l });
+              } else c.delta.type === "input_json_delta" && (i.content.at(-1).input += c.delta.partial_json);
             else if (c.type === "content_block_stop") {
-              const l = m.content.at(-1);
+              const l = i.content.at(-1);
               l.input != null && (l.input = l.input ? g(l.input, {}) : {});
             } else if (c.type === "message_stop")
               break;
           }
         }
-        const d = m.content.filter((c) => c.type === "tool_use");
+        const d = i.content.filter((c) => c.type === "tool_use");
         if (d.length && !t.signal.aborted) {
-          s.push({ role: "assistant", content: m.content });
+          r.push({ role: "assistant", content: i.content });
           const c = await Promise.all(d.map(async (l) => {
-            const p = n.find(k("name", l.name));
+            const p = n.find(_("name", l.name));
             if (e.stream && e.stream({ tool: l.name }), !p) return { tool_use_id: l.id, is_error: !0, content: "Tool not found" };
             try {
               const u = await p.fn(l.input, e?.stream, this.ai);
@@ -112,45 +112,45 @@ ${JSON.stringify(s, null, 2)}`, c;
               return { type: "tool_result", tool_use_id: l.id, is_error: !0, content: u?.message || u?.toString() || "Unknown" };
             }
           }));
-          s.push({ role: "user", content: c }), i.messages = s;
+          r.push({ role: "user", content: c }), a.messages = r;
         }
-      } while (!t.signal.aborted && m.content.some((d) => d.type === "tool_use"));
-      s.push({ role: "assistant", content: m.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(`
 
-`) }), s = this.toStandard(s), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...s), o(s.at(-1)?.content);
+`) }), r = this.toStandard(r), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...r), m(r.at(-1)?.content);
     }), { abort: () => t.abort() });
   }
 }
 class w extends q {
-  constructor(r, e, t, o) {
-    super(), this.ai = r, this.host = e, this.token = t, this.model = o, this.client = new U(P({
+  constructor(s, e, t, m) {
+    super(), this.ai = s, this.host = e, this.token = t, this.model = m, this.client = new U(M({
       baseURL: e,
       apiKey: t
     }));
   }
   client;
-  toStandard(r) {
-    for (let e = 0; e < r.length; e++) {
-      const t = r[e];
+  toStandard(s) {
+    for (let e = 0; e < s.length; e++) {
+      const t = s[e];
       if (t.role === "assistant" && t.tool_calls) {
-        const o = t.tool_calls.map((s) => ({
+        const m = t.tool_calls.map((r) => ({
           role: "tool",
-          id: s.id,
-          name: s.function.name,
-          args: g(s.function.arguments, {}),
+          id: r.id,
+          name: r.function.name,
+          args: g(r.function.arguments, {}),
           timestamp: t.timestamp
         }));
-        r.splice(e, 1, ...o), e += o.length - 1;
+        s.splice(e, 1, ...m), e += m.length - 1;
       } else if (t.role === "tool" && t.content) {
-        const o = r.find((s) => t.tool_call_id == s.id);
-        o && (t.content.includes('"error":') ? o.error = t.content : o.content = t.content), r.splice(e, 1), e--;
+        const m = s.find((r) => t.tool_call_id == r.id);
+        m && (t.content.includes('"error":') ? m.error = t.content : m.content = t.content), s.splice(e, 1), e--;
       }
-      r[e]?.timestamp || (r[e].timestamp = Date.now());
+      s[e]?.timestamp || (s[e].timestamp = Date.now());
     }
-    return r;
+    return s;
   }
-  fromStandard(r) {
-    return r.reduce((e, t) => {
+  fromStandard(s) {
+    return s.reduce((e, t) => {
       if (t.role === "tool")
         e.push({
           role: "assistant",
@@ -164,39 +164,39 @@ class w extends q {
           content: t.error || t.content
         });
       else {
-        const { timestamp: o, ...s } = t;
-        e.push(s);
+        const { timestamp: m, ...r } = t;
+        e.push(r);
       }
       return e;
     }, []);
   }
-  ask(r, e = {}) {
+  ask(s, e = {}) {
     const t = new AbortController();
-    return Object.assign(new Promise(async (o, s) => {
+    return Object.assign(new Promise(async (m, 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: r, timestamp: Date.now() }]);
-      const i = e.tools || this.ai.options.llm?.tools || [], m = {
+      let n = this.fromStandard([...e.history || [], { role: "user", content: s, timestamp: Date.now() }]);
+      const a = e.tools || this.ai.options.llm?.tools || [], i = {
         model: e.model || this.model,
         messages: n,
         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: a.map((c) => ({
           type: "function",
           function: {
             name: c.name,
             description: c.description,
             parameters: {
               type: "object",
-              properties: c.args ? _(c.args, (l, p) => ({ ...p, required: void 0 })) : {},
+              properties: c.args ? k(c.args, (l, p) => ({ ...p, required: void 0 })) : {},
               required: c.args ? Object.entries(c.args).filter((l) => l[1].required).map((l) => l[0]) : []
             }
           }
         }))
       };
-      let a, d = !0;
+      let o, d = !0;
       do {
-        if (a = await this.client.chat.completions.create(m).catch((l) => {
+        if (o = await this.client.chat.completions.create(i).catch((l) => {
           throw l.message += `
 
 Messages:
@@ -204,17 +204,17 @@ ${JSON.stringify(n, null, 2)}`, l;
         }), e.stream) {
           d ? d = !1 : e.stream({ text: `
 
-` }), a.choices = [{ message: { content: "", tool_calls: [] } }];
-          for await (const l of a) {
+` }), o.choices = [{ message: { content: "", tool_calls: [] } }];
+          for await (const l of o) {
             if (t.signal.aborted) break;
-            l.choices[0].delta.content && (a.choices[0].message.content += l.choices[0].delta.content, e.stream({ text: l.choices[0].delta.content })), l.choices[0].delta.tool_calls && (a.choices[0].message.tool_calls = l.choices[0].delta.tool_calls);
+            l.choices[0].delta.content && (o.choices[0].message.content += l.choices[0].delta.content, e.stream({ text: l.choices[0].delta.content })), l.choices[0].delta.tool_calls && (o.choices[0].message.tool_calls = l.choices[0].delta.tool_calls);
           }
         }
-        const c = a.choices[0].message.tool_calls || [];
+        const c = o.choices[0].message.tool_calls || [];
         if (c.length && !t.signal.aborted) {
-          n.push(a.choices[0].message);
+          n.push(o.choices[0].message);
           const l = await Promise.all(c.map(async (p) => {
-            const u = i?.find(k("name", p.function.name));
+            const u = a?.find(_("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);
@@ -223,46 +223,46 @@ ${JSON.stringify(n, null, 2)}`, l;
               return { role: "tool", tool_call_id: p.id, content: b({ error: f?.message || f?.toString() || "Unknown" }) };
             }
           }));
-          n.push(...l), m.messages = n;
+          n.push(...l), i.messages = n;
         }
-      } 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), o(n.at(-1)?.content);
+      } while (!t.signal.aborted && o.choices?.[0]?.message?.tool_calls?.length);
+      n.push({ role: "assistant", content: o.choices[0].message.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 z {
-  constructor(r) {
-    this.ai = r, r.options.llm?.models && Object.entries(r.options.llm.models).forEach(([e, t]) => {
+  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));
     });
   }
-  models = {};
   defaultModel;
+  models = {};
   /**
    * Chat with LLM
    * @param {string} message Question
    * @param {LLMRequest} options Configuration options and chat history
    * @returns {{abort: () => void, response: Promise<string>}} Function to abort response and chat history
    */
-  ask(r, e = {}) {
+  ask(s, e = {}) {
     const t = e.model || this.defaultModel;
     if (!this.models[t]) throw new Error(`Model does not exist: ${t}`);
-    let o = () => {
+    let m = () => {
     };
-    return Object.assign(new Promise(async (s) => {
+    return Object.assign(new Promise(async (r) => {
       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 i = async (a, d, c = 50) => {
+        const a = async (o, d, c = 50) => {
           const [l, p] = await Promise.all([
             d ? this.embedding(d) : Promise.resolve(null),
-            a ? this.embedding(a) : Promise.resolve(null)
+            o ? this.embedding(o) : Promise.resolve(null)
           ]);
           return (e.memory || []).map((u) => ({ ...u, score: l ? this.cosineSimilarity(u.embeddings[0], l[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);
-        }, m = await i(r);
-        m.length && e.history.push({ role: "assistant", content: `Things I remembered:
-` + m.map((a) => `${a.owner}: ${a.fact}`).join(`
+        }, i = await a(s);
+        i.length && e.history.push({ role: "assistant", content: `Things I remembered:
+` + i.map((o) => `${o.owner}: ${o.fact}`).join(`
 `) }), e.tools = [...e.tools || [], {
           name: "read_memory",
           description: "Check your long-term memory for more information",
@@ -271,32 +271,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 i(a.query, a.subject, a.limit || 5);
+          fn: (o) => {
+            if (!o.subject && !o.query) throw new Error("Either a subject or query argument is required");
+            return a(o.query, o.subject, o.limit || 5);
           }
         }];
       }
-      const n = await this.models[t].ask(r, e);
+      const n = await this.models[t].ask(s, e);
       if (e.memory) {
-        const i = e.history?.findIndex((m) => m.role == "assistant" && m.content.startsWith("Things I remembered:"));
-        i != null && i >= 0 && e.history?.splice(i, 1);
+        const a = e.history?.findIndex((i) => i.role == "assistant" && i.content.startsWith("Things I remembered:"));
+        a != null && a >= 0 && e.history?.splice(a, 1);
       }
       if (e.compress || e.memory) {
-        let i = null;
+        let a = 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);
+          a = await this.ai.language.compressHistory(e.history, e.compress.max, e.compress.min, e), e.history.splice(0, e.history.length, ...a.history);
         else {
-          const m = e.history?.findLastIndex((a) => a.role == "user") ?? -1;
-          i = await this.ai.language.compressHistory(m != -1 ? e.history.slice(m) : e.history, 0, 0, e);
+          const i = e.history?.findLastIndex((o) => o.role == "user") ?? -1;
+          a = await this.ai.language.compressHistory(i != -1 ? e.history.slice(i) : e.history, 0, 0, e);
         }
         if (e.memory) {
-          const m = 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, ...m);
+          const i = e.memory.filter((o) => !a.memory.some((d) => this.cosineSimilarity(o.embeddings[1], d.embeddings[1]) > 0.8)).concat(a.memory);
+          e.memory.splice(0, e.memory.length, ...i);
         }
       }
-      return s(n);
-    }), { abort: o });
+      return r(n);
+    }), { abort: m });
   }
   /**
    * Compress chat history to reduce context size
@@ -306,22 +306,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, o) {
-    if (this.estimateTokens(r) < e) return { history: r, memory: [] };
-    let s = 0, n = 0;
-    for (let u of r.toReversed())
-      if (n += this.estimateTokens(u.content), n < t) s++;
+  async compressHistory(s, e, t, m) {
+    if (this.estimateTokens(s) < e) return { history: s, memory: [] };
+    let r = 0, n = 0;
+    for (let u of s.toReversed())
+      if (n += this.estimateTokens(u.content), n < t) r++;
       else break;
-    if (r.length <= s) return { history: r, memory: [] };
-    const i = r[0].role == "system" ? r[0] : null, m = s == 0 ? [] : r.slice(-s), a = (s == 0 ? r : r.slice(0, -s)).filter((u) => u.role === "assistant" || u.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 (s.length <= r) return { history: s, memory: [] };
+    const a = s[0].role == "system" ? s[0] : null, i = r == 0 ? [] : s.slice(-r), o = (r == 0 ? s : s.slice(0, -r)).filter((u) => u.role === "assistant" || u.role === "user"), d = await this.json(o.map((u) => `${u.role}: ${u.content}`).join(`
 
-${a.map((u) => `${u.role}: ${u.content}`).join(`
-
-`)}`, { model: o?.model, temperature: o?.temperature || 0.3 }), c = /* @__PURE__ */ new Date(), l = await Promise.all((d?.facts || [])?.map(async ([u, f]) => {
+`), "{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: m?.model,
+      temperature: m?.temperature || 0.3
+    }), c = /* @__PURE__ */ new Date(), l = 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() }, ...m];
-    return i && p.splice(0, 0, i), { history: p, memory: l };
+    })), p = [{ role: "assistant", content: `Conversation Summary: ${d?.summary}`, timestamp: Date.now() }, ...i];
+    return a && p.splice(0, 0, a), { history: p, memory: l };
   }
   /**
    * Compare the difference between embeddings (calculates the angle between two vectors)
@@ -329,12 +331,12 @@ ${a.map((u) => `${u.role}: ${u.content}`).join(`
    * @param {number[]} v2 Second embedding / vector for comparison
    * @returns {number} Similarity values 0-1: 0 = unique, 1 = identical
    */
-  cosineSimilarity(r, e) {
-    if (r.length !== e.length) throw new Error("Vectors must be same length");
-    let t = 0, o = 0, s = 0;
-    for (let i = 0; i < r.length; i++)
-      t += r[i] * e[i], o += r[i] * r[i], s += e[i] * e[i];
-    const n = Math.sqrt(o) * Math.sqrt(s);
+  cosineSimilarity(s, e) {
+    if (s.length !== e.length) throw new Error("Vectors must be same length");
+    let t = 0, m = 0, r = 0;
+    for (let a = 0; a < s.length; a++)
+      t += s[a] * e[a], m += s[a] * s[a], r += e[a] * e[a];
+    const n = Math.sqrt(m) * Math.sqrt(r);
     return n === 0 ? 0 : t / n;
   }
   /**
@@ -344,26 +346,26 @@ ${a.map((u) => `${u.role}: ${u.content}`).join(`
    * @param {number} overlapTokens Includes previous X tokens to provide continuity to AI (In addition to max tokens)
    * @returns {string[]} Chunked strings
    */
-  chunk(r, e = 500, t = 50) {
-    const o = (m, a = "") => m ? Object.entries(m).flatMap(([d, c]) => {
-      const l = a ? `${a}${isNaN(+d) ? `.${d}` : `[${d}]`}` : d;
-      return typeof c == "object" && !Array.isArray(c) ? o(c, l) : `${l}: ${Array.isArray(c) ? c.join(", ") : c}`;
-    }) : [], n = (typeof r == "object" ? o(r) : r.split(`
-`)).flatMap((m) => [...m.split(/\s+/).filter(Boolean), `
-`]), i = [];
-    for (let m = 0; m < n.length; ) {
-      let a = "", d = m;
+  chunk(s, e = 500, t = 50) {
+    const m = (i, o = "") => i ? Object.entries(i).flatMap(([d, c]) => {
+      const l = o ? `${o}${isNaN(+d) ? `.${d}` : `[${d}]`}` : d;
+      return typeof c == "object" && !Array.isArray(c) ? m(c, l) : `${l}: ${Array.isArray(c) ? c.join(", ") : c}`;
+    }) : [], n = (typeof s == "object" ? m(s) : s.split(`
+`)).flatMap((i) => [...i.split(/\s+/).filter(Boolean), `
+`]), a = [];
+    for (let i = 0; i < n.length; ) {
+      let o = "", d = i;
       for (; d < n.length; ) {
-        const l = a + (a ? " " : "") + n[d];
+        const l = o + (o ? " " : "") + n[d];
         if (this.estimateTokens(l.replace(/\s*\n\s*/g, `
-`)) > e && a) break;
-        a = l, d++;
+`)) > e && o) break;
+        o = l, d++;
       }
-      const c = a.replace(/\s*\n\s*/g, `
+      const c = o.replace(/\s*\n\s*/g, `
 `).trim();
-      c && i.push(c), m = Math.max(d - t, d === m ? m + 1 : d);
+      c && a.push(c), i = Math.max(d - t, d === i ? i + 1 : d);
     }
-    return i;
+    return a;
   }
   /**
    * Create a vector representation of a string
@@ -372,20 +374,20 @@ ${a.map((u) => `${u.role}: ${u.content}`).join(`
    * @param {number} overlapTokens Includes previous X tokens to provide continuity to AI (In addition to max tokens)
    * @returns {Promise<Awaited<{index: number, embedding: number[], text: string, tokens: number}>[]>} Chunked embeddings
    */
-  embedding(r, e = 500, t = 50) {
-    const o = (n) => new Promise((i, m) => {
-      const a = new x(S(T(j(import.meta.url)), "embedder.js")), d = ({ embedding: l }) => {
-        a.terminate(), i(l);
+  embedding(s, e = 500, t = 50) {
+    const m = (n) => new Promise((a, i) => {
+      const o = new x(S(T(j(import.meta.url)), "embedder.js")), d = ({ embedding: l }) => {
+        o.terminate(), a(l);
       }, c = (l) => {
-        a.terminate(), m(l);
+        o.terminate(), i(l);
       };
-      a.on("message", d), a.on("error", c), a.on("exit", (l) => {
-        l !== 0 && m(new Error(`Worker exited with code ${l}`));
-      }), a.postMessage({ text: n, model: this.ai.options?.embedder || "bge-small-en-v1.5", modelDir: this.ai.options.path });
-    }), s = this.chunk(r, e, t);
-    return Promise.all(s.map(async (n, i) => ({
-      index: i,
-      embedding: await o(n),
+      o.on("message", d), o.on("error", c), o.on("exit", (l) => {
+        l !== 0 && i(new Error(`Worker exited with code ${l}`));
+      }), o.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, a) => ({
+      index: a,
+      embedding: await m(n),
       text: n,
       tokens: this.estimateTokens(n)
     })));
@@ -395,8 +397,8 @@ ${a.map((u) => `${u.role}: ${u.content}`).join(`
    * @param history Object to size
    * @returns {number} Rough token count
    */
-  estimateTokens(r) {
-    const e = JSON.stringify(r);
+  estimateTokens(s) {
+    const e = JSON.stringify(s);
     return Math.ceil(e.length / 4 * 1.2);
   }
   /**
@@ -405,22 +407,27 @@ ${a.map((u) => `${u.role}: ${u.content}`).join(`
    * @param {string} searchTerms Multiple search terms to check against target
    * @returns {{avg: number, max: number, similarities: number[]}} Similarity values 0-1: 0 = unique, 1 = identical
    */
-  fuzzyMatch(r, ...e) {
+  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((m, a) => m.charCodeAt(0) * (a + 1) % i / i).slice(0, i), o = t(r), s = e.map((n) => t(n)).map((n) => this.cosineSimilarity(o, n));
-    return { avg: s.reduce((n, i) => n + i, 0) / s.length, max: Math.max(...s), similarities: s };
+    const t = (n, a = 10) => n.toLowerCase().split("").map((i, o) => i.charCodeAt(0) * (o + 1) % a / a).slice(0, a), m = t(s), r = e.map((n) => t(n)).map((n) => this.cosineSimilarity(m, n));
+    return { avg: r.reduce((n, a) => n + a, 0) / r.length, max: Math.max(...r), similarities: r };
   }
   /**
    * Ask a question with JSON response
-   * @param {string} message Question
+   * @param {string} text Text to process
+   * @param {string} schema JSON schema the AI should match
    * @param {LLMRequest} options Configuration options and chat history
    * @returns {Promise<{} | {} | RegExpExecArray | null>}
    */
-  async json(r, e) {
-    let t = await this.ask(r, { system: "Respond using a JSON blob matching any provided examples", ...e });
-    if (!t) return {};
-    const o = /```(?:.+)?\s*([\s\S]*?)```/.exec(t), s = o ? o[1].trim() : t;
-    return g(s, {});
+  async json(s, e, t) {
+    let m = await this.ask(s, { ...t, system: (t?.system ? `${t.system}
+` : "") + `Only respond using a JSON code block matching this schema:
+\`\`\`json
+${e}
+\`\`\`` });
+    if (!m) return {};
+    const r = /```(?:.+)?\s*([\s\S]*?)```/.exec(m), n = r ? r[1].trim() : m;
+    return g(n, {});
   }
   /**
    * Create a summary of some text
@@ -429,55 +436,72 @@ ${a.map((u) => `${u.role}: ${u.content}`).join(`
    * @param options LLM request options
    * @returns {Promise<string>} Summary
    */
-  summarize(r, e, t) {
-    return this.ask(r, { system: `Generate a brief summary <= ${e} tokens. Output nothing else`, temperature: 0.3, ...t });
+  summarize(s, e, t) {
+    return this.ask(s, { system: `Generate a brief summary <= ${e} tokens. Output nothing else`, temperature: 0.3, ...t });
   }
 }
 class I {
-  constructor(r) {
-    this.ai = r;
+  constructor(s) {
+    this.ai = s;
   }
-  asr(r, e = {}) {
-    const { model: t = this.ai.options.asr || "whisper-base", speaker: o = !1 } = e;
-    let s = !1;
+  asr(s, e = {}) {
+    const { model: t = this.ai.options.asr || "whisper-base", speaker: m = !1 } = e;
+    let r = !1;
     const n = () => {
-      s = !0;
-    }, i = new Promise((m, a) => {
+      r = !0;
+    };
+    let a = new Promise((i, o) => {
       const d = new x(S(T(j(import.meta.url)), "asr.js")), c = ({ text: p, warning: u, error: f }) => {
-        d.terminate(), !s && (f ? a(new Error(f)) : (u && console.warn(u), m(p)));
+        d.terminate(), !r && (f ? o(new Error(f)) : (u && console.warn(u), i(p)));
       }, l = (p) => {
-        d.terminate(), s || a(p);
+        d.terminate(), r || o(p);
       };
       d.on("message", c), d.on("error", l), d.on("exit", (p) => {
-        p !== 0 && !s && a(new Error(`Worker exited with code ${p}`));
-      }), d.postMessage({ file: r, model: t, speaker: o, modelDir: this.ai.options.path, token: this.ai.options.hfToken });
+        p !== 0 && !r && o(new Error(`Worker exited with code ${p}`));
+      }), d.postMessage({ file: s, model: t, speaker: m, modelDir: this.ai.options.path, token: this.ai.options.hfToken });
     });
-    return Object.assign(i, { abort: n });
+    if (e.speaker == "id") {
+      if (!this.ai.language.defaultModel) throw new Error("Configure an LLM for advanced ASR speaker detection");
+      a = a.then(async (i) => {
+        if (!i) return i;
+        let o = this.ai.language.chunk(i, 500, 0);
+        o.length > 4 && (o = [...o.slice(0, 3), o.at(-1)]);
+        const d = await this.ai.language.json(o.join(`
+`), '{1: "Detected Name"}', {
+          system: "Use this following transcript to identify speakers. Only identify speakers you are sure about",
+          temperature: 0.1
+        });
+        return Object.entries(d).forEach(([c, l]) => {
+          i = i.replaceAll(`[Speaker ${c}]`, `[${l}]`);
+        }), i;
+      });
+    }
+    return Object.assign(a, { abort: n });
   }
   canDiarization = R;
 }
 class J {
-  constructor(r) {
-    this.ai = r;
+  constructor(s) {
+    this.ai = s;
   }
   /**
    * Convert image to text using Optical Character Recognition
    * @param {string} path Path to image
    * @returns {AbortablePromise<string | null>} Promise of extracted text with abort method
    */
-  ocr(r) {
+  ocr(s) {
     let e;
-    const t = new Promise(async (o) => {
+    const t = new Promise(async (m) => {
       e = await L(this.ai.options.ocr || "eng", 2, { cachePath: this.ai.options.path });
-      const { data: s } = await e.recognize(r);
-      await e.terminate(), o(s.text.trim() || null);
+      const { data: r } = await e.recognize(s);
+      await e.terminate(), m(r.text.trim() || null);
     });
     return Object.assign(t, { abort: () => e?.terminate() });
   }
 }
-class se {
-  constructor(r) {
-    this.options = r, r.path || (r.path = M.tmpdir()), process.env.TRANSFORMERS_CACHE = r.path, this.audio = new I(this), this.language = new z(this), this.vision = new J(this);
+class re {
+  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);
   }
   /** Audio processing AI */
   audio;
@@ -503,15 +527,15 @@ const H = {
     language: { type: "string", description: "Execution language", enum: ["cli", "node", "python"], required: !0 },
     code: { type: "string", description: "Code to execute", required: !0 }
   },
-  fn: async (h, r, e) => {
+  fn: async (h, s, e) => {
     try {
       switch (h.type) {
         case "bash":
-          return await H.fn({ command: h.code }, r, e);
+          return await H.fn({ command: h.code }, s, e);
         case "node":
-          return await F.fn({ code: h.code }, r, e);
+          return await F.fn({ code: h.code }, s, e);
         case "python":
-          return await G.fn({ code: h.code }, r, e);
+          return await G.fn({ code: h.code }, s, e);
       }
     } catch (t) {
       return { error: t?.message || t.toString() };
@@ -526,7 +550,7 @@ const H = {
     headers: { type: "object", description: "HTTP headers to send", default: {} },
     body: { type: "object", description: "HTTP body to send" }
   },
-  fn: (h) => new $({ url: h.url, headers: h.headers }).request({ method: h.method || "GET", body: h.body })
+  fn: (h) => new E({ url: h.url, headers: h.headers }).request({ method: h.method || "GET", body: h.body })
 }, F = {
   name: "exec_javascript",
   description: "Execute commonjs javascript",
@@ -534,8 +558,8 @@ const H = {
     code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
   fn: async (h) => {
-    const r = E(null), e = await A({ console: r }, h.code, !0).catch((t) => r.output.error.push(t));
-    return { ...r.output, return: e, stdout: void 0, stderr: void 0 };
+    const s = P(null), e = await A({ console: s }, h.code, !0).catch((t) => s.output.error.push(t));
+    return { ...s.output, return: e, stdout: void 0, stderr: void 0 };
   }
 }, G = {
   name: "exec_javascript",
@@ -552,24 +576,24 @@ const H = {
     focus: { type: "string", description: 'Optional: What aspect to focus on (e.g., "pricing", "features", "contact info")' }
   },
   fn: async (h) => {
-    const r = await fetch(h.url, { headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" } }).then((n) => n.text()).catch((n) => {
+    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(r);
+    }), e = D.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() || "",
       description: e('meta[name="description"]').attr("content") || e('meta[property="og:description"]').attr("content") || ""
     };
-    let o = "";
-    const s = ["article", "main", '[role="main"]', ".content", ".post", ".entry", "body"];
-    for (const n of s) {
-      const i = e(n).first();
-      if (i.length && i.text().trim().length > 200) {
-        o = i.text();
+    let m = "";
+    const r = ["article", "main", '[role="main"]', ".content", ".post", ".entry", "body"];
+    for (const n of r) {
+      const a = e(n).first();
+      if (a.length && a.text().trim().length > 200) {
+        m = a.text();
         break;
       }
     }
-    return o || (o = e("body").text()), o = o.replace(/\s+/g, " ").trim().slice(0, 8e3), { url: h.url, title: t.title.trim(), description: t.description.trim(), content: o, 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 };
   }
 }, ce = {
   name: "web_search",
@@ -579,20 +603,20 @@ const H = {
     length: { type: "string", description: "Number of results to return", default: 5 }
   },
   fn: async (h) => {
-    const r = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(h.query)}`, {
+    const s = 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((s) => s.text());
+    }).then((r) => r.text());
     let e, t = /<a .*?href="(.+?)".+?<\/a>/g;
-    const o = new v();
-    for (; (e = t.exec(r)) !== null; ) {
-      let s = /uddg=(.+)&amp?/.exec(decodeURIComponent(e[1]))?.[1];
-      if (s && (s = decodeURIComponent(s)), s && o.add(s), o.size >= (h.length || 5)) break;
+    const m = new O();
+    for (; (e = t.exec(s)) !== null; ) {
+      let r = /uddg=(.+)&amp?/.exec(decodeURIComponent(e[1]))?.[1];
+      if (r && (r = decodeURIComponent(r)), r && m.add(r), m.size >= (h.length || 5)) break;
     }
-    return o;
+    return m;
   }
 };
 export {
-  se as Ai,
+  re as Ai,
   W as Anthropic,
   I as Audio,
   H as CliTool,