@ztimson/ai-utils 0.7.7 → 0.7.9

package/dist/index.mjs

@@ -1,239 +1,241 @@
-import * as M from "node:os";
-import { objectMap as k, JSONAttemptParse as g, findByProp as _, JSONSanitize as b, clean as $, Http as v, consoleInterceptor as E, fn as P, ASet as A } from "@ztimson/utils";
-import { Anthropic as O } from "@anthropic-ai/sdk";
+import * as $ from "node:os";
+import { tmpdir as P } from "node:os";
+import { objectMap as j, JSONAttemptParse as w, findByProp as T, JSONSanitize as b, clean as M, Http as O, consoleInterceptor as A, fn as q, ASet as v } from "@ztimson/utils";
+import { Anthropic as R } 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 q } from "path";
-import { canDiarization as R } from "./asr.mjs";
-import { createWorker as L } from "tesseract.js";
-import "./embedder.mjs";
-import * as D from "cheerio";
-import { $ as N, $Sync as J } from "@ztimson/node-utils";
-class T {
+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 _, { join as x } from "node:path";
+import { createWorker as D } from "tesseract.js";
+import * as I from "cheerio";
+import { $ as F, $Sync as H } from "@ztimson/node-utils";
+class E {
 }
-class C extends T {
-  constructor(t, e, s) {
-    super(), this.ai = t, this.apiToken = e, this.model = s, this.client = new O({ apiKey: e });
+class G extends E {
+  constructor(r, e, t) {
+    super(), this.ai = r, this.apiToken = e, this.model = t, this.client = new R({ apiKey: e });
   }
   client;
-  toStandard(t) {
-    const e = Date.now(), s = [];
-    for (let c of t)
-      if (typeof c.content == "string")
-        s.push({ timestamp: e, ...c });
+  toStandard(r) {
+    const e = Date.now(), t = [];
+    for (let l of r)
+      if (typeof l.content == "string")
+        t.push({ timestamp: e, ...l });
       else {
-        const r = c.content?.filter((o) => o.type == "text").map((o) => o.text).join(`
+        const n = l.content?.filter((s) => s.type == "text").map((s) => s.text).join(`
 
 `);
-        r && s.push({ timestamp: e, role: c.role, content: r }), c.content.forEach((o) => {
-          if (o.type == "tool_use")
-            s.push({ timestamp: e, role: "tool", id: o.id, name: o.name, args: o.input, content: void 0 });
-          else if (o.type == "tool_result") {
-            const i = s.findLast((n) => n.id == o.tool_use_id);
-            i && (i[o.is_error ? "error" : "content"] = o.content);
+        n && t.push({ timestamp: e, role: l.role, content: n }), l.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);
           }
         });
       }
-    return s;
+    return t;
   }
-  fromStandard(t) {
-    for (let e = 0; e < t.length; e++)
-      if (t[e].role == "tool") {
-        const s = t[e];
-        t.splice(
+  fromStandard(r) {
+    for (let e = 0; e < r.length; e++)
+      if (r[e].role == "tool") {
+        const t = r[e];
+        r.splice(
           e,
           1,
-          { role: "assistant", content: [{ type: "tool_use", id: s.id, name: s.name, input: s.args }] },
-          { role: "user", content: [{ type: "tool_result", tool_use_id: s.id, is_error: !!s.error, content: s.error || s.content }] }
+          { 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 t.map(({ timestamp: e, ...s }) => s);
+    return r.map(({ timestamp: e, ...t }) => t);
   }
-  ask(t, e = {}) {
-    const s = new AbortController();
-    return Object.assign(new Promise(async (c) => {
-      let r = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
-      const o = e.tools || this.ai.options.llm?.tools || [], i = {
+  ask(r, e = {}) {
+    const t = new AbortController();
+    return Object.assign(new Promise(async (l) => {
+      let n = this.fromStandard([...e.history || [], { role: "user", content: r, timestamp: Date.now() }]);
+      const s = e.tools || this.ai.options.llm?.tools || [], o = {
         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: o.map((m) => ({
+        tools: s.map((m) => ({
           name: m.name,
           description: m.description,
           input_schema: {
             type: "object",
-            properties: m.args ? k(m.args, (a, u) => ({ ...u, required: void 0 })) : {},
-            required: m.args ? Object.entries(m.args).filter((a) => a[1].required).map((a) => a[0]) : []
+            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]) : []
           },
           fn: void 0
         })),
-        messages: r,
+        messages: n,
         stream: !!e.stream
       };
-      let n, l = !0;
+      let c, a = !0;
       do {
-        if (n = await this.client.messages.create(i).catch((a) => {
-          throw a.message += `
+        if (c = await this.client.messages.create(o).catch((i) => {
+          throw i.message += `
 
 Messages:
-${JSON.stringify(r, null, 2)}`, a;
+${JSON.stringify(n, null, 2)}`, i;
         }), e.stream) {
-          l ? l = !1 : e.stream({ text: `
+          a ? a = !1 : e.stream({ text: `
 
-` }), n.content = [];
-          for await (const a of n) {
-            if (s.signal.aborted) break;
-            if (a.type === "content_block_start")
-              a.content_block.type === "text" ? n.content.push({ type: "text", text: "" }) : a.content_block.type === "tool_use" && n.content.push({ type: "tool_use", id: a.content_block.id, name: a.content_block.name, input: "" });
-            else if (a.type === "content_block_delta")
-              if (a.delta.type === "text_delta") {
-                const u = a.delta.text;
-                n.content.at(-1).text += u, e.stream({ text: u });
-              } else a.delta.type === "input_json_delta" && (n.content.at(-1).input += a.delta.partial_json);
-            else if (a.type === "content_block_stop") {
-              const u = n.content.at(-1);
-              u.input != null && (u.input = u.input ? g(u.input, {}) : {});
-            } else if (a.type === "message_stop")
+` }), c.content = [];
+          for await (const i of c) {
+            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")
               break;
           }
         }
-        const m = n.content.filter((a) => a.type === "tool_use");
-        if (m.length && !s.signal.aborted) {
-          r.push({ role: "assistant", content: n.content });
-          const a = await Promise.all(m.map(async (u) => {
-            const p = o.find(_("name", u.name));
-            if (e.stream && e.stream({ tool: u.name }), !p) return { tool_use_id: u.id, is_error: !0, content: "Tool not found" };
+        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" };
             try {
-              const d = await p.fn(u.input, e?.stream, this.ai);
-              return { type: "tool_result", tool_use_id: u.id, content: b(d) };
-            } catch (d) {
-              return { type: "tool_result", tool_use_id: u.id, is_error: !0, content: d?.message || d?.toString() || "Unknown" };
+              const u = await p.fn(d.input, e?.stream, this.ai);
+              return { type: "tool_result", tool_use_id: d.id, content: b(u) };
+            } catch (u) {
+              return { type: "tool_result", tool_use_id: d.id, is_error: !0, content: u?.message || u?.toString() || "Unknown" };
             }
           }));
-          r.push({ role: "user", content: a }), i.messages = r;
+          n.push({ role: "user", content: i }), o.messages = n;
         }
-      } while (!s.signal.aborted && n.content.some((m) => m.type === "tool_use"));
-      r.push({ role: "assistant", content: n.content.filter((m) => m.type == "text").map((m) => m.text).join(`
+      } 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(`
 
-`) }), r = this.toStandard(r), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...r), c(r.at(-1)?.content);
-    }), { abort: () => s.abort() });
+`) }), 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);
+    }), { abort: () => t.abort() });
   }
 }
-class w extends T {
-  constructor(t, e, s, c) {
-    super(), this.ai = t, this.host = e, this.token = s, this.model = c, this.client = new U($({
+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({
       baseURL: e,
-      apiKey: s
+      apiKey: t
     }));
   }
   client;
-  toStandard(t) {
-    for (let e = 0; e < t.length; e++) {
-      const s = t[e];
-      if (s.role === "assistant" && s.tool_calls) {
-        const c = s.tool_calls.map((r) => ({
+  toStandard(r) {
+    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) => ({
           role: "tool",
-          id: r.id,
-          name: r.function.name,
-          args: g(r.function.arguments, {}),
-          timestamp: s.timestamp
+          id: n.id,
+          name: n.function.name,
+          args: w(n.function.arguments, {}),
+          timestamp: t.timestamp
         }));
-        t.splice(e, 1, ...c), e += c.length - 1;
-      } else if (s.role === "tool" && s.content) {
-        const c = t.find((r) => s.tool_call_id == r.id);
-        c && (s.content.includes('"error":') ? c.error = s.content : c.content = s.content), t.splice(e, 1), e--;
+        r.splice(e, 1, ...l), e += l.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--;
       }
-      t[e]?.timestamp || (t[e].timestamp = Date.now());
+      r[e]?.timestamp || (r[e].timestamp = Date.now());
     }
-    return t;
+    return r;
   }
-  fromStandard(t) {
-    return t.reduce((e, s) => {
-      if (s.role === "tool")
+  fromStandard(r) {
+    return r.reduce((e, t) => {
+      if (t.role === "tool")
         e.push({
           role: "assistant",
           content: null,
-          tool_calls: [{ id: s.id, type: "function", function: { name: s.name, arguments: JSON.stringify(s.args) } }],
+          tool_calls: [{ id: t.id, type: "function", function: { name: t.name, arguments: JSON.stringify(t.args) } }],
           refusal: null,
           annotations: []
         }, {
           role: "tool",
-          tool_call_id: s.id,
-          content: s.error || s.content
+          tool_call_id: t.id,
+          content: t.error || t.content
         });
       else {
-        const { timestamp: c, ...r } = s;
-        e.push(r);
+        const { timestamp: l, ...n } = t;
+        e.push(n);
       }
       return e;
     }, []);
   }
-  ask(t, e = {}) {
-    const s = new AbortController();
-    return Object.assign(new Promise(async (c, r) => {
+  ask(r, e = {}) {
+    const t = new AbortController();
+    return Object.assign(new Promise(async (l, n) => {
       e.system && e.history?.[0]?.role != "system" && e.history?.splice(0, 0, { role: "system", content: e.system, timestamp: Date.now() });
-      let o = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
-      const i = e.tools || this.ai.options.llm?.tools || [], n = {
+      let s = this.fromStandard([...e.history || [], { role: "user", content: r, timestamp: Date.now() }]);
+      const o = e.tools || this.ai.options.llm?.tools || [], c = {
         model: e.model || this.model,
-        messages: o,
+        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: i.map((a) => ({
+        tools: o.map((i) => ({
           type: "function",
           function: {
-            name: a.name,
-            description: a.description,
+            name: i.name,
+            description: i.description,
             parameters: {
               type: "object",
-              properties: a.args ? k(a.args, (u, p) => ({ ...p, required: void 0 })) : {},
-              required: a.args ? Object.entries(a.args).filter((u) => u[1].required).map((u) => u[0]) : []
+              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]) : []
             }
           }
         }))
       };
-      let l, m = !0;
+      let a, m = !0;
       do {
-        if (l = await this.client.chat.completions.create(n).catch((u) => {
-          throw u.message += `
+        if (a = await this.client.chat.completions.create(c).catch((d) => {
+          throw d.message += `
 
 Messages:
-${JSON.stringify(o, null, 2)}`, u;
+${JSON.stringify(s, null, 2)}`, d;
         }), e.stream) {
           m ? m = !1 : e.stream({ text: `
 
-` }), l.choices = [{ message: { content: "", tool_calls: [] } }];
-          for await (const u of l) {
-            if (s.signal.aborted) break;
-            u.choices[0].delta.content && (l.choices[0].message.content += u.choices[0].delta.content, e.stream({ text: u.choices[0].delta.content })), u.choices[0].delta.tool_calls && (l.choices[0].message.tool_calls = u.choices[0].delta.tool_calls);
+` }), a.choices = [{ message: { content: "", tool_calls: [] } }];
+          for await (const d of a) {
+            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);
           }
         }
-        const a = l.choices[0].message.tool_calls || [];
-        if (a.length && !s.signal.aborted) {
-          o.push(l.choices[0].message);
-          const u = await Promise.all(a.map(async (p) => {
-            const d = i?.find(_("name", p.function.name));
-            if (e.stream && e.stream({ tool: p.function.name }), !d) return { role: "tool", tool_call_id: p.id, content: '{"error": "Tool not found"}' };
+        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));
+            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 d.fn(f, e.stream, this.ai);
+              const f = w(p.function.arguments, {}), y = await u.fn(f, e.stream, this.ai);
               return { role: "tool", tool_call_id: p.id, content: b(y) };
             } catch (f) {
               return { role: "tool", tool_call_id: p.id, content: b({ error: f?.message || f?.toString() || "Unknown" }) };
             }
           }));
-          o.push(...u), n.messages = o;
+          s.push(...d), c.messages = s;
         }
-      } while (!s.signal.aborted && l.choices?.[0]?.message?.tool_calls?.length);
-      o.push({ role: "assistant", content: l.choices[0].message.content || "" }), o = this.toStandard(o), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...o), c(o.at(-1)?.content);
-    }), { abort: () => s.abort() });
+      } 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);
+    }), { abort: () => t.abort() });
   }
 }
-class W {
-  constructor(t) {
-    this.ai = t, t.options.llm?.models && Object.entries(t.options.llm.models).forEach(([e, s]) => {
-      this.defaultModel || (this.defaultModel = e), s.proto == "anthropic" ? this.models[e] = new C(this.ai, s.token, e) : s.proto == "ollama" ? this.models[e] = new w(this.ai, s.host, "not-needed", e) : s.proto == "openai" && (this.models[e] = new w(this.ai, s.host || null, s.token, e));
+class B {
+  constructor(r) {
+    this.ai = r, r.options.llm?.models && Object.entries(r.options.llm.models).forEach(([e, t]) => {
+      this.defaultModel || (this.defaultModel = e), t.proto == "anthropic" ? this.models[e] = new G(this.ai, t.token, e) : t.proto == "ollama" ? this.models[e] = new S(this.ai, t.host, "not-needed", e) : t.proto == "openai" && (this.models[e] = new S(this.ai, t.host || null, t.token, e));
     });
   }
   defaultModel;
@@ -244,25 +246,25 @@ class W {
    * @param {LLMRequest} options Configuration options and chat history
    * @returns {{abort: () => void, response: Promise<string>}} Function to abort response and chat history
    */
-  ask(t, e = {}) {
-    const s = e.model || this.defaultModel;
-    if (!this.models[s]) throw new Error(`Model does not exist: ${s}`);
-    let c = () => {
+  ask(r, e = {}) {
+    const t = e.model || this.defaultModel;
+    if (!this.models[t]) throw new Error(`Model does not exist: ${t}`);
+    let l = () => {
     };
-    return Object.assign(new Promise(async (r) => {
+    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 i = async (l, m, a = 50) => {
-          const [u, p] = await Promise.all([
+        const o = async (a, m, i = 50) => {
+          const [d, p] = await Promise.all([
             m ? this.embedding(m) : Promise.resolve(null),
-            l ? this.embedding(l) : Promise.resolve(null)
+            a ? this.embedding(a) : Promise.resolve(null)
           ]);
-          return (e.memory || []).map((d) => ({ ...d, score: u ? this.cosineSimilarity(d.embeddings[0], u[0].embedding) : 1 })).filter((d) => d.score >= 0.8).map((d) => ({ ...d, score: p ? this.cosineSimilarity(d.embeddings[1], p[0].embedding) : d.score })).filter((d) => d.score >= 0.2).toSorted((d, f) => d.score - f.score).slice(0, a);
-        }, n = await i(t);
-        n.length && e.history.push({ role: "assistant", content: `Things I remembered:
-` + n.map((l) => `${l.owner}: ${l.fact}`).join(`
+          return (e.memory || []).map((u) => ({ ...u, score: d ? this.cosineSimilarity(u.embeddings[0], d[0].embedding) : 1 })).filter((u) => u.score >= 0.8).map((u) => ({ ...u, score: p ? this.cosineSimilarity(u.embeddings[1], p[0].embedding) : u.score })).filter((u) => u.score >= 0.2).toSorted((u, f) => u.score - f.score).slice(0, i);
+        }, c = await o(r);
+        c.length && e.history.push({ role: "assistant", content: `Things I remembered:
+` + c.map((a) => `${a.owner}: ${a.fact}`).join(`
 `) }), e.tools = [...e.tools || [], {
           name: "read_memory",
           description: "Check your long-term memory for more information",
@@ -271,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: (l) => {
-            if (!l.subject && !l.query) throw new Error("Either a subject or query argument is required");
-            return i(l.query, l.subject, l.limit || 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);
           }
         }];
       }
-      const o = await this.models[s].ask(t, e);
+      const s = await this.models[t].ask(r, e);
       if (e.memory) {
-        const i = e.history?.findIndex((n) => n.role == "assistant" && n.content.startsWith("Things I remembered:"));
-        i != null && i >= 0 && e.history?.splice(i, 1);
+        const o = e.history?.findIndex((c) => c.role == "assistant" && c.content.startsWith("Things I remembered:"));
+        o != null && o >= 0 && e.history?.splice(o, 1);
       }
       if (e.compress || e.memory) {
-        let i = null;
+        let o = 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);
+          o = await this.ai.language.compressHistory(e.history, e.compress.max, e.compress.min, e), e.history.splice(0, e.history.length, ...o.history);
         else {
-          const n = e.history?.findLastIndex((l) => l.role == "user") ?? -1;
-          i = await this.ai.language.compressHistory(n != -1 ? e.history.slice(n) : e.history, 0, 0, e);
+          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);
         }
         if (e.memory) {
-          const n = e.memory.filter((l) => !i.memory.some((m) => this.cosineSimilarity(l.embeddings[1], m.embeddings[1]) > 0.8)).concat(i.memory);
-          e.memory.splice(0, e.memory.length, ...n);
+          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);
         }
       }
-      return r(o);
-    }), { abort: c });
+      return n(s);
+    }), { abort: l });
   }
   /**
    * Compress chat history to reduce context size
@@ -306,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(t, e, s, c) {
-    if (this.estimateTokens(t) < e) return { history: t, memory: [] };
-    let r = 0, o = 0;
-    for (let d of t.toReversed())
-      if (o += this.estimateTokens(d.content), o < s) r++;
+  async compressHistory(r, e, t, l) {
+    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 (t.length <= r) return { history: t, memory: [] };
-    const i = t[0].role == "system" ? t[0] : null, n = r == 0 ? [] : t.slice(-r), l = (r == 0 ? t : t.slice(0, -r)).filter((d) => d.role === "assistant" || d.role === "user"), m = await this.json(l.map((d) => `${d.role}: ${d.content}`).join(`
+    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(`
 
 `), "{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: c?.model,
-      temperature: c?.temperature || 0.3
-    }), a = /* @__PURE__ */ new Date(), u = await Promise.all((m?.facts || [])?.map(async ([d, f]) => {
-      const y = await Promise.all([this.embedding(d), this.embedding(`${d}: ${f}`)]);
-      return { owner: d, fact: f, embeddings: [y[0][0].embedding, y[1][0].embedding], timestamp: a };
-    })), p = [{ role: "assistant", content: `Conversation Summary: ${m?.summary}`, timestamp: Date.now() }, ...n];
-    return i && p.splice(0, 0, i), { history: p, memory: u };
+      model: l?.model,
+      temperature: l?.temperature || 0.3
+    }), i = /* @__PURE__ */ new Date(), d = await Promise.all((m?.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 };
   }
   /**
    * Compare the difference between embeddings (calculates the angle between two vectors)
@@ -331,13 +333,13 @@ You have passive persistent memory never make any mention of your memory capabil
    * @param {number[]} v2 Second embedding / vector for comparison
    * @returns {number} Similarity values 0-1: 0 = unique, 1 = identical
    */
-  cosineSimilarity(t, e) {
-    if (t.length !== e.length) throw new Error("Vectors must be same length");
-    let s = 0, c = 0, r = 0;
-    for (let i = 0; i < t.length; i++)
-      s += t[i] * e[i], c += t[i] * t[i], r += e[i] * e[i];
-    const o = Math.sqrt(c) * Math.sqrt(r);
-    return o === 0 ? 0 : s / o;
+  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);
+    return s === 0 ? 0 : t / s;
   }
   /**
    * Chunk text into parts for AI digestion
@@ -346,26 +348,26 @@ You have passive persistent memory never make any mention of your memory capabil
    * @param {number} overlapTokens Includes previous X tokens to provide continuity to AI (In addition to max tokens)
    * @returns {string[]} Chunked strings
    */
-  chunk(t, e = 500, s = 50) {
-    const c = (n, l = "") => n ? Object.entries(n).flatMap(([m, a]) => {
-      const u = l ? `${l}${isNaN(+m) ? `.${m}` : `[${m}]`}` : m;
-      return typeof a == "object" && !Array.isArray(a) ? c(a, u) : `${u}: ${Array.isArray(a) ? a.join(", ") : a}`;
-    }) : [], o = (typeof t == "object" ? c(t) : t.split(`
-`)).flatMap((n) => [...n.split(/\s+/).filter(Boolean), `
-`]), i = [];
-    for (let n = 0; n < o.length; ) {
-      let l = "", m = n;
-      for (; m < o.length; ) {
-        const u = l + (l ? " " : "") + o[m];
-        if (this.estimateTokens(u.replace(/\s*\n\s*/g, `
-`)) > e && l) break;
-        l = u, m++;
+  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 a = l.replace(/\s*\n\s*/g, `
+      const i = a.replace(/\s*\n\s*/g, `
 `).trim();
-      a && i.push(a), n = Math.max(m - s, m === n ? n + 1 : m);
+      i && o.push(i), c = Math.max(m - t, m === c ? c + 1 : m);
     }
-    return i;
+    return o;
   }
   /**
    * Create a vector representation of a string
@@ -373,31 +375,48 @@ You have passive persistent memory never make any mention of your memory capabil
    * @param {maxTokens?: number, overlapTokens?: number} opts Options for embedding such as chunk sizes
    * @returns {Promise<Awaited<{index: number, embedding: number[], text: string, tokens: number}>[]>} Chunked embeddings
    */
-  async embedding(t, e = {}) {
-    let { maxTokens: s = 500, overlapTokens: c = 50 } = e;
-    const r = (n) => new Promise((l, m) => {
-      const a = new x(S(q(j(import.meta.url)), "embedder.js")), u = ({ embedding: d }) => {
-        a.terminate(), l(d);
-      }, p = (d) => {
-        a.terminate(), m(d);
-      };
-      a.on("message", u), a.on("error", p), a.on("exit", (d) => {
-        d !== 0 && m(new Error(`Worker exited with code ${d}`));
-      }), a.postMessage({ text: n, model: this.ai.options?.embedder || "bge-small-en-v1.5", modelDir: this.ai.options.path });
-    }), o = this.chunk(t, s, c), i = [];
-    for (let n = 0; n < o.length; n++) {
-      const l = o[n], m = await r(l);
-      i.push({ index: n, embedding: m, text: l, tokens: this.estimateTokens(l) });
-    }
-    return i;
+  embedding(r, e = {}) {
+    let { maxTokens: t = 500, overlapTokens: l = 50 } = e, n = !1;
+    const s = () => {
+      n = !0;
+    }, o = (a) => new Promise((m, i) => {
+      if (n) return i(new Error("Aborted"));
+      const d = [
+        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();
+      let u = "";
+      p.stdout.on("data", (f) => u += f.toString()), p.on("close", (f) => {
+        if (n) return i(new Error("Aborted"));
+        if (f === 0)
+          try {
+            const y = JSON.parse(u);
+            m(y.embedding);
+          } catch {
+            i(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) });
+      }
+      return m;
+    })();
+    return Object.assign(c, { abort: s });
   }
   /**
    * Estimate variable as tokens
    * @param history Object to size
    * @returns {number} Rough token count
    */
-  estimateTokens(t) {
-    const e = JSON.stringify(t);
+  estimateTokens(r) {
+    const e = JSON.stringify(r);
     return Math.ceil(e.length / 4 * 1.2);
   }
   /**
@@ -406,10 +425,10 @@ You have passive persistent memory never make any mention of your memory capabil
    * @param {string} searchTerms Multiple search terms to check against target
    * @returns {{avg: number, max: number, similarities: number[]}} Similarity values 0-1: 0 = unique, 1 = identical
    */
-  fuzzyMatch(t, ...e) {
+  fuzzyMatch(r, ...e) {
     if (e.length < 2) throw new Error("Requires at least 2 strings to compare");
-    const s = (o, i = 10) => o.toLowerCase().split("").map((n, l) => n.charCodeAt(0) * (l + 1) % i / i).slice(0, i), c = s(t), r = e.map((o) => s(o)).map((o) => this.cosineSimilarity(c, o));
-    return { avg: r.reduce((o, i) => o + i, 0) / r.length, max: Math.max(...r), similarities: r };
+    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 };
   }
   /**
    * Ask a question with JSON response
@@ -418,15 +437,15 @@ You have passive persistent memory never make any mention of your memory capabil
    * @param {LLMRequest} options Configuration options and chat history
    * @returns {Promise<{} | {} | RegExpExecArray | null>}
    */
-  async json(t, e, s) {
-    let c = await this.ask(t, { ...s, system: (s?.system ? `${s.system}
+  async json(r, e, t) {
+    let l = await this.ask(r, { ...t, system: (t?.system ? `${t.system}
 ` : "") + `Only respond using a JSON code block matching this schema:
 \`\`\`json
 ${e}
 \`\`\`` });
-    if (!c) return {};
-    const r = /```(?:.+)?\s*([\s\S]*?)```/.exec(c), o = r ? r[1].trim() : c;
-    return g(o, {});
+    if (!l) return {};
+    const n = /```(?:.+)?\s*([\s\S]*?)```/.exec(l), s = n ? n[1].trim() : l;
+    return w(s, {});
   }
   /**
    * Create a summary of some text
@@ -435,110 +454,154 @@ ${e}
    * @param options LLM request options
    * @returns {Promise<string>} Summary
    */
-  summarize(t, e, s) {
-    return this.ask(t, { system: `Generate a brief summary <= ${e} tokens. Output nothing else`, temperature: 0.3, ...s });
+  summarize(r, e, t) {
+    return this.ask(r, { system: `Generate a brief summary <= ${e} tokens. Output nothing else`, temperature: 0.3, ...t });
   }
 }
-class z {
-  constructor(t) {
-    this.ai = t;
-  }
-  busy = !1;
-  currentJob;
-  queue = [];
-  worker = null;
-  processQueue() {
-    if (this.busy || !this.queue.length) return;
-    this.busy = !0;
-    const t = this.queue.shift();
-    this.worker || (this.worker = new x(S(q(j(import.meta.url)), "asr.js")), this.worker.on("message", this.handleMessage.bind(this)), this.worker.on("error", this.handleError.bind(this))), this.currentJob = t, this.worker.postMessage({ file: t.file, model: t.model, speaker: t.speaker, modelDir: t.modelDir, token: t.token });
-  }
-  handleMessage({ text: t, warning: e, error: s }) {
-    const c = this.currentJob;
-    this.busy = !1, s ? c.reject(new Error(s)) : (e && console.warn(e), c.resolve(t)), this.processQueue();
+class K {
+  constructor(r) {
+    this.ai = r, r.options.whisper && (this.whisperModel = r.options.asr?.endsWith(".bin") ? r.options.asr : r.options.asr + ".bin", this.downloadAsrModel()), this.pyannote = `
+import sys
+import json
+import os
+from pyannote.audio import Pipeline
+
+os.environ['TORCH_HOME'] = r"${r.options.path}"
+pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization-3.1", token="${r.options.hfToken}")
+output = pipeline(sys.argv[1])
+
+segments = []
+for turn, speaker in output.speaker_diarization:
+    segments.append({"start": turn.start, "end": turn.end, "speaker": speaker})
+
+print(json.dumps(segments))
+`;
   }
-  handleError(t) {
-    this.currentJob && (this.currentJob.reject(t), this.busy = !1, this.processQueue());
+  downloads = {};
+  pyannote;
+  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)
+            if (e.diarization)
+              try {
+                n(JSON.parse(c));
+              } catch {
+                s(new Error("Failed to parse whisper JSON"));
+              }
+            else
+              n(c.trim() || null);
+          else
+            s(new Error(`Exit code ${m}`));
+        });
+      });
+    });
+    return Object.assign(l, { abort: () => t?.kill("SIGTERM") });
   }
-  asr(t, e = {}) {
-    const { model: s = this.ai.options.asr || "whisper-base", speaker: c = !1 } = e;
-    let r = !1;
-    const o = () => {
-      r = !0;
+  runDiarization(r) {
+    let e = !1, t = () => {
+      e = !0;
     };
-    let i = new Promise((n, l) => {
-      this.queue.push({
-        file: t,
-        model: s,
-        speaker: c,
-        modelDir: this.ai.options.path,
-        token: this.ai.options.hfToken,
-        resolve: (m) => !r && n(m),
-        reject: (m) => !r && l(m)
-      }), this.processQueue();
+    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));
+    }), n = Promise.all([
+      l("python"),
+      l("python3")
+    ]).then((async ([s, o]) => {
+      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)
+            try {
+              m(JSON.parse(d));
+            } catch {
+              i(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 });
+      });
+    }));
+    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);
     });
-    if (e.speaker == "id") {
-      if (!this.ai.language.defaultModel) throw new Error("Configure an LLM for advanced ASR speaker detection");
-      i = i.then(async (n) => {
-        if (!n) return n;
-        let l = this.ai.language.chunk(n, 500, 0);
-        l.length > 4 && (l = [...l.slice(0, 3), l.at(-1)]);
-        const m = await this.ai.language.json(l.join(`
+    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(`
+`);
+  }
+  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") {
+        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(`
 `), '{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
         });
-        return Object.entries(m).forEach(([a, u]) => {
-          n = n.replaceAll(`[Speaker ${a}]`, `[${u}]`);
-        }), n;
-      });
-    }
-    return Object.assign(i, { abort: o });
+        Object.entries(m).forEach(([i, d]) => o = o.replaceAll(`[Speaker ${i}]`, `[${d}]`));
+      }
+      return o;
+    });
+    return Object.assign(s, { abort: n });
   }
-  canDiarization = () => R().then((t) => !!t);
-}
-class I {
-  constructor(t) {
-    this.ai = t;
+  async downloadAsrModel(r = this.whisperModel) {
+    if (!this.ai.options.whisper) throw new Error("Whisper not configured");
+    r.endsWith(".bin") || (r += ".bin");
+    const e = _.join(this.ai.options.path, r);
+    return await k.stat(e).then(() => !0).catch(() => !1) ? e : this.downloads[r] ? this.downloads[r] : (this.downloads[r] = fetch(`https://huggingface.co/ggerganov/whisper.cpp/resolve/main/${r}`).then((t) => t.arrayBuffer()).then((t) => Buffer.from(t)).then(async (t) => (await k.writeFile(e, t), delete this.downloads[r], e)), this.downloads[r]);
   }
-  worker = null;
-  queue = [];
-  busy = !1;
-  async processQueue() {
-    if (this.busy || !this.queue.length) return;
-    this.busy = !0;
-    const t = this.queue.shift();
-    this.worker || (this.worker = await L(this.ai.options.ocr || "eng", 2, { cachePath: this.ai.options.path }));
-    try {
-      const { data: e } = await this.worker.recognize(t.path);
-      t.resolve(e.text.trim() || null);
-    } catch (e) {
-      t.reject(e);
-    }
-    this.busy = !1, this.processQueue();
+}
+class V {
+  constructor(r) {
+    this.ai = r;
   }
   /**
    * 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(t) {
-    let e = !1;
-    const s = () => {
-      e = !0;
-    }, c = new Promise((r, o) => {
-      this.queue.push({
-        path: t,
-        resolve: (i) => !e && r(i),
-        reject: (i) => !e && o(i)
-      }), this.processQueue();
+  ocr(r) {
+    let e;
+    const t = new Promise(async (l) => {
+      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);
     });
-    return Object.assign(c, { abort: s });
+    return Object.assign(t, { abort: () => e?.terminate() });
   }
 }
-class re {
-  constructor(t) {
-    this.options = t, t.path || (t.path = M.tmpdir()), process.env.TRANSFORMERS_CACHE = t.path, this.audio = new z(this), this.language = new W(this), this.vision = new I(this);
+class de {
+  constructor(r) {
+    this.options = r, r.path || (r.path = $.tmpdir()), process.env.TRANSFORMERS_CACHE = r.path, this.audio = new K(this), this.language = new B(this), this.vision = new V(this);
   }
   /** Audio processing AI */
   audio;
@@ -547,38 +610,38 @@ class re {
   /** Vision processing AI */
   vision;
 }
-const H = {
+const Y = {
   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}`
-}, oe = {
+  fn: (h) => F`${h.command}`
+}, ue = {
   name: "get_datetime",
   description: "Get current UTC date / time",
   args: {},
   fn: async () => (/* @__PURE__ */ new Date()).toUTCString()
-}, ne = {
+}, pe = {
   name: "exec",
   description: "Run code/scripts",
   args: {
     language: { type: "string", description: "Execution language", enum: ["cli", "node", "python"], required: !0 },
     code: { type: "string", description: "Code to execute", required: !0 }
   },
-  fn: async (h, t, e) => {
+  fn: async (h, r, e) => {
     try {
       switch (h.type) {
         case "bash":
-          return await H.fn({ command: h.code }, t, e);
+          return await Y.fn({ command: h.code }, r, e);
         case "node":
-          return await F.fn({ code: h.code }, t, e);
+          return await Q.fn({ code: h.code }, r, e);
         case "python":
-          return await Q.fn({ code: h.code }, t, e);
+          return await X.fn({ code: h.code }, r, e);
       }
-    } catch (s) {
-      return { error: s?.message || s.toString() };
+    } catch (t) {
+      return { error: t?.message || t.toString() };
     }
   }
-}, ie = {
+}, he = {
   name: "fetch",
   description: "Make HTTP request to URL",
   args: {
@@ -587,25 +650,25 @@ const H = {
     headers: { type: "object", description: "HTTP headers to send", default: {} },
     body: { type: "object", description: "HTTP body to send" }
   },
-  fn: (h) => new v({ url: h.url, headers: h.headers }).request({ method: h.method || "GET", body: h.body })
-}, F = {
+  fn: (h) => new O({ url: h.url, headers: h.headers }).request({ method: h.method || "GET", body: h.body })
+}, Q = {
   name: "exec_javascript",
   description: "Execute commonjs javascript",
   args: {
     code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
   fn: async (h) => {
-    const t = E(null), e = await P({ console: t }, h.code, !0).catch((s) => t.output.error.push(s));
-    return { ...t.output, return: e, stdout: void 0, stderr: void 0 };
+    const r = A(null), e = await q({ console: r }, h.code, !0).catch((t) => r.output.error.push(t));
+    return { ...r.output, return: e, stdout: void 0, stderr: void 0 };
   }
-}, Q = {
+}, X = {
   name: "exec_javascript",
   description: "Execute commonjs javascript",
   args: {
     code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
-  fn: async (h) => ({ result: J`python -c "${h.code}"` })
-}, ae = {
+  fn: async (h) => ({ result: H`python -c "${h.code}"` })
+}, fe = {
   name: "read_webpage",
   description: "Extract clean, structured content from a webpage. Use after web_search to read specific URLs",
   args: {
@@ -613,26 +676,26 @@ const H = {
     focus: { type: "string", description: 'Optional: What aspect to focus on (e.g., "pricing", "features", "contact info")' }
   },
   fn: async (h) => {
-    const t = 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 = D.load(t);
+    const r = await fetch(h.url, { headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" } }).then((s) => s.text()).catch((s) => {
+      throw new Error(`Failed to fetch: ${s.message}`);
+    }), e = I.load(r);
     e('script, style, nav, footer, header, aside, iframe, noscript, [role="navigation"], [role="banner"], .ad, .ads, .cookie, .popup').remove();
-    const s = {
+    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 c = "";
-    const r = ["article", "main", '[role="main"]', ".content", ".post", ".entry", "body"];
-    for (const o of r) {
-      const i = e(o).first();
-      if (i.length && i.text().trim().length > 200) {
-        c = i.text();
+    let l = "";
+    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();
         break;
       }
     }
-    return c || (c = e("body").text()), c = c.replace(/\s+/g, " ").trim().slice(0, 8e3), { url: h.url, title: s.title.trim(), description: s.description.trim(), content: c, focus: h.focus };
+    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 = {
+}, ye = {
   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: {
@@ -640,33 +703,32 @@ const H = {
     length: { type: "string", description: "Number of results to return", default: 5 }
   },
   fn: async (h) => {
-    const t = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(h.query)}`, {
+    const r = 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((r) => r.text());
-    let e, s = /<a .*?href="(.+?)".+?<\/a>/g;
-    const c = new A();
-    for (; (e = s.exec(t)) !== null; ) {
-      let r = /uddg=(.+)&amp?/.exec(decodeURIComponent(e[1]))?.[1];
-      if (r && (r = decodeURIComponent(r)), r && c.add(r), c.size >= (h.length || 5)) break;
+    }).then((n) => n.text());
+    let e, t = /<a .*?href="(.+?)".+?<\/a>/g;
+    const l = 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;
     }
-    return c;
+    return l;
   }
 };
 export {
-  re as Ai,
-  C as Anthropic,
-  z as Audio,
-  H as CliTool,
-  oe as DateTimeTool,
-  ne as ExecTool,
-  ie as FetchTool,
-  F as JSTool,
-  T as LLMProvider,
-  w as OpenAi,
-  Q as PythonTool,
-  ae as ReadWebpageTool,
-  I as Vision,
-  ce as WebSearchTool,
-  R as canDiarization
+  de as Ai,
+  G as Anthropic,
+  K as Audio,
+  Y as CliTool,
+  ue as DateTimeTool,
+  pe as ExecTool,
+  he as FetchTool,
+  Q as JSTool,
+  E as LLMProvider,
+  S as OpenAi,
+  X as PythonTool,
+  fe as ReadWebpageTool,
+  V as Vision,
+  ye as WebSearchTool
 };
 //# sourceMappingURL=index.mjs.map