@ztimson/ai-utils 0.1.20 → 0.1.21

package/dist/index.mjs

@@ -1,29 +1,29 @@
 import { createWorker as T } from "tesseract.js";
-import { objectMap as k, JSONAttemptParse as y, findByProp as x, JSONSanitize as b, Http as q, consoleInterceptor as v, fn as P, ASet as A } from "@ztimson/utils";
-import { Anthropic as E } from "@anthropic-ai/sdk";
-import { Ollama as M } from "ollama";
-import { OpenAI as O } from "openai";
+import { deepCopy as q, objectMap as k, JSONAttemptParse as y, findByProp as x, JSONSanitize as b, Http as v, consoleInterceptor as P, fn as A, ASet as E } from "@ztimson/utils";
+import { Anthropic as M } from "@anthropic-ai/sdk";
+import { Ollama as O } from "ollama";
+import { OpenAI as D } from "openai";
 import j from "node:fs/promises";
-import D from "node:path";
+import U from "node:path";
 import * as _ from "@tensorflow/tfjs";
-import { spawn as U } from "node:child_process";
-import { $, $Sync as L } from "@ztimson/node-utils";
+import { spawn as $ } from "node:child_process";
+import { $ as L, $Sync as R } from "@ztimson/node-utils";
 class S {
 }
-class R extends S {
+class I extends S {
   constructor(t, e, n) {
-    super(), this.ai = t, this.apiToken = e, this.model = n, this.client = new E({ apiKey: e });
+    super(), this.ai = t, this.apiToken = e, this.model = n, this.client = new M({ apiKey: e });
   }
   client;
   toStandard(t) {
     for (let e = 0; e < t.length; e++) {
       const n = e;
-      typeof t[n].content != "string" && (t[n].role == "assistant" ? t[n].content.filter((o) => o.type == "tool_use").forEach((o) => {
-        e++, t.splice(e, 0, { role: "tool", id: o.id, name: o.name, args: o.input, timestamp: Date.now() });
-      }) : t[n].role == "user" && t[n].content.filter((o) => o.type == "tool_result").forEach((o) => {
-        const c = t.find((f) => f.id == o.tool_use_id);
-        c[o.is_error ? "error" : "content"] = o.content;
-      }), t[n].content = t[n].content.filter((o) => o.type == "text").map((o) => o.text).join(`
+      typeof t[n].content != "string" && (t[n].role == "assistant" ? t[n].content.filter((a) => a.type == "tool_use").forEach((a) => {
+        e++, t.splice(e, 0, { role: "tool", id: a.id, name: a.name, args: a.input, timestamp: Date.now() });
+      }) : t[n].role == "user" && t[n].content.filter((a) => a.type == "tool_result").forEach((a) => {
+        const i = t.find((f) => f.id == a.tool_use_id);
+        i[a.is_error ? "error" : "content"] = a.content;
+      }), t[n].content = t[n].content.filter((a) => a.type == "text").map((a) => a.text).join(`
 
 `)), t[n].timestamp || (t[n].timestamp = Date.now());
     }
@@ -43,80 +43,81 @@ class R extends S {
     return t.map(({ timestamp: e, ...n }) => n);
   }
   ask(t, e = {}) {
-    const n = new AbortController(), o = new Promise(async (c, f) => {
-      let l = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
-      e.compress && (l = await this.ai.llm.compress(l, e.compress.max, e.compress.min, e));
-      const m = {
+    const n = new AbortController(), a = new Promise(async (i, f) => {
+      let c = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
+      const l = q(c);
+      e.compress && (c = await this.ai.llm.compress(c, e.compress.max, e.compress.min, e));
+      const d = {
         model: e.model || this.model,
         max_tokens: e.max_tokens || this.ai.options.max_tokens || 4096,
         system: e.system || this.ai.options.system || "",
         temperature: e.temperature || this.ai.options.temperature || 0.7,
-        tools: (e.tools || this.ai.options.tools || []).map((p) => ({
-          name: p.name,
-          description: p.description,
+        tools: (e.tools || this.ai.options.tools || []).map((m) => ({
+          name: m.name,
+          description: m.description,
           input_schema: {
             type: "object",
-            properties: p.args ? k(p.args, (d, s) => ({ ...s, required: void 0 })) : {},
-            required: p.args ? Object.entries(p.args).filter((d) => d[1].required).map((d) => d[0]) : []
+            properties: m.args ? k(m.args, (r, s) => ({ ...s, required: void 0 })) : {},
+            required: m.args ? Object.entries(m.args).filter((r) => r[1].required).map((r) => r[0]) : []
           },
           fn: void 0
         })),
-        messages: l,
+        messages: c,
         stream: !!e.stream
       };
-      let i;
-      const r = [];
+      let o;
+      const h = [];
       do {
-        if (i = await this.client.messages.create(m), e.stream) {
-          r.length && e.stream({ text: `
+        if (o = await this.client.messages.create(d), e.stream) {
+          h.length && e.stream({ text: `
 
-` }), i.content = [];
-          for await (const s of i) {
+` }), o.content = [];
+          for await (const s of o) {
             if (n.signal.aborted) break;
             if (s.type === "content_block_start")
-              s.content_block.type === "text" ? i.content.push({ type: "text", text: "" }) : s.content_block.type === "tool_use" && i.content.push({ type: "tool_use", id: s.content_block.id, name: s.content_block.name, input: "" });
+              s.content_block.type === "text" ? o.content.push({ type: "text", text: "" }) : s.content_block.type === "tool_use" && o.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 a = s.delta.text;
-                i.content.at(-1).text += a, e.stream({ text: a });
-              } else s.delta.type === "input_json_delta" && (i.content.at(-1).input += s.delta.partial_json);
+                const p = s.delta.text;
+                o.content.at(-1).text += p, e.stream({ text: p });
+              } else s.delta.type === "input_json_delta" && (o.content.at(-1).input += s.delta.partial_json);
             else if (s.type === "content_block_stop") {
-              const a = i.content.at(-1);
-              a.input != null && (a.input = a.input ? y(a.input, {}) : {});
+              const p = o.content.at(-1);
+              p.input != null && (p.input = p.input ? y(p.input, {}) : {});
             } else if (s.type === "message_stop")
               break;
           }
         }
-        const p = i.content.filter((s) => s.type == "text").map((s) => s.text).join(`
+        const m = o.content.filter((s) => s.type == "text").map((s) => s.text).join(`
 
 `);
-        p && r.push(p);
-        const d = i.content.filter((s) => s.type === "tool_use");
-        if (d.length && !n.signal.aborted) {
-          l.push({ role: "assistant", content: i.content });
-          const s = await Promise.all(d.map(async (a) => {
-            const g = e.tools?.find(x("name", a.name));
-            if (!g) return { tool_use_id: a.id, is_error: !0, content: "Tool not found" };
+        m && h.push(m);
+        const r = o.content.filter((s) => s.type === "tool_use");
+        if (r.length && !n.signal.aborted) {
+          c.push({ role: "assistant", content: o.content }), l.push({ role: "assistant", content: o.content });
+          const s = await Promise.all(r.map(async (p) => {
+            const g = e.tools?.find(x("name", p.name));
+            if (!g) return { tool_use_id: p.id, is_error: !0, content: "Tool not found" };
             try {
-              const h = await g.fn(a.input, this.ai);
-              return { type: "tool_result", tool_use_id: a.id, content: b(h) };
-            } catch (h) {
-              return { type: "tool_result", tool_use_id: a.id, is_error: !0, content: h?.message || h?.toString() || "Unknown" };
+              const w = await g.fn(p.input, this.ai);
+              return { type: "tool_result", tool_use_id: p.id, content: b(w) };
+            } catch (w) {
+              return { type: "tool_result", tool_use_id: p.id, is_error: !0, content: w?.message || w?.toString() || "Unknown" };
             }
           }));
-          l.push({ role: "user", content: s }), m.messages = l;
+          c.push({ role: "user", content: s }), l.push({ role: "user", content: s }), d.messages = c;
         }
-      } while (!n.signal.aborted && i.content.some((p) => p.type === "tool_use"));
-      e.stream && e.stream({ done: !0 }), c(this.toStandard([...l, { role: "assistant", content: r.join(`
+      } while (!n.signal.aborted && o.content.some((m) => m.type === "tool_use"));
+      e.stream && e.stream({ done: !0 }), i(this.toStandard([...l, { role: "assistant", content: h.join(`
 
 `), timestamp: Date.now() }]));
     });
-    return Object.assign(o, { abort: () => n.abort() });
+    return Object.assign(a, { abort: () => n.abort() });
   }
 }
-class I extends S {
+class J extends S {
   constructor(t, e, n) {
-    super(), this.ai = t, this.host = e, this.model = n, this.client = new M({ host: e });
+    super(), this.ai = t, this.host = e, this.model = n, this.client = new O({ host: e });
   }
   client;
   toStandard(t) {
@@ -133,90 +134,90 @@ class I extends S {
   }
   fromStandard(t) {
     return t.map((e) => {
-      const { timestamp: n, ...o } = e;
-      return e.role != "tool" ? o : { role: "tool", tool_name: e.name, content: e.error || e.content };
+      const { timestamp: n, ...a } = e;
+      return e.role != "tool" ? a : { role: "tool", tool_name: e.name, content: e.error || e.content };
     });
   }
   ask(t, e = {}) {
-    const n = new AbortController(), o = new Promise(async (c, f) => {
-      let l = e.system || this.ai.options.system, m = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
-      m[0].roll == "system" && (l ? m.shift() : l = m.shift()), e.compress && (m = await this.ai.llm.compress(m, e.compress.max, e.compress.min)), e.system && m.unshift({ role: "system", content: l });
-      const i = {
+    const n = new AbortController(), a = new Promise(async (i, f) => {
+      let c = e.system || this.ai.options.system, l = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
+      l[0].roll == "system" && (c ? l.shift() : c = l.shift()), e.compress && (l = await this.ai.llm.compress(l, e.compress.max, e.compress.min)), e.system && l.unshift({ role: "system", content: c });
+      const d = {
         model: e.model || this.model,
-        messages: m,
+        messages: l,
         stream: !!e.stream,
         signal: n.signal,
         options: {
           temperature: e.temperature || this.ai.options.temperature || 0.7,
           num_predict: e.max_tokens || this.ai.options.max_tokens || 4096
         },
-        tools: (e.tools || this.ai.options.tools || []).map((s) => ({
+        tools: (e.tools || this.ai.options.tools || []).map((r) => ({
           type: "function",
           function: {
-            name: s.name,
-            description: s.description,
+            name: r.name,
+            description: r.description,
             parameters: {
               type: "object",
-              properties: s.args ? k(s.args, (a, g) => ({ ...g, required: void 0 })) : {},
-              required: s.args ? Object.entries(s.args).filter((a) => a[1].required).map((a) => a[0]) : []
+              properties: r.args ? k(r.args, (s, p) => ({ ...p, required: void 0 })) : {},
+              required: r.args ? Object.entries(r.args).filter((s) => s[1].required).map((s) => s[0]) : []
             }
           }
         }))
       };
-      let r;
-      const p = [];
+      let o;
+      const h = [];
       do {
-        if (r = await this.client.chat(i), e.stream) {
-          p.length && e.stream({ text: `
+        if (o = await this.client.chat(d), e.stream) {
+          h.length && e.stream({ text: `
 
-` }), r.message = { role: "assistant", content: "", tool_calls: [] };
-          for await (const s of r)
-            if (n.signal.aborted || (s.message?.content && (r.message.content += s.message.content, e.stream({ text: s.message.content })), s.message?.tool_calls && (r.message.tool_calls = s.message.tool_calls), s.done)) break;
+` }), o.message = { role: "assistant", content: "", tool_calls: [] };
+          for await (const r of o)
+            if (n.signal.aborted || (r.message?.content && (o.message.content += r.message.content, e.stream({ text: r.message.content })), r.message?.tool_calls && (o.message.tool_calls = r.message.tool_calls), r.done)) break;
         }
-        if (p.push({ role: "assistant", content: r.message?.content, timestamp: Date.now() }), r.message?.tool_calls?.length && !n.signal.aborted) {
-          m.push(r.message);
-          const s = await Promise.all(r.message.tool_calls.map(async (a) => {
-            const g = (e.tools || this.ai.options.tools)?.find(x("name", a.function.name));
-            if (!g) return { role: "tool", tool_name: a.function.name, content: '{"error": "Tool not found"}' };
-            const h = typeof a.function.arguments == "string" ? y(a.function.arguments, {}) : a.function.arguments;
+        if (h.push({ role: "assistant", content: o.message?.content, timestamp: Date.now() }), o.message?.tool_calls?.length && !n.signal.aborted) {
+          l.push(o.message);
+          const r = await Promise.all(o.message.tool_calls.map(async (s) => {
+            const p = (e.tools || this.ai.options.tools)?.find(x("name", s.function.name));
+            if (!p) return { role: "tool", tool_name: s.function.name, content: '{"error": "Tool not found"}' };
+            const g = typeof s.function.arguments == "string" ? y(s.function.arguments, {}) : s.function.arguments;
             try {
-              const w = await g.fn(h, this.ai);
-              return { role: "tool", tool_name: a.function.name, args: h, content: b(w) };
+              const w = await p.fn(g, this.ai);
+              return { role: "tool", tool_name: s.function.name, args: g, content: b(w) };
             } catch (w) {
-              return { role: "tool", tool_name: a.function.name, args: h, content: b({ error: w?.message || w?.toString() || "Unknown" }) };
+              return { role: "tool", tool_name: s.function.name, args: g, content: b({ error: w?.message || w?.toString() || "Unknown" }) };
             }
           }));
-          m.push(...s), p.push(...s.map((a) => ({ ...a, timestamp: Date.now() }))), i.messages = m;
+          l.push(...r), h.push(...r.map((s) => ({ ...s, timestamp: Date.now() }))), d.messages = l;
         }
-      } while (!n.signal.aborted && r.message?.tool_calls?.length);
-      const d = p.filter((s) => s.role === "assistant").map((s) => s.content).filter((s) => s).join(`
+      } while (!n.signal.aborted && o.message?.tool_calls?.length);
+      const m = h.filter((r) => r.role === "assistant").map((r) => r.content).filter((r) => r).join(`
 
 `);
-      e.stream && e.stream({ done: !0 }), c(this.toStandard([...m, { role: "assistant", content: d, timestamp: Date.now() }]));
+      e.stream && e.stream({ done: !0 }), i(this.toStandard([...l, { role: "assistant", content: m, timestamp: Date.now() }]));
     });
-    return Object.assign(o, { abort: () => n.abort() });
+    return Object.assign(a, { abort: () => n.abort() });
   }
 }
-class J extends S {
+class W extends S {
   constructor(t, e, n) {
-    super(), this.ai = t, this.apiToken = e, this.model = n, this.client = new O({ apiKey: e });
+    super(), this.ai = t, this.apiToken = e, this.model = n, this.client = new D({ apiKey: e });
   }
   client;
   toStandard(t) {
     for (let e = 0; e < t.length; e++) {
       const n = t[e];
       if (n.role === "assistant" && n.tool_calls) {
-        const o = n.tool_calls.map((c) => ({
+        const a = n.tool_calls.map((i) => ({
           role: "tool",
-          id: c.id,
-          name: c.function.name,
-          args: y(c.function.arguments, {}),
+          id: i.id,
+          name: i.function.name,
+          args: y(i.function.arguments, {}),
           timestamp: n.timestamp
         }));
-        t.splice(e, 1, ...o), e += o.length - 1;
+        t.splice(e, 1, ...a), e += a.length - 1;
       } else if (n.role === "tool" && n.content) {
-        const o = t.find((c) => n.tool_call_id == c.id);
-        o && (n.content.includes('"error":') ? o.error = n.content : o.content = n.content), t.splice(e, 1), e--;
+        const a = t.find((i) => n.tool_call_id == i.id);
+        a && (n.content.includes('"error":') ? a.error = n.content : a.content = n.content), t.splice(e, 1), e--;
       }
       t[e]?.timestamp || (t[e].timestamp = Date.now());
     }
@@ -237,75 +238,75 @@ class J extends S {
           content: n.error || n.content
         });
       else {
-        const { timestamp: o, ...c } = n;
-        e.push(c);
+        const { timestamp: a, ...i } = n;
+        e.push(i);
       }
       return e;
     }, []);
   }
   ask(t, e = {}) {
-    const n = new AbortController(), o = new Promise(async (c, f) => {
-      let l = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
-      e.compress && (l = await this.ai.llm.compress(l, e.compress.max, e.compress.min, e));
-      const m = {
+    const n = new AbortController(), a = new Promise(async (i, f) => {
+      let c = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
+      e.compress && (c = await this.ai.llm.compress(c, e.compress.max, e.compress.min, e));
+      const l = {
         model: e.model || this.model,
-        messages: l,
+        messages: c,
         stream: !!e.stream,
         max_tokens: e.max_tokens || this.ai.options.max_tokens || 4096,
         temperature: e.temperature || this.ai.options.temperature || 0.7,
-        tools: (e.tools || this.ai.options.tools || []).map((d) => ({
+        tools: (e.tools || this.ai.options.tools || []).map((m) => ({
           type: "function",
           function: {
-            name: d.name,
-            description: d.description,
+            name: m.name,
+            description: m.description,
             parameters: {
               type: "object",
-              properties: d.args ? k(d.args, (s, a) => ({ ...a, required: void 0 })) : {},
-              required: d.args ? Object.entries(d.args).filter((s) => s[1].required).map((s) => s[0]) : []
+              properties: m.args ? k(m.args, (r, s) => ({ ...s, required: void 0 })) : {},
+              required: m.args ? Object.entries(m.args).filter((r) => r[1].required).map((r) => r[0]) : []
             }
           }
         }))
       };
-      let i;
-      const r = [];
+      let d;
+      const o = [];
       do {
-        if (i = await this.client.chat.completions.create(m), e.stream) {
-          r.length && e.stream({ text: `
+        if (d = await this.client.chat.completions.create(l), e.stream) {
+          o.length && e.stream({ text: `
 
-` }), i.choices = [{ message: { content: "", tool_calls: [] } }];
-          for await (const s of i) {
+` }), d.choices = [{ message: { content: "", tool_calls: [] } }];
+          for await (const r of d) {
             if (n.signal.aborted) break;
-            s.choices[0].delta.content && (i.choices[0].message.content += s.choices[0].delta.content, e.stream({ text: s.choices[0].delta.content })), s.choices[0].delta.tool_calls && (i.choices[0].message.tool_calls = s.choices[0].delta.tool_calls);
+            r.choices[0].delta.content && (d.choices[0].message.content += r.choices[0].delta.content, e.stream({ text: r.choices[0].delta.content })), r.choices[0].delta.tool_calls && (d.choices[0].message.tool_calls = r.choices[0].delta.tool_calls);
           }
         }
-        r.push({ role: "assistant", content: i.choices[0].message.content || "", timestamp: Date.now() });
-        const d = i.choices[0].message.tool_calls || [];
-        if (d.length && !n.signal.aborted) {
-          l.push(i.choices[0].message);
-          const s = await Promise.all(d.map(async (a) => {
-            const g = e.tools?.find(x("name", a.function.name));
-            if (!g) return { role: "tool", tool_call_id: a.id, content: '{"error": "Tool not found"}' };
+        o.push({ role: "assistant", content: d.choices[0].message.content || "", timestamp: Date.now() });
+        const m = d.choices[0].message.tool_calls || [];
+        if (m.length && !n.signal.aborted) {
+          c.push(d.choices[0].message);
+          const r = await Promise.all(m.map(async (s) => {
+            const p = e.tools?.find(x("name", s.function.name));
+            if (!p) return { role: "tool", tool_call_id: s.id, content: '{"error": "Tool not found"}' };
             try {
-              const h = y(a.function.arguments, {}), w = await g.fn(h, this.ai);
-              return { role: "tool", tool_call_id: a.id, content: b(w) };
-            } catch (h) {
-              return { role: "tool", tool_call_id: a.id, content: b({ error: h?.message || h?.toString() || "Unknown" }) };
+              const g = y(s.function.arguments, {}), w = await p.fn(g, this.ai);
+              return { role: "tool", tool_call_id: s.id, content: b(w) };
+            } catch (g) {
+              return { role: "tool", tool_call_id: s.id, content: b({ error: g?.message || g?.toString() || "Unknown" }) };
             }
           }));
-          l.push(...s), r.push(...s.map((a) => ({ ...a, timestamp: Date.now() }))), m.messages = l;
+          c.push(...r), o.push(...r.map((s) => ({ ...s, timestamp: Date.now() }))), l.messages = c;
         }
-      } while (!n.signal.aborted && i.choices?.[0]?.message?.tool_calls?.length);
-      const p = r.filter((d) => d.role === "assistant").map((d) => d.content).filter((d) => d).join(`
+      } while (!n.signal.aborted && d.choices?.[0]?.message?.tool_calls?.length);
+      const h = o.filter((m) => m.role === "assistant").map((m) => m.content).filter((m) => m).join(`
 
 `);
-      e.stream && e.stream({ done: !0 }), c(this.toStandard([...l, { role: "assistant", content: p, timestamp: Date.now() }]));
+      e.stream && e.stream({ done: !0 }), i(this.toStandard([...c, { role: "assistant", content: h, timestamp: Date.now() }]));
     });
-    return Object.assign(o, { abort: () => n.abort() });
+    return Object.assign(a, { abort: () => n.abort() });
   }
 }
-class W {
+class N {
   constructor(t, e) {
-    this.ai = t, this.options = e, e.anthropic?.token && (this.providers.anthropic = new R(this.ai, e.anthropic.token, e.anthropic.model)), e.ollama?.host && (this.providers.ollama = new I(this.ai, e.ollama.host, e.ollama.model)), e.openAi?.token && (this.providers.openAi = new J(this.ai, e.openAi.token, e.openAi.model));
+    this.ai = t, this.options = e, e.anthropic?.token && (this.providers.anthropic = new I(this.ai, e.anthropic.token, e.anthropic.model)), e.ollama?.host && (this.providers.ollama = new J(this.ai, e.ollama.host, e.ollama.model)), e.openAi?.token && (this.providers.openAi = new W(this.ai, e.openAi.token, e.openAi.model));
   }
   providers = {};
   /**
@@ -327,17 +328,17 @@ class W {
    * @param {LLMRequest} options LLM options
    * @returns {Promise<LLMMessage[]>} New chat history will summary at index 0
    */
-  async compress(t, e, n, o) {
+  async compress(t, e, n, a) {
     if (this.estimateTokens(t) < e) return t;
-    let c = 0, f = 0;
-    for (let r of t.toReversed())
-      if (f += this.estimateTokens(r.content), f < n) c++;
+    let i = 0, f = 0;
+    for (let o of t.toReversed())
+      if (f += this.estimateTokens(o.content), f < n) i++;
       else break;
-    if (t.length <= c) return t;
-    const l = c == 0 ? [] : t.slice(-c), m = (c == 0 ? t : t.slice(0, -c)).filter((r) => r.role === "assistant" || r.role === "user");
-    return [{ role: "assistant", content: `Conversation Summary: ${await this.summarize(m.map((r) => `${r.role}: ${r.content}`).join(`
+    if (t.length <= i) return t;
+    const c = i == 0 ? [] : t.slice(-i), l = (i == 0 ? t : t.slice(0, -i)).filter((o) => o.role === "assistant" || o.role === "user");
+    return [{ role: "assistant", content: `Conversation Summary: ${await this.summarize(l.map((o) => `${o.role}: ${o.content}`).join(`
 
-`), 250, o)}`, timestamp: Date.now() }, ...l];
+`), 250, a)}`, timestamp: Date.now() }, ...c];
   }
   /**
    * Estimate variable as tokens
@@ -369,12 +370,12 @@ class W {
    * @returns {Promise<string>} Summary
    */
   summarize(t, e, n) {
-    return this.ask(t, { system: `Generate a brief summary <= ${e} tokens. Output nothing else`, temperature: 0.3, ...n }).then((o) => o.pop()?.content || null);
+    return this.ask(t, { system: `Generate a brief summary <= ${e} tokens. Output nothing else`, temperature: 0.3, ...n }).then((a) => a.pop()?.content || null);
   }
 }
-class Z {
+class ee {
   constructor(t) {
-    this.options = t, this.llm = new W(this, t), this.options.whisper?.binary && (this.whisperModel = this.options.whisper?.model.endsWith(".bin") ? this.options.whisper?.model : this.options.whisper?.model + ".bin", this.downloadAsrModel());
+    this.options = t, this.llm = new N(this, t), this.options.whisper?.binary && (this.whisperModel = this.options.whisper?.model.endsWith(".bin") ? this.options.whisper?.model : this.options.whisper?.model + ".bin", this.downloadAsrModel());
   }
   downloads = {};
   whisperModel;
@@ -390,12 +391,12 @@ class Z {
     if (!this.options.whisper?.binary) throw new Error("Whisper not configured");
     let n = () => {
     };
-    return { response: new Promise((c, f) => {
-      this.downloadAsrModel(e).then((l) => {
-        let m = "";
-        const i = U(this.options.whisper?.binary, ["-nt", "-np", "-m", l, "-f", t], { stdio: ["ignore", "pipe", "ignore"] });
-        n = () => i.kill("SIGTERM"), i.on("error", (r) => f(r)), i.stdout.on("data", (r) => m += r.toString()), i.on("close", (r) => {
-          r === 0 ? c(m.trim() || null) : f(new Error(`Exit code ${r}`));
+    return { response: new Promise((i, f) => {
+      this.downloadAsrModel(e).then((c) => {
+        let l = "";
+        const d = $(this.options.whisper?.binary, ["-nt", "-np", "-m", c, "-f", t], { stdio: ["ignore", "pipe", "ignore"] });
+        n = () => d.kill("SIGTERM"), d.on("error", (o) => f(o)), d.stdout.on("data", (o) => l += o.toString()), d.on("close", (o) => {
+          o === 0 ? i(l.trim() || null) : f(new Error(`Exit code ${o}`));
         });
       });
     }), abort: n };
@@ -409,7 +410,7 @@ class Z {
   async downloadAsrModel(t = this.whisperModel) {
     if (!this.options.whisper?.binary) throw new Error("Whisper not configured");
     t.endsWith(".bin") || (t += ".bin");
-    const e = D.join(this.options.whisper.path, t);
+    const e = U.join(this.options.whisper.path, t);
     return await j.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((n) => n.arrayBuffer()).then((n) => Buffer.from(n)).then(async (n) => (await j.writeFile(e, n), delete this.downloads[t], e)), this.downloads[t]);
   }
   /**
@@ -425,8 +426,8 @@ class Z {
       },
       response: new Promise(async (n) => {
         e = await T("eng");
-        const { data: o } = await e.recognize(t);
-        await e.terminate(), n(o.text.trim() || null);
+        const { data: a } = await e.recognize(t);
+        await e.terminate(), n(a.text.trim() || null);
       })
     };
   }
@@ -438,25 +439,25 @@ class Z {
    */
   semanticSimilarity(t, ...e) {
     if (e.length < 2) throw new Error("Requires at least 2 strings to compare");
-    const n = (l, m = 10) => l.toLowerCase().split("").map((i, r) => i.charCodeAt(0) * (r + 1) % m / m).slice(0, m), o = (l, m) => {
-      if (l.length !== m.length) throw new Error("Vectors must be same length");
-      const i = _.tensor1d(l), r = _.tensor1d(m), p = _.dot(i, r), d = _.norm(i), s = _.norm(r);
-      return d.dataSync()[0] === 0 || s.dataSync()[0] === 0 ? 0 : p.dataSync()[0] / (d.dataSync()[0] * s.dataSync()[0]);
-    }, c = n(t), f = e.map((l) => n(l)).map((l) => o(c, l));
-    return { avg: f.reduce((l, m) => l + m, 0) / f.length, max: Math.max(...f), similarities: f };
+    const n = (c, l = 10) => c.toLowerCase().split("").map((d, o) => d.charCodeAt(0) * (o + 1) % l / l).slice(0, l), a = (c, l) => {
+      if (c.length !== l.length) throw new Error("Vectors must be same length");
+      const d = _.tensor1d(c), o = _.tensor1d(l), h = _.dot(d, o), m = _.norm(d), r = _.norm(o);
+      return m.dataSync()[0] === 0 || r.dataSync()[0] === 0 ? 0 : h.dataSync()[0] / (m.dataSync()[0] * r.dataSync()[0]);
+    }, i = n(t), f = e.map((c) => n(c)).map((c) => a(i, c));
+    return { avg: f.reduce((c, l) => c + l, 0) / f.length, max: Math.max(...f), similarities: f };
   }
 }
-const N = {
+const z = {
   name: "cli",
   description: "Use the command line interface, returns any output",
   args: { command: { type: "string", description: "Command to run", required: !0 } },
-  fn: (u) => $`${u.command}`
-}, ee = {
+  fn: (u) => L`${u.command}`
+}, te = {
   name: "get_datetime",
   description: "Get current date and time",
   args: {},
   fn: async () => (/* @__PURE__ */ new Date()).toISOString()
-}, te = {
+}, ne = {
   name: "exec",
   description: "Run code/scripts",
   args: {
@@ -467,9 +468,9 @@ const N = {
     try {
       switch (u.type) {
         case "bash":
-          return await N.fn({ command: u.code }, t);
+          return await z.fn({ command: u.code }, t);
         case "node":
-          return await z.fn({ code: u.code }, t);
+          return await C.fn({ code: u.code }, t);
         case "python":
           return await G.fn({ code: u.code }, t);
       }
@@ -477,7 +478,7 @@ const N = {
       return { error: e?.message || e.toString() };
     }
   }
-}, ne = {
+}, oe = {
   name: "fetch",
   description: "Make HTTP request to URL",
   args: {
@@ -486,15 +487,15 @@ const N = {
     headers: { type: "object", description: "HTTP headers to send", default: {} },
     body: { type: "object", description: "HTTP body to send" }
   },
-  fn: (u) => new q({ url: u.url, headers: u.headers }).request({ method: u.method || "GET", body: u.body })
-}, z = {
+  fn: (u) => new v({ url: u.url, headers: u.headers }).request({ method: u.method || "GET", body: u.body })
+}, C = {
   name: "exec_javascript",
   description: "Execute commonjs javascript",
   args: {
     code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
   fn: async (u) => {
-    const t = v(null), e = await P({ console: t }, u.code, !0).catch((n) => t.output.error.push(n));
+    const t = P(null), e = await A({ console: t }, u.code, !0).catch((n) => t.output.error.push(n));
     return { ...t.output, return: e, stdout: void 0, stderr: void 0 };
   }
 }, G = {
@@ -503,7 +504,7 @@ const N = {
   args: {
     code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
-  fn: async (u) => ({ result: L`python -c "${u.code}"` })
+  fn: async (u) => ({ result: R`python -c "${u.code}"` })
 }, se = {
   name: "search",
   description: "Use a search engine to find relevant URLs, should be changed with fetch to scrape sources",
@@ -514,25 +515,25 @@ const N = {
   fn: async (u) => {
     const t = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(u.query)}`, {
       headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)", "Accept-Language": "en-US,en;q=0.9" }
-    }).then((c) => c.text());
+    }).then((i) => i.text());
     let e, n = /<a .*?href="(.+?)".+?<\/a>/g;
-    const o = new A();
+    const a = new E();
     for (; (e = n.exec(t)) !== null; ) {
-      let c = /uddg=(.+)&amp?/.exec(decodeURIComponent(e[1]))?.[1];
-      if (c && (c = decodeURIComponent(c)), c && o.add(c), o.size >= (u.length || 5)) break;
+      let i = /uddg=(.+)&amp?/.exec(decodeURIComponent(e[1]))?.[1];
+      if (i && (i = decodeURIComponent(i)), i && a.add(i), a.size >= (u.length || 5)) break;
     }
-    return o;
+    return a;
   }
 };
 export {
-  Z as Ai,
-  R as Anthropic,
-  N as CliTool,
-  ee as DateTimeTool,
-  te as ExecTool,
-  ne as FetchTool,
-  z as JSTool,
-  W as LLM,
+  ee as Ai,
+  I as Anthropic,
+  z as CliTool,
+  te as DateTimeTool,
+  ne as ExecTool,
+  oe as FetchTool,
+  C as JSTool,
+  N as LLM,
   G as PythonTool,
   se as SearchTool
 };