@ztimson/ai-utils 0.8.16 → 0.9.0

package/dist/index.mjs

@@ -1,254 +1,254 @@
-import * as O from "node:os";
-import { tmpdir as L } from "node:os";
-import { Anthropic as N } from "@anthropic-ai/sdk";
-import { objectMap as R, JSONAttemptParse as S, findByProp as z, JSONSanitize as _, clean as C, Http as J, consoleInterceptor as I, fn as F, ASet as H } from "@ztimson/utils";
-import { OpenAI as B } from "openai";
-import { fileURLToPath as D } from "url";
-import { join as G, dirname as K } from "path";
-import { spawn as b, execSync as Y } from "node:child_process";
-import { mkdtempSync as V } from "node:fs";
-import w from "node:fs/promises";
+import * as R from "node:os";
+import { tmpdir as W } from "node:os";
+import { Anthropic as C } from "@anthropic-ai/sdk";
+import { objectMap as O, JSONAttemptParse as $, findByProp as U, JSONSanitize as T, clean as J, Http as F, consoleInterceptor as B, fn as I, decodeHtml as D, ASet as H } from "@ztimson/utils";
+import { OpenAI as G } from "openai";
+import { fileURLToPath as K } from "url";
+import { join as Y, dirname as V } from "path";
+import { spawn as k, execSync as Z } from "node:child_process";
+import { mkdtempSync as Q } from "node:fs";
+import x from "node:fs/promises";
 import * as q from "node:path";
 import M, { join as A } from "node:path";
-import { createWorker as Z } from "tesseract.js";
-import * as Q from "cheerio";
-import { $Sync as T } from "@ztimson/node-utils";
-class W {
+import { createWorker as X } from "tesseract.js";
+import * as ee from "cheerio";
+import { $Sync as j } from "@ztimson/node-utils";
+class L {
 }
-class X extends W {
-  constructor(t, e, r) {
-    super(), this.ai = t, this.apiToken = e, this.model = r, this.client = new N({ apiKey: e });
+class te extends L {
+  constructor(r, e, t) {
+    super(), this.ai = r, this.apiToken = e, this.model = t, this.client = new C({ apiKey: e });
   }
   client;
-  toStandard(t) {
-    const e = Date.now(), r = [];
-    for (let o of t)
-      if (typeof o.content == "string")
-        r.push({ timestamp: e, ...o });
+  toStandard(r) {
+    const e = Date.now(), t = [];
+    for (let l of r)
+      if (typeof l.content == "string")
+        t.push({ timestamp: e, ...l });
       else {
-        const i = o.content?.filter((n) => n.type == "text").map((n) => n.text).join(`
+        const n = l.content?.filter((s) => s.type == "text").map((s) => s.text).join(`
 
 `);
-        i && r.push({ timestamp: e, role: o.role, content: i }), o.content.forEach((n) => {
-          if (n.type == "tool_use")
-            r.push({ timestamp: e, role: "tool", id: n.id, name: n.name, args: n.input, content: void 0 });
-          else if (n.type == "tool_result") {
-            const l = r.findLast((m) => m.id == n.tool_use_id);
-            l && (l[n.is_error ? "error" : "content"] = n.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((u) => u.id == s.tool_use_id);
+            o && (o[s.is_error ? "error" : "content"] = s.content);
           }
         });
       }
-    return r;
+    return t;
   }
-  fromStandard(t) {
-    for (let e = 0; e < t.length; e++)
-      if (t[e].role == "tool") {
-        const r = 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: r.id, name: r.name, input: r.args }] },
-          { role: "user", content: [{ type: "tool_result", tool_use_id: r.id, is_error: !!r.error, content: r.error || r.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, ...r }) => r);
+    return r.map(({ timestamp: e, ...t }) => t);
   }
-  ask(t, e = {}) {
-    const r = new AbortController();
-    return Object.assign(new Promise(async (o) => {
-      let i = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
-      const n = e.tools || this.ai.options.llm?.tools || [], l = {
+  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: n.map((u) => ({
-          name: u.name,
-          description: u.description,
+        tools: s.map((m) => ({
+          name: m.name,
+          description: m.description,
           input_schema: {
             type: "object",
-            properties: u.args ? R(u.args, (s, c) => ({ ...c, required: void 0 })) : {},
-            required: u.args ? Object.entries(u.args).filter((s) => s[1].required).map((s) => s[0]) : []
+            properties: m.args ? O(m.args, (i, p) => ({ ...p, required: void 0 })) : {},
+            required: m.args ? Object.entries(m.args).filter((i) => i[1].required).map((i) => i[0]) : []
           },
           fn: void 0
         })),
-        messages: i,
+        messages: n,
         stream: !!e.stream
       };
-      let m, a = !0;
+      let u, a = !0;
       do {
-        if (m = await this.client.messages.create(l).catch((s) => {
-          throw s.message += `
+        if (u = await this.client.messages.create(o).catch((i) => {
+          throw i.message += `
 
 Messages:
-${JSON.stringify(i, null, 2)}`, s;
+${JSON.stringify(n, null, 2)}`, i;
         }), e.stream) {
           a ? a = !1 : e.stream({ text: `
 
-` }), m.content = [];
-          for await (const s of m) {
-            if (r.signal.aborted) break;
-            if (s.type === "content_block_start")
-              s.content_block.type === "text" ? m.content.push({ type: "text", text: "" }) : s.content_block.type === "tool_use" && m.content.push({ type: "tool_use", id: s.content_block.id, name: s.content_block.name, input: "" });
-            else if (s.type === "content_block_delta")
-              if (s.delta.type === "text_delta") {
-                const c = s.delta.text;
-                m.content.at(-1).text += c, e.stream({ text: c });
-              } else s.delta.type === "input_json_delta" && (m.content.at(-1).input += s.delta.partial_json);
-            else if (s.type === "content_block_stop") {
-              const c = m.content.at(-1);
-              c.input != null && (c.input = c.input ? S(c.input, {}) : {});
-            } else if (s.type === "message_stop")
+` }), u.content = [];
+          for await (const i of u) {
+            if (t.signal.aborted) break;
+            if (i.type === "content_block_start")
+              i.content_block.type === "text" ? u.content.push({ type: "text", text: "" }) : i.content_block.type === "tool_use" && u.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 p = i.delta.text;
+                u.content.at(-1).text += p, e.stream({ text: p });
+              } else i.delta.type === "input_json_delta" && (u.content.at(-1).input += i.delta.partial_json);
+            else if (i.type === "content_block_stop") {
+              const p = u.content.at(-1);
+              p.input != null && (p.input = p.input ? $(p.input, {}) : {});
+            } else if (i.type === "message_stop")
               break;
           }
         }
-        const u = m.content.filter((s) => s.type === "tool_use");
-        if (u.length && !r.signal.aborted) {
-          i.push({ role: "assistant", content: m.content });
-          const s = await Promise.all(u.map(async (c) => {
-            const p = n.find(z("name", c.name));
-            if (e.stream && e.stream({ tool: c.name }), !p) return { tool_use_id: c.id, is_error: !0, content: "Tool not found" };
+        const m = u.content.filter((i) => i.type === "tool_use");
+        if (m.length && !t.signal.aborted) {
+          n.push({ role: "assistant", content: u.content });
+          const i = await Promise.all(m.map(async (p) => {
+            const d = s.find(U("name", p.name));
+            if (e.stream && e.stream({ tool: p.name }), !d) return { tool_use_id: p.id, is_error: !0, content: "Tool not found" };
             try {
-              const d = await p.fn(c.input, e?.stream, this.ai);
-              return { type: "tool_result", tool_use_id: c.id, content: _(d) };
-            } catch (d) {
-              return { type: "tool_result", tool_use_id: c.id, is_error: !0, content: d?.message || d?.toString() || "Unknown" };
+              const c = await d.fn(p.input, e?.stream, this.ai);
+              return { type: "tool_result", tool_use_id: p.id, content: typeof c == "object" ? T(c) : c };
+            } catch (c) {
+              return { type: "tool_result", tool_use_id: p.id, is_error: !0, content: c?.message || c?.toString() || "Unknown" };
             }
           }));
-          i.push({ role: "user", content: s }), l.messages = i;
+          n.push({ role: "user", content: i }), o.messages = n;
         }
-      } while (!r.signal.aborted && m.content.some((u) => u.type === "tool_use"));
-      i.push({ role: "assistant", content: m.content.filter((u) => u.type == "text").map((u) => u.text).join(`
+      } while (!t.signal.aborted && u.content.some((m) => m.type === "tool_use"));
+      n.push({ role: "assistant", content: u.content.filter((m) => m.type == "text").map((m) => m.text).join(`
 
-`) }), i = this.toStandard(i), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...i), o(i.at(-1)?.content);
-    }), { abort: () => r.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 P extends W {
-  constructor(t, e, r, o) {
-    super(), this.ai = t, this.host = e, this.token = r, this.model = o, this.client = new B(C({
+class P extends L {
+  constructor(r, e, t, l) {
+    super(), this.ai = r, this.host = e, this.token = t, this.model = l, this.client = new G(J({
       baseURL: e,
-      apiKey: r || e ? "ignored" : void 0
+      apiKey: t || e ? "ignored" : void 0
     }));
   }
   client;
-  toStandard(t) {
-    for (let e = 0; e < t.length; e++) {
-      const r = t[e];
-      if (r.role === "assistant" && r.tool_calls) {
-        const o = r.tool_calls.map((i) => ({
+  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: i.id,
-          name: i.function.name,
-          args: S(i.function.arguments, {}),
-          timestamp: r.timestamp
+          id: n.id,
+          name: n.function.name,
+          args: $(n.function.arguments, {}),
+          timestamp: t.timestamp
         }));
-        t.splice(e, 1, ...o), e += o.length - 1;
-      } else if (r.role === "tool" && r.content) {
-        const o = t.find((i) => r.tool_call_id == i.id);
-        o && (r.content.includes('"error":') ? o.error = r.content : o.content = r.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, r) => {
-      if (r.role === "tool")
+  fromStandard(r) {
+    return r.reduce((e, t) => {
+      if (t.role === "tool")
         e.push({
           role: "assistant",
           content: null,
-          tool_calls: [{ id: r.id, type: "function", function: { name: r.name, arguments: JSON.stringify(r.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: r.id,
-          content: r.error || r.content
+          tool_call_id: t.id,
+          content: t.error || t.content
         });
       else {
-        const { timestamp: o, ...i } = r;
-        e.push(i);
+        const { timestamp: l, ...n } = t;
+        e.push(n);
       }
       return e;
     }, []);
   }
-  ask(t, e = {}) {
-    const r = new AbortController();
-    return Object.assign(new Promise(async (o, i) => {
+  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() }) : e.history[0].content = e.system);
-      let n = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
-      const l = e.tools || this.ai.options.llm?.tools || [], m = {
+      let s = this.fromStandard([...e.history || [], { role: "user", content: r, timestamp: Date.now() }]);
+      const o = e.tools || this.ai.options.llm?.tools || [], u = {
         model: e.model || this.model,
-        messages: n,
+        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: l.map((s) => ({
+        tools: o.map((i) => ({
           type: "function",
           function: {
-            name: s.name,
-            description: s.description,
+            name: i.name,
+            description: i.description,
             parameters: {
               type: "object",
-              properties: s.args ? R(s.args, (c, p) => ({ ...p, required: void 0 })) : {},
-              required: s.args ? Object.entries(s.args).filter((c) => c[1].required).map((c) => c[0]) : []
+              properties: i.args ? O(i.args, (p, d) => ({ ...d, required: void 0 })) : {},
+              required: i.args ? Object.entries(i.args).filter((p) => p[1].required).map((p) => p[0]) : []
             }
           }
         }))
       };
-      let a, u = !0;
+      let a, m = !0;
       do {
-        if (a = await this.client.chat.completions.create(m).catch((c) => {
-          throw c.message += `
+        if (a = await this.client.chat.completions.create(u).catch((p) => {
+          throw p.message += `
 
 Messages:
-${JSON.stringify(n, null, 2)}`, c;
+${JSON.stringify(s, null, 2)}`, p;
         }), e.stream) {
-          u ? u = !1 : e.stream({ text: `
+          m ? m = !1 : e.stream({ text: `
 
 ` }), a.choices = [{ message: { role: "assistant", content: "", tool_calls: [] } }];
-          for await (const c of a) {
-            if (r.signal.aborted) break;
-            if (c.choices[0].delta.content && (a.choices[0].message.content += c.choices[0].delta.content, e.stream({ text: c.choices[0].delta.content })), c.choices[0].delta.tool_calls)
-              for (const p of c.choices[0].delta.tool_calls) {
-                const d = a.choices[0].message.tool_calls.find((f) => f.index === p.index);
-                d ? (p.id && (d.id = p.id), p.type && (d.type = p.type), p.function && (d.function || (d.function = {}), p.function.name && (d.function.name = p.function.name), p.function.arguments && (d.function.arguments = (d.function.arguments || "") + p.function.arguments))) : a.choices[0].message.tool_calls.push({
-                  index: p.index,
-                  id: p.id || "",
-                  type: p.type || "function",
+          for await (const p of a) {
+            if (t.signal.aborted) break;
+            if (p.choices[0].delta.content && (a.choices[0].message.content += p.choices[0].delta.content, e.stream({ text: p.choices[0].delta.content })), p.choices[0].delta.tool_calls)
+              for (const d of p.choices[0].delta.tool_calls) {
+                const c = a.choices[0].message.tool_calls.find((f) => f.index === d.index);
+                c ? (d.id && (c.id = d.id), d.type && (c.type = d.type), d.function && (c.function || (c.function = {}), d.function.name && (c.function.name = d.function.name), d.function.arguments && (c.function.arguments = (c.function.arguments || "") + d.function.arguments))) : a.choices[0].message.tool_calls.push({
+                  index: d.index,
+                  id: d.id || "",
+                  type: d.type || "function",
                   function: {
-                    name: p.function?.name || "",
-                    arguments: p.function?.arguments || ""
+                    name: d.function?.name || "",
+                    arguments: d.function?.arguments || ""
                   }
                 });
               }
           }
         }
-        const s = a.choices[0].message.tool_calls || [];
-        if (s.length && !r.signal.aborted) {
-          n.push(a.choices[0].message);
-          const c = await Promise.all(s.map(async (p) => {
-            const d = l?.find(z("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 p = await Promise.all(i.map(async (d) => {
+            const c = o?.find(U("name", d.function.name));
+            if (e.stream && e.stream({ tool: d.function.name }), !c) return { role: "tool", tool_call_id: d.id, content: '{"error": "Tool not found"}' };
             try {
-              const f = S(p.function.arguments, {}), g = await d.fn(f, e.stream, this.ai);
-              return { role: "tool", tool_call_id: p.id, content: _(g) };
+              const f = $(d.function.arguments, {}), g = await c.fn(f, e.stream, this.ai);
+              return { role: "tool", tool_call_id: d.id, content: typeof g == "object" ? T(g) : g };
             } catch (f) {
-              return { role: "tool", tool_call_id: p.id, content: _({ error: f?.message || f?.toString() || "Unknown" }) };
+              return { role: "tool", tool_call_id: d.id, content: T({ error: f?.message || f?.toString() || "Unknown" }) };
             }
           }));
-          n.push(...c), m.messages = n;
+          s.push(...p), u.messages = s;
         }
-      } while (!r.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);
-    }), { abort: () => r.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 ee {
-  constructor(t) {
-    this.ai = t, t.options.llm?.models && Object.entries(t.options.llm.models).forEach(([e, r]) => {
-      this.defaultModel || (this.defaultModel = e), r.proto == "anthropic" ? this.models[e] = new X(this.ai, r.token, e) : r.proto == "ollama" ? this.models[e] = new P(this.ai, r.host, "not-needed", e) : r.proto == "openai" && (this.models[e] = new P(this.ai, r.host || null, r.token, e));
+class re {
+  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 te(this.ai, t.token, e) : t.proto == "ollama" ? this.models[e] = new P(this.ai, t.host, "not-needed", e) : t.proto == "openai" && (this.models[e] = new P(this.ai, t.host || null, t.token, e));
     });
   }
   defaultModel;
@@ -259,7 +259,7 @@ class ee {
    * @param {LLMRequest} options Configuration options and chat history
    * @returns {{abort: () => void, response: Promise<string>}} Function to abort response and chat history
    */
-  ask(t, e = {}) {
+  ask(r, e = {}) {
     e = {
       system: "",
       temperature: 0.8,
@@ -268,29 +268,29 @@ class ee {
       history: [],
       ...e
     };
-    const r = e.model || this.defaultModel;
-    if (!this.models[r]) throw new Error(`Model does not exist: ${r}`);
-    let o = () => {
+    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 (i) => {
+    return Object.assign(new Promise(async (n) => {
       if (e.history || (e.history = []), e.memory) {
-        const l = async (a, u, s = 10) => {
-          const [c, p] = await Promise.all([
-            u ? this.embedding(u) : Promise.resolve(null),
+        const o = async (a, m, i = 10) => {
+          const [p, d] = await Promise.all([
+            m ? this.embedding(m) : Promise.resolve(null),
             a ? this.embedding(a) : Promise.resolve(null)
           ]);
-          return (e.memory || []).map((d) => {
-            const f = (c ? this.cosineSimilarity(d.embeddings[0], c[0].embedding) : 0) + (p ? this.cosineSimilarity(d.embeddings[1], p[0].embedding) : 0);
-            return { ...d, score: f };
-          }).toSorted((d, f) => d.score - f.score).slice(0, s).map((d) => `- ${d.owner}: ${d.fact}`).join(`
+          return (e.memory || []).map((c) => {
+            const f = (p ? this.cosineSimilarity(c.embeddings[0], p[0].embedding) : 0) + (d ? this.cosineSimilarity(c.embeddings[1], d[0].embedding) : 0);
+            return { ...c, score: f };
+          }).toSorted((c, f) => c.score - f.score).slice(0, i).map((c) => `- ${c.owner}: ${c.fact}`).join(`
 `);
         };
         e.system += `
 You have RAG memory and will be given the top_k closest memories regarding the users query. Save anything new you have learned worth remembering from the user message using the remember tool and feel free to recall memories manually.
 `;
-        const m = await l(t);
-        m.length && e.history.push({ role: "tool", name: "recall", id: "auto_recall_" + Math.random().toString(), args: {}, content: `Things I remembered:
-${m}` }), e.tools = [{
+        const u = await o(r);
+        u.length && e.history.push({ role: "tool", name: "recall", id: "auto_recall_" + Math.random().toString(), args: {}, content: `Things I remembered:
+${u}` }), e.tools = [{
           name: "recall",
           description: "Recall the closest memories you have regarding a query using RAG",
           args: {
@@ -300,7 +300,7 @@ ${m}` }), e.tools = [{
           },
           fn: (a) => {
             if (!a.subject && !a.query) throw new Error("Either a subject or query argument is required");
-            return l(a.query, a.subject, a.topK);
+            return o(a.query, a.subject, a.topK);
           }
         }, {
           name: "remember",
@@ -311,29 +311,29 @@ ${m}` }), e.tools = [{
           },
           fn: async (a) => {
             if (!e.memory) return;
-            const u = await Promise.all([
+            const m = await Promise.all([
               this.embedding(a.owner),
               this.embedding(`${a.owner}: ${a.fact}`)
-            ]), s = { owner: a.owner, fact: a.fact, embeddings: [u[0][0].embedding, u[1][0].embedding] };
-            return e.memory.splice(0, e.memory.length, ...e.memory.filter((c) => !(this.cosineSimilarity(s.embeddings[0], c.embeddings[0]) >= 0.9 && this.cosineSimilarity(s.embeddings[1], c.embeddings[1]) >= 0.8)), s), "Remembered!";
+            ]), i = { owner: a.owner, fact: a.fact, embeddings: [m[0][0].embedding, m[1][0].embedding] };
+            return e.memory.splice(0, e.memory.length, ...e.memory.filter((p) => !(this.cosineSimilarity(i.embeddings[0], p.embeddings[0]) >= 0.9 && this.cosineSimilarity(i.embeddings[1], p.embeddings[1]) >= 0.8)), i), "Remembered!";
           }
         }, ...e.tools || []];
       }
-      const n = await this.models[r].ask(t, e);
-      if (e.memory && e.history.splice(0, e.history.length, ...e.history.filter((l) => l.role != "tool" || l.name != "recall" && l.name != "remember")), e.compress) {
-        const l = await this.ai.language.compressHistory(e.history, e.compress.max, e.compress.min, e);
-        e.history.splice(0, e.history.length, ...l);
+      const s = await this.models[t].ask(r, e);
+      if (e.memory && e.history.splice(0, e.history.length, ...e.history.filter((o) => o.role != "tool" || o.name != "recall" && o.name != "remember")), e.compress) {
+        const o = await this.ai.language.compressHistory(e.history, e.compress.max, e.compress.min, e);
+        e.history.splice(0, e.history.length, ...o);
       }
-      return i(n);
-    }), { abort: o });
+      return n(s);
+    }), { abort: l });
   }
-  async code(t, e) {
-    const r = await this.ask(t, { ...e, system: [
+  async code(r, e) {
+    const t = await this.ask(r, { ...e, system: [
       e?.system,
       "Return your response in a code block"
-    ].filter((i) => !!i).join(`
-`) }), o = /```(?:.+)?\s*([\s\S]*?)```/.exec(r);
-    return o ? o[1].trim() : null;
+    ].filter((n) => !!n).join(`
+`) }), l = /```(?:.+)?\s*([\s\S]*?)```/.exec(t);
+    return l ? l[1].trim() : null;
   }
   /**
    * Compress chat history to reduce context size
@@ -343,17 +343,17 @@ ${m}` }), e.tools = [{
    * @param {LLMRequest} options LLM options
    * @returns {Promise<LLMMessage[]>} New chat history will summary at index 0
    */
-  async compressHistory(t, e, r, o) {
-    if (this.estimateTokens(t) < e) return t;
-    let i = 0, n = 0;
-    for (let p of t.toReversed())
-      if (n += this.estimateTokens(p.content), n < r) i++;
+  async compressHistory(r, e, t, l) {
+    if (this.estimateTokens(r) < e) return r;
+    let n = 0, s = 0;
+    for (let d of r.toReversed())
+      if (s += this.estimateTokens(d.content), s < t) n++;
       else break;
-    if (t.length <= i) return t;
-    const l = t[0].role == "system" ? t[0] : null, m = i == 0 ? [] : t.slice(-i), a = (i == 0 ? t : t.slice(0, -i)).filter((p) => p.role === "assistant" || p.role === "user"), u = await this.summarize(a.map((p) => `[${p.role}]: ${p.content}`).join(`
+    if (r.length <= n) return r;
+    const o = r[0].role == "system" ? r[0] : null, u = n == 0 ? [] : r.slice(-n), a = (n == 0 ? r : r.slice(0, -n)).filter((d) => d.role === "assistant" || d.role === "user"), m = await this.summarize(a.map((d) => `[${d.role}]: ${d.content}`).join(`
 
-`), 500, o), s = Date.now(), c = [{ role: "tool", name: "summary", id: "summary_" + s, args: {}, content: `Conversation Summary: ${u?.summary}`, timestamp: s }, ...m];
-    return l && c.splice(0, 0, l), c;
+`), 500, l), i = Date.now(), p = [{ role: "tool", name: "summary", id: "summary_" + i, args: {}, content: `Conversation Summary: ${m?.summary}`, timestamp: i }, ...u];
+    return o && p.splice(0, 0, o), p;
   }
   /**
    * Compare the difference between embeddings (calculates the angle between two vectors)
@@ -361,13 +361,13 @@ ${m}` }), e.tools = [{
    * @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 r = 0, o = 0, i = 0;
-    for (let l = 0; l < t.length; l++)
-      r += t[l] * e[l], o += t[l] * t[l], i += e[l] * e[l];
-    const n = Math.sqrt(o) * Math.sqrt(i);
-    return n === 0 ? 0 : r / n;
+  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
@@ -376,26 +376,26 @@ ${m}` }), e.tools = [{
    * @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, r = 50) {
-    const o = (m, a = "") => m ? Object.entries(m).flatMap(([u, s]) => {
-      const c = a ? `${a}${isNaN(+u) ? `.${u}` : `[${u}]`}` : u;
-      return typeof s == "object" && !Array.isArray(s) ? o(s, c) : `${c}: ${Array.isArray(s) ? s.join(", ") : s}`;
-    }) : [], n = (typeof t == "object" ? o(t) : t.toString().split(`
-`)).flatMap((m) => [...m.split(/\s+/).filter(Boolean), `
-`]), l = [];
-    for (let m = 0; m < n.length; ) {
-      let a = "", u = m;
-      for (; u < n.length; ) {
-        const c = a + (a ? " " : "") + n[u];
-        if (this.estimateTokens(c.replace(/\s*\n\s*/g, `
+  chunk(r, e = 500, t = 50) {
+    const l = (u, a = "") => u ? Object.entries(u).flatMap(([m, i]) => {
+      const p = a ? `${a}${isNaN(+m) ? `.${m}` : `[${m}]`}` : m;
+      return typeof i == "object" && !Array.isArray(i) ? l(i, p) : `${p}: ${Array.isArray(i) ? i.join(", ") : i}`;
+    }) : [], s = (typeof r == "object" ? l(r) : r.toString().split(`
+`)).flatMap((u) => [...u.split(/\s+/).filter(Boolean), `
+`]), o = [];
+    for (let u = 0; u < s.length; ) {
+      let a = "", m = u;
+      for (; m < s.length; ) {
+        const p = a + (a ? " " : "") + s[m];
+        if (this.estimateTokens(p.replace(/\s*\n\s*/g, `
 `)) > e && a) break;
-        a = c, u++;
+        a = p, m++;
       }
-      const s = a.replace(/\s*\n\s*/g, `
+      const i = a.replace(/\s*\n\s*/g, `
 `).trim();
-      s && l.push(s), m = Math.max(u - r, u === m ? m + 1 : u);
+      i && o.push(i), u = Math.max(m - t, m === u ? u + 1 : m);
     }
-    return l;
+    return o;
   }
   /**
    * Create a vector representation of a string
@@ -403,48 +403,48 @@ ${m}` }), e.tools = [{
    * @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
    */
-  embedding(t, e = {}) {
-    let { maxTokens: r = 500, overlapTokens: o = 50 } = e, i = !1;
-    const n = () => {
-      i = !0;
-    }, l = (a) => new Promise((u, s) => {
-      if (i) return s(new Error("Aborted"));
-      const c = [
-        G(K(D(import.meta.url)), "embedder.js"),
+  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 p = [
+        Y(V(K(import.meta.url)), "embedder.js"),
         this.ai.options.path,
         this.ai.options?.embedder || "bge-small-en-v1.5"
-      ], p = b("node", c, { stdio: ["pipe", "pipe", "ignore"] });
-      p.stdin.write(a), p.stdin.end();
-      let d = "";
-      p.stdout.on("data", (f) => d += f.toString()), p.on("close", (f) => {
-        if (i) return s(new Error("Aborted"));
+      ], d = k("node", p, { stdio: ["pipe", "pipe", "ignore"] });
+      d.stdin.write(a), d.stdin.end();
+      let c = "";
+      d.stdout.on("data", (f) => c += f.toString()), d.on("close", (f) => {
+        if (n) return i(new Error("Aborted"));
         if (f === 0)
           try {
-            const g = JSON.parse(d);
-            u(g.embedding);
+            const g = JSON.parse(c);
+            m(g.embedding);
           } catch {
-            s(new Error("Failed to parse embedding output"));
+            i(new Error("Failed to parse embedding output"));
           }
         else
-          s(new Error(`Embedder process exited with code ${f}`));
-      }), p.on("error", s);
-    }), m = (async () => {
-      const a = this.chunk(t, r, o), u = [];
-      for (let s = 0; s < a.length && !i; s++) {
-        const c = a[s], p = await l(c);
-        u.push({ index: s, embedding: p, text: c, tokens: this.estimateTokens(c) });
+          i(new Error(`Embedder process exited with code ${f}`));
+      }), d.on("error", i);
+    }), u = (async () => {
+      const a = this.chunk(r, t, l), m = [];
+      for (let i = 0; i < a.length && !n; i++) {
+        const p = a[i], d = await o(p);
+        m.push({ index: i, embedding: d, text: p, tokens: this.estimateTokens(p) });
       }
-      return u;
+      return m;
     })();
-    return Object.assign(m, { abort: n });
+    return Object.assign(u, { 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);
   }
   /**
@@ -453,10 +453,10 @@ ${m}` }), e.tools = [{
    * @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 r = (n, l = 10) => n.toLowerCase().split("").map((m, a) => m.charCodeAt(0) * (a + 1) % l / l).slice(0, l), o = r(t), i = e.map((n) => r(n)).map((n) => this.cosineSimilarity(o, n));
-    return { avg: i.reduce((n, l) => n + l, 0) / i.length, max: Math.max(...i), similarities: i };
+    const t = (s, o = 10) => s.toLowerCase().split("").map((u, a) => u.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
@@ -465,38 +465,38 @@ ${m}` }), e.tools = [{
    * @param {LLMRequest} options Configuration options and chat history
    * @returns {Promise<{} | {} | RegExpExecArray | null>}
    */
-  async json(t, e, r) {
-    let o = `Your job is to convert input to JSON using tool calls. Call the \`submit\` tool at least once with JSON matching this schema:
+  async json(r, e, t) {
+    let l = `Your job is to convert input to JSON using tool calls. Call the \`submit\` tool at least once with JSON matching this schema:
 \`\`\`json
 ${e}
 \`\`\`
 
 Responses are ignored`;
-    return r?.system && (o += `
+    return t?.system && (l += `
 
-` + r.system), new Promise(async (i, n) => {
-      let l = !1;
-      const m = await this.ask(t, {
+` + t.system), new Promise(async (n, s) => {
+      let o = !1;
+      const u = await this.ask(r, {
         temperature: 0.3,
-        ...r,
-        system: o,
+        ...t,
+        system: l,
         tools: [{
           name: "submit",
           description: "Submit JSON",
           args: { json: { type: "string", description: "Javascript parsable JSON string", required: !0 } },
           fn: (a) => {
             try {
-              const u = JSON.parse(a.json);
-              i(u), l = !0;
+              const m = JSON.parse(a.json);
+              n(m), o = !0;
             } catch {
               return "Invalid JSON";
             }
             return "Saved";
           }
-        }, ...r?.tools || []]
+        }, ...t?.tools || []]
       });
-      l || n(`AI failed to create JSON:
-${m}`);
+      o || s(`AI failed to create JSON:
+${u}`);
     });
   }
   /**
@@ -506,38 +506,38 @@ ${m}`);
    * @param options LLM request options
    * @returns {Promise<string>} Summary
    */
-  async summarize(t, e = 500, r) {
-    let o = `Your job is to summarize the users message using tool calls. Call the \`submit\` tool at least once with the shortest summary possible that's <= ${e} words. The tool call will respond with the token count. Responses are ignored`;
-    return r?.system && (o += `
+  async summarize(r, e = 500, t) {
+    let l = `Your job is to summarize the users message using tool calls. Call the \`submit\` tool at least once with the shortest summary possible that's <= ${e} words. The tool call will respond with the token count. Responses are ignored`;
+    return t?.system && (l += `
 
-` + r.system), new Promise(async (i, n) => {
-      let l = !1;
-      const m = await this.ask(t, {
+` + t.system), new Promise(async (n, s) => {
+      let o = !1;
+      const u = await this.ask(r, {
         temperature: 0.3,
-        ...r,
-        system: o,
+        ...t,
+        system: l,
         tools: [{
           name: "submit",
           description: "Submit summary",
           args: { summary: { type: "string", description: "Text summarization", required: !0 } },
-          fn: (a) => a.summary ? a.summary.split(" ").length > e ? `Too long: ${e} words` : (l = !0, i(a.summary || null), `Saved: ${e} words`) : "No summary provided"
-        }, ...r?.tools || []]
+          fn: (a) => a.summary ? a.summary.split(" ").length > e ? `Too long: ${e} words` : (o = !0, n(a.summary || null), `Saved: ${e} words`) : "No summary provided"
+        }, ...t?.tools || []]
       });
-      l || n(`AI failed to create summary:
-${m}`);
+      o || s(`AI failed to create summary:
+${u}`);
     });
   }
 }
-class te {
-  constructor(t) {
-    this.ai = t, t.options.whisper && (this.whisperModel = t.options.asr || "ggml-base.en.bin", this.downloadAsrModel()), this.pyannote = `
+class ne {
+  constructor(r) {
+    this.ai = r, r.options.whisper && (this.whisperModel = r.options.asr || "ggml-base.en.bin", this.downloadAsrModel()), this.pyannote = `
 import sys
 import json
 import os
 from pyannote.audio import Pipeline
 
-os.environ['TORCH_HOME'] = r"${t.options.path}"
-pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization-3.1", token="${t.options.hfToken}")
+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 = []
@@ -550,22 +550,22 @@ print(json.dumps(segments))
   downloads = {};
   pyannote;
   whisperModel;
-  async addPunctuation(t, e, r = 150) {
-    const o = (n) => {
-      if (n = n.toLowerCase().replace(/[^a-z]/g, ""), n.length <= 3) return 1;
-      const l = n.match(/[aeiouy]+/g);
-      let m = l ? l.length : 1;
-      return n.endsWith("e") && m--, Math.max(1, m);
+  async addPunctuation(r, e, t = 150) {
+    const l = (s) => {
+      if (s = s.toLowerCase().replace(/[^a-z]/g, ""), s.length <= 3) return 1;
+      const o = s.match(/[aeiouy]+/g);
+      let u = o ? o.length : 1;
+      return s.endsWith("e") && u--, Math.max(1, u);
     };
-    let i = "";
-    return t.transcription.filter((n, l) => {
-      let m = !1;
-      const a = t.transcription[l - 1], u = t.transcription[l + 1];
-      return !n.text && u ? (u.offsets.from = n.offsets.from, u.timestamps.from = n.offsets.from) : n.text && n.text[0] != " " && a && (a.offsets.to = n.offsets.to, a.timestamps.to = n.timestamps.to, a.text += n.text, m = !0), !!n.text && !m;
-    }).forEach((n) => {
-      const l = /^[A-Z]/.test(n.text.trim()), m = n.offsets.to - n.offsets.from, u = o(n.text.trim()) * r;
-      l && m > u * 2 && n.text[0] == " " && (i += "."), i += n.text;
-    }), e ? this.ai.language.ask(i, {
+    let n = "";
+    return r.transcription.filter((s, o) => {
+      let u = !1;
+      const a = r.transcription[o - 1], m = r.transcription[o + 1];
+      return !s.text && m ? (m.offsets.from = s.offsets.from, m.timestamps.from = s.offsets.from) : s.text && s.text[0] != " " && a && (a.offsets.to = s.offsets.to, a.timestamps.to = s.timestamps.to, a.text += s.text, u = !0), !!s.text && !u;
+    }).forEach((s) => {
+      const o = /^[A-Z]/.test(s.text.trim()), u = s.offsets.to - s.offsets.from, m = l(s.text.trim()) * t;
+      o && u > m * 2 && s.text[0] == " " && (n += "."), n += s.text;
+    }), e ? this.ai.language.ask(n, {
       system: "Remove any misplaced punctuation from the following ASR transcript using the replace tool. Avoid modifying words unless there is an obvious typo",
       temperature: 0.1,
       tools: [{
@@ -575,162 +575,162 @@ print(json.dumps(segments))
           find: { type: "string", description: "Text to find", required: !0 },
           replace: { type: "string", description: "Text to replace", required: !0 }
         },
-        fn: (n) => i = i.replace(n.find, n.replace)
+        fn: (s) => n = n.replace(s.find, s.replace)
       }]
-    }).then(() => i) : i.trim();
+    }).then(() => n) : n.trim();
   }
-  async diarizeTranscript(t, e, r) {
-    const o = /* @__PURE__ */ new Map();
-    let i = 0;
-    e.forEach((d) => {
-      o.has(d.speaker) || o.set(d.speaker, ++i);
+  async diarizeTranscript(r, e, t) {
+    const l = /* @__PURE__ */ new Map();
+    let n = 0;
+    e.forEach((c) => {
+      l.has(c.speaker) || l.set(c.speaker, ++n);
     });
-    const n = await this.addPunctuation(t, r), l = n.match(/[^.!?]+[.!?]+/g) || [n], m = t.transcription.filter((d) => d.text.trim()), a = l.map((d) => {
-      if (d = d.trim(), !d) return null;
-      const f = d.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/), g = /* @__PURE__ */ new Map();
-      f.forEach((x) => {
-        const k = m.find((y) => x === y.text.trim().toLowerCase().replace(/[^\w]/g, ""));
-        if (!k) return;
-        const v = k.offsets.from / 1e3, E = e.find((y) => v >= y.start && v <= y.end);
+    const s = await this.addPunctuation(r, t), o = s.match(/[^.!?]+[.!?]+/g) || [s], u = r.transcription.filter((c) => c.text.trim()), a = o.map((c) => {
+      if (c = c.trim(), !c) return null;
+      const f = c.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/), g = /* @__PURE__ */ new Map();
+      f.forEach((y) => {
+        const _ = u.find((w) => y === w.text.trim().toLowerCase().replace(/[^\w]/g, ""));
+        if (!_) return;
+        const v = _.offsets.from / 1e3, E = e.find((w) => v >= w.start && v <= w.end);
         if (E) {
-          const y = o.get(E.speaker);
-          g.set(y, (g.get(y) || 0) + 1);
+          const w = l.get(E.speaker);
+          g.set(w, (g.get(w) || 0) + 1);
         }
       });
-      let j = 1, $ = 0;
-      return g.forEach((x, k) => {
-        x > $ && ($ = x, j = k);
-      }), { speaker: j, text: d };
-    }).filter((d) => d !== null), u = [];
-    a.forEach((d) => {
-      const f = u[u.length - 1];
-      f && f.speaker === d.speaker ? f.text += " " + d.text : u.push({ ...d });
+      let b = 1, S = 0;
+      return g.forEach((y, _) => {
+        y > S && (S = y, b = _);
+      }), { speaker: b, text: c };
+    }).filter((c) => c !== null), m = [];
+    a.forEach((c) => {
+      const f = m[m.length - 1];
+      f && f.speaker === c.speaker ? f.text += " " + c.text : m.push({ ...c });
     });
-    let s = u.map((d) => `[Speaker ${d.speaker}]: ${d.text}`).join(`
+    let i = m.map((c) => `[Speaker ${c.speaker}]: ${c.text}`).join(`
 `).trim();
-    if (!r) return s;
-    let c = this.ai.language.chunk(s, 500, 0);
-    c.length > 4 && (c = [...c.slice(0, 3), c.at(-1)]);
-    const p = await this.ai.language.json(c.join(`
+    if (!t) return i;
+    let p = this.ai.language.chunk(i, 500, 0);
+    p.length > 4 && (p = [...p.slice(0, 3), p.at(-1)]);
+    const d = await this.ai.language.json(p.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(p).forEach(([d, f]) => s = s.replaceAll(`[Speaker ${d}]`, `[${f}]`)), s;
+    return Object.entries(d).forEach(([c, f]) => i = i.replaceAll(`[Speaker ${c}]`, `[${f}]`)), i;
   }
-  runAsr(t, e = {}) {
-    let r;
-    const o = new Promise((i, n) => {
-      this.downloadAsrModel(e.model).then((l) => {
+  runAsr(r, e = {}) {
+    let t;
+    const l = new Promise((n, s) => {
+      this.downloadAsrModel(e.model).then((o) => {
         if (e.diarization) {
-          let m = q.join(q.dirname(t), "transcript");
-          r = b(
+          let u = q.join(q.dirname(r), "transcript");
+          t = k(
             this.ai.options.whisper,
-            ["-m", l, "-f", t, "-np", "-ml", "1", "-oj", "-of", m],
+            ["-m", o, "-f", r, "-np", "-ml", "1", "-oj", "-of", u],
             { stdio: ["ignore", "ignore", "pipe"] }
-          ), r.on("error", (a) => n(a)), r.on("close", async (a) => {
+          ), t.on("error", (a) => s(a)), t.on("close", async (a) => {
             if (a === 0) {
-              m = await w.readFile(m + ".json", "utf-8"), w.rm(m + ".json").catch(() => {
+              u = await x.readFile(u + ".json", "utf-8"), x.rm(u + ".json").catch(() => {
               });
               try {
-                i(JSON.parse(m));
+                n(JSON.parse(u));
               } catch {
-                n(new Error("Failed to parse whisper JSON"));
+                s(new Error("Failed to parse whisper JSON"));
               }
             } else
-              n(new Error(`Exit code ${a}`));
+              s(new Error(`Exit code ${a}`));
           });
         } else {
-          let m = "";
-          r = b(this.ai.options.whisper, ["-m", l, "-f", t, "-np", "-nt"]), r.on("error", (a) => n(a)), r.stdout.on("data", (a) => m += a.toString()), r.on("close", async (a) => {
-            a === 0 ? i(m.trim() || null) : n(new Error(`Exit code ${a}`));
+          let u = "";
+          t = k(this.ai.options.whisper, ["-m", o, "-f", r, "-np", "-nt"]), t.on("error", (a) => s(a)), t.stdout.on("data", (a) => u += a.toString()), t.on("close", async (a) => {
+            a === 0 ? n(u.trim() || null) : s(new Error(`Exit code ${a}`));
           });
         }
       });
     });
-    return Object.assign(o, { abort: () => r?.kill("SIGTERM") });
+    return Object.assign(l, { abort: () => t?.kill("SIGTERM") });
   }
-  runDiarization(t) {
-    let e = !1, r = () => {
+  runDiarization(r) {
+    let e = !1, t = () => {
       e = !0;
     };
-    const o = (n) => new Promise((l) => {
-      const m = b(n, ["-W", "ignore", "-c", "import pyannote.audio"]);
-      m.on("close", (a) => l(a === 0)), m.on("error", () => l(!1));
-    }), i = Promise.all([
-      o("python"),
-      o("python3")
-    ]).then((async ([n, l]) => {
+    const l = (s) => new Promise((o) => {
+      const u = k(s, ["-W", "ignore", "-c", "import pyannote.audio"]);
+      u.on("close", (a) => o(a === 0)), u.on("error", () => o(!1));
+    }), n = Promise.all([
+      l("python"),
+      l("python3")
+    ]).then((async ([s, o]) => {
       if (e) return;
-      if (!n && !l) throw new Error("Pyannote is not installed: pip install pyannote.audio");
-      const m = l ? "python3" : "python";
-      return new Promise((a, u) => {
+      if (!s && !o) throw new Error("Pyannote is not installed: pip install pyannote.audio");
+      const u = o ? "python3" : "python";
+      return new Promise((a, m) => {
         if (e) return;
-        let s = "";
-        const c = b(m, ["-W", "ignore", "-c", this.pyannote, t]);
-        c.stdout.on("data", (p) => s += p.toString()), c.stderr.on("data", (p) => console.error(p.toString())), c.on("close", (p) => {
-          if (p === 0)
+        let i = "";
+        const p = k(u, ["-W", "ignore", "-c", this.pyannote, r]);
+        p.stdout.on("data", (d) => i += d.toString()), p.stderr.on("data", (d) => console.error(d.toString())), p.on("close", (d) => {
+          if (d === 0)
             try {
-              a(JSON.parse(s));
+              a(JSON.parse(i));
             } catch {
-              u(new Error("Failed to parse diarization output"));
+              m(new Error("Failed to parse diarization output"));
             }
           else
-            u(new Error(`Python process exited with code ${p}`));
-        }), c.on("error", u), r = () => c.kill("SIGTERM");
+            m(new Error(`Python process exited with code ${d}`));
+        }), p.on("error", m), t = () => p.kill("SIGTERM");
       });
     }));
-    return Object.assign(i, { abort: r });
+    return Object.assign(n, { abort: t });
   }
-  asr(t, e = {}) {
+  asr(r, e = {}) {
     if (!this.ai.options.whisper) throw new Error("Whisper not configured");
-    const r = A(V(A(L(), "audio-")), "converted.wav");
-    Y(`ffmpeg -i "${t}" -ar 16000 -ac 1 -f wav "${r}"`, { stdio: "ignore" });
-    const o = () => w.rm(M.dirname(r), { recursive: !0, force: !0 }).catch(() => {
+    const t = A(Q(A(W(), "audio-")), "converted.wav");
+    Z(`ffmpeg -i "${r}" -ar 16000 -ac 1 -f wav "${t}"`, { stdio: "ignore" });
+    const l = () => x.rm(M.dirname(t), { recursive: !0, force: !0 }).catch(() => {
     });
-    if (!e.diarization) return this.runAsr(r, { model: e.model });
-    const i = this.runAsr(r, { model: e.model, diarization: !0 }), n = this.runDiarization(r);
-    let l = !1, m = () => {
-      l = !0, i.abort(), n.abort(), o();
+    if (!e.diarization) return this.runAsr(t, { model: e.model });
+    const n = this.runAsr(t, { model: e.model, diarization: !0 }), s = this.runDiarization(t);
+    let o = !1, u = () => {
+      o = !0, n.abort(), s.abort(), l();
     };
-    const a = Promise.allSettled([i, n]).then(async ([u, s]) => {
-      if (u.status == "rejected") throw new Error(`Whisper.cpp timestamps:
-` + u.reason);
-      if (s.status == "rejected") throw new Error(`Pyannote:
-` + s.reason);
-      return l || !e.diarization ? u.value : this.diarizeTranscript(u.value, s.value, e.diarization == "llm");
-    }).finally(() => o());
-    return Object.assign(a, { abort: m });
-  }
-  async downloadAsrModel(t = this.whisperModel) {
+    const a = Promise.allSettled([n, s]).then(async ([m, i]) => {
+      if (m.status == "rejected") throw new Error(`Whisper.cpp timestamps:
+` + m.reason);
+      if (i.status == "rejected") throw new Error(`Pyannote:
+` + i.reason);
+      return o || !e.diarization ? m.value : this.diarizeTranscript(m.value, i.value, e.diarization == "llm");
+    }).finally(() => l());
+    return Object.assign(a, { abort: u });
+  }
+  async downloadAsrModel(r = this.whisperModel) {
     if (!this.ai.options.whisper) throw new Error("Whisper not configured");
-    t.endsWith(".bin") || (t += ".bin");
-    const e = M.join(this.ai.options.path, t);
-    return await w.stat(e).then(() => !0).catch(() => !1) ? e : this.downloads[t] ? this.downloads[t] : (this.downloads[t] = fetch(`https://huggingface.co/ggerganov/whisper.cpp/resolve/main/${t}`).then((r) => r.arrayBuffer()).then((r) => Buffer.from(r)).then(async (r) => (await w.writeFile(e, r), delete this.downloads[t], e)), this.downloads[t]);
+    r.endsWith(".bin") || (r += ".bin");
+    const e = M.join(this.ai.options.path, r);
+    return await x.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 x.writeFile(e, t), delete this.downloads[r], e)), this.downloads[r]);
   }
 }
-class re {
-  constructor(t) {
-    this.ai = t;
+class se {
+  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) {
+  ocr(r) {
     let e;
-    const r = new Promise(async (o) => {
-      e = await Z(this.ai.options.ocr || "eng", 2, { cachePath: this.ai.options.path });
-      const { data: i } = await e.recognize(t);
-      await e.terminate(), o(i.text.trim() || null);
+    const t = new Promise(async (l) => {
+      e = await X(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(r, { abort: () => e?.terminate() });
+    return Object.assign(t, { abort: () => e?.terminate() });
   }
 }
-class be {
-  constructor(t) {
-    this.options = t, t.path || (t.path = O.tmpdir()), process.env.TRANSFORMERS_CACHE = t.path, this.audio = new te(this), this.language = new ee(this), this.vision = new re(this);
+class ke {
+  constructor(r) {
+    this.options = r, r.path || (r.path = R.tmpdir()), process.env.TRANSFORMERS_CACHE = r.path, this.audio = new ne(this), this.language = new re(this), this.vision = new se(this);
   }
   /** Audio processing AI */
   audio;
@@ -739,45 +739,45 @@ class be {
   /** Vision processing AI */
   vision;
 }
-const ne = () => O.platform() == "win32" ? "cmd" : T`echo $SHELL`?.split("/").pop() || "bash", se = {
+const z = "Mozilla/5.0 (Windows NT 10.0; Win64; x64)", oe = () => R.platform() == "win32" ? "cmd" : j`echo $SHELL`?.split("/").pop() || "bash", ie = {
   name: "cli",
   description: "Use the command line interface, returns any output",
   args: { command: { type: "string", description: "Command to run", required: !0 } },
-  fn: (h) => T`${h.command}`
-}, xe = {
+  fn: (h) => j`${h.command}`
+}, Se = {
   name: "get_datetime",
   description: "Get local date / time",
   args: {},
   fn: async () => (/* @__PURE__ */ new Date()).toString()
-}, ke = {
+}, _e = {
   name: "get_datetime_utc",
   description: "Get current UTC date / time",
   args: {},
   fn: async () => (/* @__PURE__ */ new Date()).toUTCString()
-}, Se = {
+}, $e = {
   name: "exec",
   description: "Run code/scripts",
   args: {
-    language: { type: "string", description: `Execution language (CLI: ${ne()})`, enum: ["cli", "node", "python"], required: !0 },
+    language: { type: "string", description: `Execution language (CLI: ${oe()})`, 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.language) {
         case "cli":
-          return await se.fn({ command: h.code }, t, e);
+          return await ie.fn({ command: h.code }, r, e);
         case "node":
-          return await oe.fn({ code: h.code }, t, e);
+          return await ae.fn({ code: h.code }, r, e);
         case "python":
-          return await ie.fn({ code: h.code }, t, e);
+          return await ce.fn({ code: h.code }, r, e);
         default:
           throw new Error(`Unsupported language: ${h.language}`);
       }
-    } catch (r) {
-      return { error: r?.message || r.toString() };
+    } catch (t) {
+      return { error: t?.message || t.toString() };
     }
   }
-}, _e = {
+}, Te = {
   name: "fetch",
   description: "Make HTTP request to URL",
   args: {
@@ -786,100 +786,122 @@ const ne = () => O.platform() == "win32" ? "cmd" : T`echo $SHELL`?.split("/").po
     headers: { type: "object", description: "HTTP headers to send", default: {} },
     body: { type: "object", description: "HTTP body to send" }
   },
-  fn: (h) => new J({ url: h.url, headers: h.headers }).request({ method: h.method || "GET", body: h.body })
-}, oe = {
+  fn: (h) => new F({ url: h.url, headers: h.headers }).request({ method: h.method || "GET", body: h.body })
+}, ae = {
   name: "exec_javascript",
   description: "Execute commonjs javascript",
   args: {
     code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
   fn: async (h) => {
-    const t = I(null), e = await F({ console: t }, h.code, !0).catch((r) => t.output.error.push(r));
-    return { ...t.output, return: e, stdout: void 0, stderr: void 0 };
+    const r = B(null), e = await I({ console: r }, h.code, !0).catch((t) => r.output.error.push(t));
+    return { ...r.output, return: e, stdout: void 0, stderr: void 0 };
   }
-}, ie = {
+}, ce = {
   name: "exec_javascript",
   description: "Execute commonjs javascript",
   args: {
     code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
-  fn: async (h) => ({ result: T`python -c "${h.code}"` })
-}, Te = {
+  fn: async (h) => ({ result: j`python -c "${h.code}"` })
+}, je = {
   name: "read_webpage",
-  description: "Extract clean, structured content from a webpage or convert media/documents to accessible formats",
+  description: "Extract clean content from webpages, or convert media/documents to accessible formats",
   args: {
-    url: { type: "string", description: "URL to extract content from", required: !0 },
-    mimeRegex: { type: "string", description: 'Optional: Regex pattern to filter MIME types (e.g., "^image/", "text/", "application/pdf")' },
-    maxSize: { type: "number", description: "Optional: Max file size in bytes for binary content (default: 10MB)" }
+    url: { type: "string", description: "URL to read", required: !0 },
+    mimeRegex: { type: "string", description: 'Optional regex to filter MIME types (e.g., "^image/", "text/")' }
   },
   fn: async (h) => {
-    const e = await fetch(h.url, {
+    const t = await fetch(h.url, {
       headers: {
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+        "User-Agent": "AiTools-Webpage/1.0",
         Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
         "Accept-Language": "en-US,en;q=0.5"
       },
       redirect: "follow"
-    }).catch((s) => {
-      throw new Error(`Failed to fetch: ${s.message}`);
-    }), r = e.headers.get("content-type") || "", o = r.split(";")[0].trim().toLowerCase();
-    if (r.match(/charset=([^;]+)/)?.[1], h.mimeRegex && !new RegExp(h.mimeRegex, "i").test(o))
-      return { url: h.url, error: "MIME type rejected", mimeType: o, filter: h.mimeRegex };
-    if (o.startsWith("image/") || o.startsWith("audio/") || o.startsWith("video/")) {
-      const s = await e.arrayBuffer();
-      if (s.byteLength > 10485760)
-        return { url: h.url, type: "media", mimeType: o, error: "File too large", size: s.byteLength, maxSize: 10485760 };
-      const c = Buffer.from(s).toString("base64");
-      return { url: h.url, type: "media", mimeType: o, dataUrl: `data:${o};base64,${c}`, size: s.byteLength };
+    }).catch((c) => {
+      throw new Error(`Failed to fetch: ${c.message}`);
+    }), n = (t.headers.get("content-type") || "").split(";")[0].trim().toLowerCase();
+    if (h.mimeRegex && !new RegExp(h.mimeRegex, "i").test(n))
+      return `❌ MIME type rejected: ${n} (filter: ${h.mimeRegex})`;
+    if (n.match(/^(image|audio|video)\//)) {
+      const c = await t.arrayBuffer();
+      if (c.byteLength > 10485760)
+        return `❌ File too large: ${(c.byteLength / 1024 / 1024).toFixed(1)}MB (max 10MB)
+Type: ${n}`;
+      const f = Buffer.from(c).toString("base64");
+      return `## Media File
+**Type:** ${n}
+**Size:** ${(c.byteLength / 1024).toFixed(1)}KB
+**Data URL:** \`data:${n};base64,${f.slice(0, 100)}...\``;
     }
-    if (o.match(/^(text\/(plain|csv|xml)|application\/(json|xml|csv|x-yaml))/) || h.url.match(/\.(txt|json|xml|csv|yaml|yml|md)$/i)) {
-      const s = await e.text();
-      return { url: h.url, type: "text", mimeType: o, content: s.slice(0, 1e5) };
+    if (n.match(/^text\/(plain|csv|xml)/) || h.url.match(/\.(txt|csv|xml|md|yaml|yml)$/i)) {
+      const c = await t.text(), f = c.length > 5e4 ? c.slice(0, 5e4) : c;
+      return `## Text File
+**Type:** ${n}
+**URL:** ${h.url}
+
+${f}`;
     }
-    if (o === "application/pdf" || o.startsWith("application/") && !o.includes("html")) {
-      const s = await e.arrayBuffer();
-      if (s.byteLength > 10485760)
-        return { url: h.url, type: "binary", mimeType: o, error: "File too large", size: s.byteLength, maxSize: 10485760 };
-      const c = Buffer.from(s).toString("base64");
-      return { url: h.url, type: "binary", mimeType: o, dataUrl: `data:${o};base64,${c}`, size: s.byteLength };
+    if (n.match(/application\/(json|xml|csv)/)) {
+      const c = await t.text(), f = c.length > 5e4 ? c.slice(0, 5e4) : c;
+      return `## Structured Data
+**Type:** ${n}
+**URL:** ${h.url}
+
+\`\`\`
+${f}
+\`\`\``;
     }
-    const i = await e.text(), n = Q.load(i);
-    n('script, style, nav, footer, header, aside, iframe, noscript, svg, [role="navigation"], [role="banner"], [role="complementary"], .ad, .ads, .advertisement, .cookie, .popup, .modal, .sidebar, .related, .comments, .social-share').remove();
-    const l = {
-      title: n('meta[property="og:title"]').attr("content") || n("title").text() || "",
-      description: n('meta[name="description"]').attr("content") || n('meta[property="og:description"]').attr("content") || "",
-      author: n('meta[name="author"]').attr("content") || "",
-      published: n('meta[property="article:published_time"]').attr("content") || n("time").attr("datetime") || "",
-      image: n('meta[property="og:image"]').attr("content") || ""
-    };
-    let m = "";
-    const a = ["article", "main", '[role="main"]', ".content", ".post-content", ".entry-content", ".article-content", "body"];
-    for (const s of a) {
-      const c = n(s).first();
-      if (c.length && c.text().trim().length > 200) {
-        m = c.text();
-        break;
+    if (n === "application/pdf" || n.startsWith("application/") && !n.includes("html")) {
+      const c = await t.arrayBuffer();
+      if (c.byteLength > 10485760)
+        return `❌ File too large: ${(c.byteLength / 1024 / 1024).toFixed(1)}MB (max 10MB)
+Type: ${n}`;
+      const f = Buffer.from(c).toString("base64");
+      return `## Binary File
+**Type:** ${n}
+**Size:** ${(c.byteLength / 1024).toFixed(1)}KB
+**Data URL:** \`data:${n};base64,${f.slice(0, 100)}...\``;
+    }
+    const s = await t.text(), o = ee.load(s);
+    o("script, style, nav, footer, header, aside, iframe, noscript, svg").remove(), o('[role="navigation"], [role="banner"], [role="complementary"]').remove(), o('[aria-hidden="true"], [hidden], .visually-hidden, .sr-only, .screen-reader-text').remove(), o(".ad, .ads, .advertisement, .cookie, .popup, .modal, .sidebar, .related, .comments, .social-share").remove(), o('button, [class*="share"], [class*="follow"], [class*="social"]').remove();
+    const u = o('meta[property="og:title"]').attr("content") || o("title").text().trim() || "", a = o('meta[name="description"]').attr("content") || o('meta[property="og:description"]').attr("content") || "", m = o('meta[name="author"]').attr("content") || "";
+    let i = "";
+    const p = ["article", "main", '[role="main"]', ".content", ".post-content", ".entry-content", ".article-content"];
+    for (const c of p) {
+      const f = o(c).first();
+      if (f.length && f.text().trim().length > 200) {
+        const g = [];
+        if (f.find("p").each((b, S) => {
+          const y = o(S).text().trim();
+          y.length > 80 && g.push(y);
+        }), g.length > 2) {
+          i = g.join(`
+
+`);
+          break;
+        }
       }
     }
-    m || (m = n("body").text()), m = m.replace(/\n\s*\n\s*\n/g, `
+    if (!i) {
+      const c = [];
+      o("body p").each((f, g) => {
+        const b = o(g).text().trim();
+        b.length > 80 && c.push(b);
+      }), i = c.slice(0, 30).join(`
 
-`).replace(/[ \t]+/g, " ").trim().slice(0, 5e4);
-    let u = [];
-    return m.length < 500 && (n("a[href]").each((s, c) => {
-      const p = n(c).attr("href"), d = n(c).text().trim();
-      p && d && !p.startsWith("#") && u.push({ text: d, href: p });
-    }), u = u.slice(0, 50)), {
-      url: h.url,
-      type: "html",
-      title: l.title.trim(),
-      description: l.description.trim(),
-      author: l.author.trim(),
-      published: l.published,
-      content: m,
-      links: u.length ? u : void 0
-    };
+`);
+    }
+    const d = [`## ${u || "Webpage"}`];
+    return a && d.push(`_${a}_`), m && d.push(`👤 ${m}`), d.push(`🔗 ${h.url}
+`), d.push(i), D(d.join(`
+
+`).replaceAll(/\n{3,}/g, `
+
+`));
   }
-}, je = {
+}, ve = {
   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: {
@@ -887,112 +909,111 @@ const ne = () => O.platform() == "win32" ? "cmd" : T`echo $SHELL`?.split("/").po
     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)}`, {
-      headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)", "Accept-Language": "en-US,en;q=0.9" }
-    }).then((i) => i.text());
-    let e, r = /<a .*?href="(.+?)".+?<\/a>/g;
-    const o = new H();
-    for (; (e = r.exec(t)) !== null; ) {
-      let i = /uddg=(.+)&amp?/.exec(decodeURIComponent(e[1]))?.[1];
-      if (i && (i = decodeURIComponent(i)), i && o.add(i), o.size >= (h.length || 5)) break;
+    const r = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(h.query)}`, {
+      headers: { "User-Agent": z, "Accept-Language": "en-US,en;q=0.9" }
+    }).then((n) => n.text());
+    let e, t = /<a .*?href="(.+?)".+?<\/a>/g;
+    const l = new H();
+    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 o;
+    return l;
   }
 };
-class U {
-  ua = "AiTools-Wikipedia/1.0";
-  async get(t) {
-    return (await fetch(t, { headers: { "User-Agent": this.ua } })).json();
+class N {
+  async get(r) {
+    return (await fetch(r, { headers: { "User-Agent": z } })).json();
   }
-  api(t) {
-    const e = new URLSearchParams({ ...t, format: "json", utf8: "1" }).toString();
+  api(r) {
+    const e = new URLSearchParams({ ...r, format: "json", utf8: "1" }).toString();
     return this.get(`https://en.wikipedia.org/w/api.php?${e}`);
   }
-  clean(t) {
-    return t.replace(/\n{3,}/g, `
+  clean(r) {
+    return r.replace(/\n{3,}/g, `
 
 `).replace(/ {2,}/g, " ").replace(/\[\d+\]/g, "").trim();
   }
-  truncate(t, e) {
-    if (t.length <= e) return t;
-    const r = t.slice(0, e), o = r.lastIndexOf(`
+  truncate(r, e) {
+    if (r.length <= e) return r;
+    const t = r.slice(0, e), l = t.lastIndexOf(`
 
 `);
-    return o > e * 0.7 ? r.slice(0, o) : r;
+    return l > e * 0.7 ? t.slice(0, l) : t;
   }
-  async searchTitles(t, e = 6) {
-    return (await this.api({ action: "query", list: "search", srsearch: t, srlimit: e, srprop: "snippet" })).query?.search || [];
+  async searchTitles(r, e = 6) {
+    return (await this.api({ action: "query", list: "search", srsearch: r, srlimit: e, srprop: "snippet" })).query?.search || [];
   }
-  async fetchExtract(t, e = !1) {
-    const r = { action: "query", prop: "extracts", titles: t, explaintext: 1, redirects: 1 };
-    e && (r.exintro = 1);
-    const o = await this.api(r), i = Object.values(o.query?.pages || {})[0];
-    return this.clean(i?.extract || "");
+  async fetchExtract(r, e = !1) {
+    const t = { action: "query", prop: "extracts", titles: r, explaintext: 1, redirects: 1 };
+    e && (t.exintro = 1);
+    const l = await this.api(t), n = Object.values(l.query?.pages || {})[0];
+    return this.clean(n?.extract || "");
   }
-  pageUrl(t) {
-    return `https://en.wikipedia.org/wiki/${encodeURIComponent(t.replace(/ /g, "_"))}`;
+  pageUrl(r) {
+    return `https://en.wikipedia.org/wiki/${encodeURIComponent(r.replace(/ /g, "_"))}`;
   }
-  stripHtml(t) {
-    return t.replace(/<[^>]+>/g, "");
+  stripHtml(r) {
+    return r.replace(/<[^>]+>/g, "");
   }
-  async lookup(t, e = "intro") {
-    const r = await this.searchTitles(t, 6);
-    if (!r.length) return `❌ No Wikipedia articles found for "${t}"`;
-    const o = r[0].title, i = this.pageUrl(o), n = await this.fetchExtract(o, e === "intro"), l = this.truncate(n, e === "intro" ? 2e3 : 8e3);
-    return `## ${o}
-🔗 ${i}
+  async lookup(r, e = "intro") {
+    const t = await this.searchTitles(r, 6);
+    if (!t.length) return `❌ No Wikipedia articles found for "${r}"`;
+    const l = t[0].title, n = this.pageUrl(l), s = await this.fetchExtract(l, e === "intro"), o = this.truncate(s, e === "intro" ? 2e3 : 8e3);
+    return `## ${l}
+🔗 ${n}
 
-${l}`;
+${o}`;
   }
-  async search(t) {
-    const e = await this.searchTitles(t, 8);
-    if (!e.length) return `❌ No results for "${t}"`;
-    const r = [`### Search results for "${t}"
+  async search(r) {
+    const e = await this.searchTitles(r, 8);
+    if (!e.length) return `❌ No results for "${r}"`;
+    const t = [`### Search results for "${r}"
 `];
-    for (let o = 0; o < e.length; o++) {
-      const i = e[o], n = this.truncate(this.stripHtml(i.snippet || ""), 150);
-      r.push(`**${o + 1}. ${i.title}**
-${n}
-${this.pageUrl(i.title)}`);
+    for (let l = 0; l < e.length; l++) {
+      const n = e[l], s = this.truncate(this.stripHtml(n.snippet || ""), 150);
+      t.push(`**${l + 1}. ${n.title}**
+${s}
+${this.pageUrl(n.title)}`);
     }
-    return r.join(`
+    return t.join(`
 
 `);
   }
 }
-const $e = {
+const Ee = {
   name: "wikipedia_lookup",
   description: "Get Wikipedia article content",
   args: {
     query: { type: "string", description: "Topic or article title", required: !0 },
     detail: { type: "string", description: 'Content level: "intro" (summary, default) or "full" (complete article)', enum: ["intro", "full"], default: "intro" }
   },
-  fn: async (h) => new U().lookup(h.query, h.detail || "intro")
-}, ve = {
+  fn: async (h) => new N().lookup(h.query, h.detail || "intro")
+}, qe = {
   name: "wikipedia_search",
   description: "Search Wikipedia for matching articles",
   args: {
     query: { type: "string", description: "Search terms", required: !0 }
   },
-  fn: async (h) => new U().search(h.query)
+  fn: async (h) => new N().search(h.query)
 };
 export {
-  be as Ai,
-  X as Anthropic,
-  te as Audio,
-  se as CliTool,
-  xe as DateTimeTool,
-  ke as DateTimeUTCTool,
-  Se as ExecTool,
-  _e as FetchTool,
-  oe as JSTool,
-  W as LLMProvider,
+  ke as Ai,
+  te as Anthropic,
+  ne as Audio,
+  ie as CliTool,
+  Se as DateTimeTool,
+  _e as DateTimeUTCTool,
+  $e as ExecTool,
+  Te as FetchTool,
+  ae as JSTool,
+  L as LLMProvider,
   P as OpenAi,
-  ie as PythonTool,
-  Te as ReadWebpageTool,
-  re as Vision,
-  je as WebSearchTool,
-  $e as WikipediaLookupTool,
-  ve as WikipediaSearchTool
+  ce as PythonTool,
+  je as ReadWebpageTool,
+  se as Vision,
+  ve as WebSearchTool,
+  Ee as WikipediaLookupTool,
+  qe as WikipediaSearchTool
 };
 //# sourceMappingURL=index.mjs.map