@ztimson/ai-utils 0.2.7 → 0.3.0

package/dist/index.mjs

@@ -1,126 +1,127 @@
-import * as j from "node:os";
-import { deepCopy as T, objectMap as y, JSONAttemptParse as _, findByProp as k, JSONSanitize as b, Http as M, consoleInterceptor as A, fn as q, ASet as P } from "@ztimson/utils";
-import { Anthropic as O } from "@anthropic-ai/sdk";
-import { Ollama as $ } from "ollama";
-import { OpenAI as E } from "openai";
-import { Worker as v } from "worker_threads";
-import { fileURLToPath as R } from "url";
-import { join as U, dirname as L } from "path";
-import { spawn as N } from "node:child_process";
-import S from "node:fs/promises";
-import W from "node:path";
-import { createWorker as D } from "tesseract.js";
-import { $ as J, $Sync as H } from "@ztimson/node-utils";
-class x {
+import * as M from "node:os";
+import { platform as E, arch as T } from "node:os";
+import { deepCopy as A, objectMap as x, JSONAttemptParse as _, findByProp as j, JSONSanitize as k, Http as q, consoleInterceptor as O, fn as $, ASet as v } from "@ztimson/utils";
+import { Anthropic as R } from "@anthropic-ai/sdk";
+import { Ollama as L } from "ollama";
+import { OpenAI as U } from "openai";
+import { Worker as B } from "worker_threads";
+import { fileURLToPath as W } from "url";
+import { join as I, dirname as D } from "path";
+import { spawn as P } from "node:child_process";
+import b from "node:fs/promises";
+import y from "node:path";
+import { createWorker as N } from "tesseract.js";
+import { $ as H, $Sync as J } from "@ztimson/node-utils";
+class S {
 }
-class I extends x {
-  constructor(t, e, s) {
-    super(), this.ai = t, this.apiToken = e, this.model = s, this.client = new O({ apiKey: e });
+class F extends S {
+  constructor(t, e, n) {
+    super(), this.ai = t, this.apiToken = e, this.model = n, this.client = new R({ apiKey: e });
   }
   client;
   toStandard(t) {
     for (let e = 0; e < t.length; e++) {
-      const s = e;
-      typeof t[s].content != "string" && (t[s].role == "assistant" ? t[s].content.filter((n) => n.type == "tool_use").forEach((n) => {
-        e++, t.splice(e, 0, { role: "tool", id: n.id, name: n.name, args: n.input, timestamp: Date.now() });
-      }) : t[s].role == "user" && t[s].content.filter((n) => n.type == "tool_result").forEach((n) => {
-        const i = t.find((d) => d.id == n.tool_use_id);
-        i[n.is_error ? "error" : "content"] = n.content;
-      }), t[s].content = t[s].content.filter((n) => n.type == "text").map((n) => n.text).join(`
+      const n = e;
+      typeof t[n].content != "string" && (t[n].role == "assistant" ? t[n].content.filter((s) => s.type == "tool_use").forEach((s) => {
+        e++, t.splice(e, 0, { role: "tool", id: s.id, name: s.name, args: s.input, timestamp: Date.now() });
+      }) : t[n].role == "user" && t[n].content.filter((s) => s.type == "tool_result").forEach((s) => {
+        const r = t.find((l) => l.id == s.tool_use_id);
+        r[s.is_error ? "error" : "content"] = s.content;
+      }), t[n].content = t[n].content.filter((s) => s.type == "text").map((s) => s.text).join(`
 
-`)), t[s].timestamp || (t[s].timestamp = Date.now());
+`)), t[n].timestamp || (t[n].timestamp = Date.now());
     }
     return t.filter((e) => !!e.content);
   }
   fromStandard(t) {
     for (let e = 0; e < t.length; e++)
       if (t[e].role == "tool") {
-        const s = t[e];
+        const n = t[e];
         t.splice(
           e,
           1,
-          { role: "assistant", content: [{ type: "tool_use", id: s.id, name: s.name, input: s.args }] },
-          { role: "user", content: [{ type: "tool_result", tool_use_id: s.id, is_error: !!s.error, content: s.error || s.content }] }
+          { role: "assistant", content: [{ type: "tool_use", id: n.id, name: n.name, input: n.args }] },
+          { role: "user", content: [{ type: "tool_result", tool_use_id: n.id, is_error: !!n.error, content: n.error || n.content }] }
         ), e++;
       }
-    return t.map(({ timestamp: e, ...s }) => s);
+    return t.map(({ timestamp: e, ...n }) => n);
   }
   ask(t, e = {}) {
-    const s = new AbortController(), n = new Promise(async (i, d) => {
-      let r = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
-      const l = T(r);
-      e.compress && (r = await this.ai.language.compressHistory(r, e.compress.max, e.compress.min, e));
-      const u = e.tools || this.ai.options.tools || [], c = {
+    const n = new AbortController(), s = new Promise(async (r, l) => {
+      let o = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
+      const d = A(o);
+      e.compress && (o = await this.ai.language.compressHistory(o, e.compress.max, e.compress.min, e));
+      const p = e.tools || this.ai.options.tools || [], a = {
         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: u.map((o) => ({
-          name: o.name,
-          description: o.description,
+        tools: p.map((i) => ({
+          name: i.name,
+          description: i.description,
           input_schema: {
             type: "object",
-            properties: o.args ? y(o.args, (a, f) => ({ ...f, required: void 0 })) : {},
-            required: o.args ? Object.entries(o.args).filter((a) => a[1].required).map((a) => a[0]) : []
+            properties: i.args ? x(i.args, (c, f) => ({ ...f, required: void 0 })) : {},
+            required: i.args ? Object.entries(i.args).filter((c) => c[1].required).map((c) => c[0]) : []
           },
           fn: void 0
         })),
-        messages: r,
+        messages: o,
         stream: !!e.stream
       };
       let m, h = !0;
       do {
-        if (m = await this.client.messages.create(c).catch((a) => {
-          throw a.message += `
+        if (m = await this.client.messages.create(a).catch((c) => {
+          throw c.message += `
 
 Messages:
-${JSON.stringify(r, null, 2)}`, a;
+${JSON.stringify(o, null, 2)}`, c;
         }), e.stream) {
           h ? h = !1 : e.stream({ text: `
 
 ` }), m.content = [];
-          for await (const a of m) {
-            if (s.signal.aborted) break;
-            if (a.type === "content_block_start")
-              a.content_block.type === "text" ? m.content.push({ type: "text", text: "" }) : a.content_block.type === "tool_use" && m.content.push({ type: "tool_use", id: a.content_block.id, name: a.content_block.name, input: "" });
-            else if (a.type === "content_block_delta")
-              if (a.delta.type === "text_delta") {
-                const f = a.delta.text;
+          for await (const c of m) {
+            if (n.signal.aborted) break;
+            if (c.type === "content_block_start")
+              c.content_block.type === "text" ? m.content.push({ type: "text", text: "" }) : c.content_block.type === "tool_use" && m.content.push({ type: "tool_use", id: c.content_block.id, name: c.content_block.name, input: "" });
+            else if (c.type === "content_block_delta")
+              if (c.delta.type === "text_delta") {
+                const f = c.delta.text;
                 m.content.at(-1).text += f, e.stream({ text: f });
-              } else a.delta.type === "input_json_delta" && (m.content.at(-1).input += a.delta.partial_json);
-            else if (a.type === "content_block_stop") {
+              } else c.delta.type === "input_json_delta" && (m.content.at(-1).input += c.delta.partial_json);
+            else if (c.type === "content_block_stop") {
               const f = m.content.at(-1);
               f.input != null && (f.input = f.input ? _(f.input, {}) : {});
-            } else if (a.type === "message_stop")
+            } else if (c.type === "message_stop")
               break;
           }
         }
-        const o = m.content.filter((a) => a.type === "tool_use");
-        if (o.length && !s.signal.aborted) {
-          r.push({ role: "assistant", content: m.content }), l.push({ role: "assistant", content: m.content });
-          const a = await Promise.all(o.map(async (f) => {
-            const g = u.find(k("name", f.name));
-            if (!g) return { tool_use_id: f.id, is_error: !0, content: "Tool not found" };
+        const i = m.content.filter((c) => c.type === "tool_use");
+        if (i.length && !n.signal.aborted) {
+          o.push({ role: "assistant", content: m.content }), d.push({ role: "assistant", content: m.content });
+          const c = await Promise.all(i.map(async (f) => {
+            const g = p.find(j("name", f.name));
+            if (e.stream && e.stream({ tool: f.name }), !g) return { tool_use_id: f.id, is_error: !0, content: "Tool not found" };
             try {
               const w = await g.fn(f.input, this.ai);
-              return { type: "tool_result", tool_use_id: f.id, content: b(w) };
+              return { type: "tool_result", tool_use_id: f.id, content: k(w) };
             } catch (w) {
               return { type: "tool_result", tool_use_id: f.id, is_error: !0, content: w?.message || w?.toString() || "Unknown" };
             }
           }));
-          r.push({ role: "user", content: a }), c.messages = r;
+          o.push({ role: "user", content: c }), a.messages = o;
         }
-      } while (!s.signal.aborted && m.content.some((o) => o.type === "tool_use"));
-      e.stream && e.stream({ done: !0 }), i(this.toStandard([...r, { role: "assistant", content: m.content.filter((o) => o.type == "text").map((o) => o.text).join(`
+      } while (!n.signal.aborted && m.content.some((i) => i.type === "tool_use"));
+      e.stream && e.stream({ done: !0 }), r(this.toStandard([...o, { role: "assistant", content: m.content.filter((i) => i.type == "text").map((i) => i.text).join(`
 
 `) }]));
     });
-    return Object.assign(n, { abort: () => s.abort() });
+    return Object.assign(s, { abort: () => n.abort() });
   }
 }
-class z extends x {
-  constructor(t, e, s) {
-    super(), this.ai = t, this.host = e, this.model = s, this.client = new $({ host: e });
+class z extends S {
+  constructor(t, e, n) {
+    super(), this.ai = t, this.host = e, this.model = n, this.client = new L({ host: e });
   }
   client;
   toStandard(t) {
@@ -128,8 +129,8 @@ class z extends x {
       if (t[e].role == "assistant" && t[e].tool_calls)
         t[e].content ? delete t[e].tool_calls : (t.splice(e, 1), e--);
       else if (t[e].role == "tool") {
-        const s = t[e].content.startsWith('{"error":');
-        t[e] = { role: "tool", name: t[e].tool_name, args: t[e].args, [s ? "error" : "content"]: t[e].content, timestamp: t[e].timestamp };
+        const n = t[e].content.startsWith('{"error":');
+        t[e] = { role: "tool", name: t[e].tool_name, args: t[e].args, [n ? "error" : "content"]: t[e].content, timestamp: t[e].timestamp };
       }
       t[e]?.timestamp || (t[e].timestamp = Date.now());
     }
@@ -137,183 +138,183 @@ class z extends x {
   }
   fromStandard(t) {
     return t.map((e) => {
-      const { timestamp: s, ...n } = e;
-      return e.role != "tool" ? n : { role: "tool", tool_name: e.name, content: e.error || e.content };
+      const { timestamp: n, ...s } = e;
+      return e.role != "tool" ? s : { role: "tool", tool_name: e.name, content: e.error || e.content };
     });
   }
   ask(t, e = {}) {
-    const s = new AbortController(), n = new Promise(async (i, d) => {
-      let r = e.system || this.ai.options.system, l = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
-      l[0].roll == "system" && (r ? l.shift() : r = l.shift()), e.compress && (l = await this.ai.language.compressHistory(l, e.compress.max, e.compress.min)), e.system && l.unshift({ role: "system", content: r });
-      const u = e.tools || this.ai.options.tools || [], c = {
+    const n = new AbortController(), s = new Promise(async (r, l) => {
+      let o = e.system || this.ai.options.system, d = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
+      d[0].roll == "system" && (o ? d.shift() : o = d.shift()), e.compress && (d = await this.ai.language.compressHistory(d, e.compress.max, e.compress.min)), e.system && d.unshift({ role: "system", content: o });
+      const p = e.tools || this.ai.options.tools || [], a = {
         model: e.model || this.model,
-        messages: l,
+        messages: d,
         stream: !!e.stream,
-        signal: s.signal,
+        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: u.map((o) => ({
+        tools: p.map((i) => ({
           type: "function",
           function: {
-            name: o.name,
-            description: o.description,
+            name: i.name,
+            description: i.description,
             parameters: {
               type: "object",
-              properties: o.args ? y(o.args, (a, f) => ({ ...f, required: void 0 })) : {},
-              required: o.args ? Object.entries(o.args).filter((a) => a[1].required).map((a) => a[0]) : []
+              properties: i.args ? x(i.args, (c, f) => ({ ...f, required: void 0 })) : {},
+              required: i.args ? Object.entries(i.args).filter((c) => c[1].required).map((c) => c[0]) : []
             }
           }
         }))
       };
       let m, h = !0;
       do {
-        if (m = await this.client.chat(c).catch((o) => {
-          throw o.message += `
+        if (m = await this.client.chat(a).catch((i) => {
+          throw i.message += `
 
 Messages:
-${JSON.stringify(l, null, 2)}`, o;
+${JSON.stringify(d, null, 2)}`, i;
         }), e.stream) {
           h ? h = !1 : e.stream({ text: `
 
 ` }), m.message = { role: "assistant", content: "", tool_calls: [] };
-          for await (const o of m)
-            if (s.signal.aborted || (o.message?.content && (m.message.content += o.message.content, e.stream({ text: o.message.content })), o.message?.tool_calls && (m.message.tool_calls = o.message.tool_calls), o.done)) break;
+          for await (const i of m)
+            if (n.signal.aborted || (i.message?.content && (m.message.content += i.message.content, e.stream({ text: i.message.content })), i.message?.tool_calls && (m.message.tool_calls = i.message.tool_calls), i.done)) break;
         }
-        if (m.message?.tool_calls?.length && !s.signal.aborted) {
-          l.push(m.message);
-          const o = await Promise.all(m.message.tool_calls.map(async (a) => {
-            const f = u.find(k("name", a.function.name));
-            if (!f) return { role: "tool", tool_name: a.function.name, content: '{"error": "Tool not found"}' };
-            const g = typeof a.function.arguments == "string" ? _(a.function.arguments, {}) : a.function.arguments;
+        if (m.message?.tool_calls?.length && !n.signal.aborted) {
+          d.push(m.message);
+          const i = await Promise.all(m.message.tool_calls.map(async (c) => {
+            const f = p.find(j("name", c.function.name));
+            if (e.stream && e.stream({ tool: c.function.name }), !f) return { role: "tool", tool_name: c.function.name, content: '{"error": "Tool not found"}' };
+            const g = typeof c.function.arguments == "string" ? _(c.function.arguments, {}) : c.function.arguments;
             try {
               const w = await f.fn(g, this.ai);
-              return { role: "tool", tool_name: a.function.name, args: g, content: b(w) };
+              return { role: "tool", tool_name: c.function.name, args: g, content: k(w) };
             } catch (w) {
-              return { role: "tool", tool_name: a.function.name, args: g, content: b({ error: w?.message || w?.toString() || "Unknown" }) };
+              return { role: "tool", tool_name: c.function.name, args: g, content: k({ error: w?.message || w?.toString() || "Unknown" }) };
             }
           }));
-          l.push(...o), c.messages = l;
+          d.push(...i), a.messages = d;
         }
-      } while (!s.signal.aborted && m.message?.tool_calls?.length);
-      e.stream && e.stream({ done: !0 }), i(this.toStandard([...l, { role: "assistant", content: m.message?.content }]));
+      } while (!n.signal.aborted && m.message?.tool_calls?.length);
+      e.stream && e.stream({ done: !0 }), r(this.toStandard([...d, { role: "assistant", content: m.message?.content }]));
     });
-    return Object.assign(n, { abort: () => s.abort() });
+    return Object.assign(s, { abort: () => n.abort() });
   }
 }
-class F extends x {
-  constructor(t, e, s) {
-    super(), this.ai = t, this.apiToken = e, this.model = s, this.client = new E({ apiKey: e });
+class G extends S {
+  constructor(t, e, n) {
+    super(), this.ai = t, this.apiToken = e, this.model = n, this.client = new U({ apiKey: e });
   }
   client;
   toStandard(t) {
     for (let e = 0; e < t.length; e++) {
-      const s = t[e];
-      if (s.role === "assistant" && s.tool_calls) {
-        const n = s.tool_calls.map((i) => ({
+      const n = t[e];
+      if (n.role === "assistant" && n.tool_calls) {
+        const s = n.tool_calls.map((r) => ({
           role: "tool",
-          id: i.id,
-          name: i.function.name,
-          args: _(i.function.arguments, {}),
-          timestamp: s.timestamp
+          id: r.id,
+          name: r.function.name,
+          args: _(r.function.arguments, {}),
+          timestamp: n.timestamp
         }));
-        t.splice(e, 1, ...n), e += n.length - 1;
-      } else if (s.role === "tool" && s.content) {
-        const n = t.find((i) => s.tool_call_id == i.id);
-        n && (s.content.includes('"error":') ? n.error = s.content : n.content = s.content), t.splice(e, 1), e--;
+        t.splice(e, 1, ...s), e += s.length - 1;
+      } else if (n.role === "tool" && n.content) {
+        const s = t.find((r) => n.tool_call_id == r.id);
+        s && (n.content.includes('"error":') ? s.error = n.content : s.content = n.content), t.splice(e, 1), e--;
       }
       t[e]?.timestamp || (t[e].timestamp = Date.now());
     }
     return t;
   }
   fromStandard(t) {
-    return t.reduce((e, s) => {
-      if (s.role === "tool")
+    return t.reduce((e, n) => {
+      if (n.role === "tool")
         e.push({
           role: "assistant",
           content: null,
-          tool_calls: [{ id: s.id, type: "function", function: { name: s.name, arguments: JSON.stringify(s.args) } }],
+          tool_calls: [{ id: n.id, type: "function", function: { name: n.name, arguments: JSON.stringify(n.args) } }],
           refusal: null,
           annotations: []
         }, {
           role: "tool",
-          tool_call_id: s.id,
-          content: s.error || s.content
+          tool_call_id: n.id,
+          content: n.error || n.content
         });
       else {
-        const { timestamp: n, ...i } = s;
-        e.push(i);
+        const { timestamp: s, ...r } = n;
+        e.push(r);
       }
       return e;
     }, []);
   }
   ask(t, e = {}) {
-    const s = new AbortController(), n = new Promise(async (i, d) => {
-      let r = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
-      e.compress && (r = await this.ai.language.compressHistory(r, e.compress.max, e.compress.min, e));
-      const l = e.tools || this.ai.options.tools || [], u = {
+    const n = new AbortController(), s = new Promise(async (r, l) => {
+      let o = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
+      e.compress && (o = await this.ai.language.compressHistory(o, e.compress.max, e.compress.min, e));
+      const d = e.tools || this.ai.options.tools || [], p = {
         model: e.model || this.model,
-        messages: r,
+        messages: o,
         stream: !!e.stream,
         max_tokens: e.max_tokens || this.ai.options.max_tokens || 4096,
         temperature: e.temperature || this.ai.options.temperature || 0.7,
-        tools: l.map((h) => ({
+        tools: d.map((h) => ({
           type: "function",
           function: {
             name: h.name,
             description: h.description,
             parameters: {
               type: "object",
-              properties: h.args ? y(h.args, (o, a) => ({ ...a, required: void 0 })) : {},
-              required: h.args ? Object.entries(h.args).filter((o) => o[1].required).map((o) => o[0]) : []
+              properties: h.args ? x(h.args, (i, c) => ({ ...c, required: void 0 })) : {},
+              required: h.args ? Object.entries(h.args).filter((i) => i[1].required).map((i) => i[0]) : []
             }
           }
         }))
       };
-      let c, m = !0;
+      let a, m = !0;
       do {
-        if (c = await this.client.chat.completions.create(u).catch((o) => {
-          throw o.message += `
+        if (a = await this.client.chat.completions.create(p).catch((i) => {
+          throw i.message += `
 
 Messages:
-${JSON.stringify(r, null, 2)}`, o;
+${JSON.stringify(o, null, 2)}`, i;
         }), e.stream) {
           m ? m = !1 : e.stream({ text: `
 
-` }), c.choices = [{ message: { content: "", tool_calls: [] } }];
-          for await (const o of c) {
-            if (s.signal.aborted) break;
-            o.choices[0].delta.content && (c.choices[0].message.content += o.choices[0].delta.content, e.stream({ text: o.choices[0].delta.content })), o.choices[0].delta.tool_calls && (c.choices[0].message.tool_calls = o.choices[0].delta.tool_calls);
+` }), a.choices = [{ message: { content: "", tool_calls: [] } }];
+          for await (const i of a) {
+            if (n.signal.aborted) break;
+            i.choices[0].delta.content && (a.choices[0].message.content += i.choices[0].delta.content, e.stream({ text: i.choices[0].delta.content })), i.choices[0].delta.tool_calls && (a.choices[0].message.tool_calls = i.choices[0].delta.tool_calls);
           }
         }
-        const h = c.choices[0].message.tool_calls || [];
-        if (h.length && !s.signal.aborted) {
-          r.push(c.choices[0].message);
-          const o = await Promise.all(h.map(async (a) => {
-            const f = l?.find(k("name", a.function.name));
-            if (!f) return { role: "tool", tool_call_id: a.id, content: '{"error": "Tool not found"}' };
+        const h = a.choices[0].message.tool_calls || [];
+        if (h.length && !n.signal.aborted) {
+          o.push(a.choices[0].message);
+          const i = await Promise.all(h.map(async (c) => {
+            const f = d?.find(j("name", c.function.name));
+            if (e.stream && e.stream({ tool: c.function.name }), !f) return { role: "tool", tool_call_id: c.id, content: '{"error": "Tool not found"}' };
             try {
-              const g = _(a.function.arguments, {}), w = await f.fn(g, this.ai);
-              return { role: "tool", tool_call_id: a.id, content: b(w) };
+              const g = _(c.function.arguments, {}), w = await f.fn(g, this.ai);
+              return { role: "tool", tool_call_id: c.id, content: k(w) };
             } catch (g) {
-              return { role: "tool", tool_call_id: a.id, content: b({ error: g?.message || g?.toString() || "Unknown" }) };
+              return { role: "tool", tool_call_id: c.id, content: k({ error: g?.message || g?.toString() || "Unknown" }) };
             }
           }));
-          r.push(...o), u.messages = r;
+          o.push(...i), p.messages = o;
         }
-      } while (!s.signal.aborted && c.choices?.[0]?.message?.tool_calls?.length);
-      e.stream && e.stream({ done: !0 }), i(this.toStandard([...r, { role: "assistant", content: c.choices[0].message.content || "" }]));
+      } while (!n.signal.aborted && a.choices?.[0]?.message?.tool_calls?.length);
+      e.stream && e.stream({ done: !0 }), r(this.toStandard([...o, { role: "assistant", content: a.choices[0].message.content || "" }]));
     });
-    return Object.assign(n, { abort: () => s.abort() });
+    return Object.assign(s, { abort: () => n.abort() });
   }
 }
-class G {
+class Q {
   constructor(t) {
-    this.ai = t, this.embedWorker = new v(U(L(R(import.meta.url)), "embedder.js")), this.embedWorker.on("message", ({ id: e, embedding: s }) => {
-      const n = this.embedQueue.get(e);
-      n && (n.resolve(s), this.embedQueue.delete(e));
-    }), t.options.anthropic?.token && (this.providers.anthropic = new I(this.ai, t.options.anthropic.token, t.options.anthropic.model)), t.options.ollama?.host && (this.providers.ollama = new z(this.ai, t.options.ollama.host, t.options.ollama.model)), t.options.openAi?.token && (this.providers.openAi = new F(this.ai, t.options.openAi.token, t.options.openAi.model));
+    this.ai = t, this.embedWorker = new B(I(D(W(import.meta.url)), "embedder.js")), this.embedWorker.on("message", ({ id: e, embedding: n }) => {
+      const s = this.embedQueue.get(e);
+      s && (s.resolve(n), this.embedQueue.delete(e));
+    }), t.options.anthropic?.token && (this.providers.anthropic = new F(this.ai, t.options.anthropic.token, t.options.anthropic.model)), t.options.ollama?.host && (this.providers.ollama = new z(this.ai, t.options.ollama.host, t.options.ollama.model)), t.options.openAi?.token && (this.providers.openAi = new G(this.ai, t.options.openAi.token, t.options.openAi.model));
   }
   embedWorker = null;
   embedQueue = /* @__PURE__ */ new Map();
@@ -326,9 +327,9 @@ class G {
    * @returns {{abort: () => void, response: Promise<LLMMessage[]>}} Function to abort response and chat history
    */
   ask(t, e = {}) {
-    let s = [null, null];
-    if (e.model && (typeof e.model == "object" ? s = e.model : s = [e.model, this.ai.options[e.model]?.model]), (!e.model || s[1] == null) && (typeof this.ai.options.model == "object" ? s = this.ai.options.model : s = [this.ai.options.model, this.ai.options[this.ai.options.model]?.model]), !s[0] || !s[1]) throw new Error(`Unknown LLM provider or model: ${s[0]} / ${s[1]}`);
-    return this.providers[s[0]].ask(t, { ...e, model: s[1] });
+    let n = [null, null];
+    if (e.model && (typeof e.model == "object" ? n = e.model : n = [e.model, this.ai.options[e.model]?.model]), (!e.model || n[1] == null) && (typeof this.ai.options.model == "object" ? n = this.ai.options.model : n = [this.ai.options.model, this.ai.options[this.ai.options.model]?.model]), !n[0] || !n[1]) throw new Error(`Unknown LLM provider or model: ${n[0]} / ${n[1]}`);
+    return this.providers[n[0]].ask(t, { ...e, model: n[1] });
   }
   /**
    * Compress chat history to reduce context size
@@ -338,57 +339,57 @@ class G {
    * @param {LLMRequest} options LLM options
    * @returns {Promise<LLMMessage[]>} New chat history will summary at index 0
    */
-  async compressHistory(t, e, s, n) {
+  async compressHistory(t, e, n, s) {
     if (this.estimateTokens(t) < e) return t;
-    let i = 0, d = 0;
-    for (let c of t.toReversed())
-      if (d += this.estimateTokens(c.content), d < s) i++;
+    let r = 0, l = 0;
+    for (let a of t.toReversed())
+      if (l += this.estimateTokens(a.content), l < n) r++;
       else break;
-    if (t.length <= i) return t;
-    const r = i == 0 ? [] : t.slice(-i), l = (i == 0 ? t : t.slice(0, -i)).filter((c) => c.role === "assistant" || c.role === "user");
-    return [{ role: "assistant", content: `Conversation Summary: ${await this.summarize(l.map((c) => `${c.role}: ${c.content}`).join(`
+    if (t.length <= r) return t;
+    const o = r == 0 ? [] : t.slice(-r), d = (r == 0 ? t : t.slice(0, -r)).filter((a) => a.role === "assistant" || a.role === "user");
+    return [{ role: "assistant", content: `Conversation Summary: ${await this.summarize(d.map((a) => `${a.role}: ${a.content}`).join(`
 
-`), 250, n)}`, timestamp: Date.now() }, ...r];
+`), 250, s)}`, timestamp: Date.now() }, ...o];
   }
   cosineSimilarity(t, e) {
     if (t.length !== e.length) throw new Error("Vectors must be same length");
-    let s = 0, n = 0, i = 0;
-    for (let r = 0; r < t.length; r++)
-      s += t[r] * e[r], n += t[r] * t[r], i += e[r] * e[r];
-    const d = Math.sqrt(n) * Math.sqrt(i);
-    return d === 0 ? 0 : s / d;
-  }
-  chunk(t, e = 500, s = 50) {
-    const n = (l, u = "") => l ? Object.entries(l).flatMap(([c, m]) => {
-      const h = u ? `${u}${isNaN(+c) ? `.${c}` : `[${c}]`}` : c;
-      return typeof m == "object" && !Array.isArray(m) ? n(m, h) : `${h}: ${Array.isArray(m) ? m.join(", ") : m}`;
-    }) : [], d = (typeof t == "object" ? n(t) : t.split(`
-`)).flatMap((l) => [...l.split(/\s+/).filter(Boolean), `
-`]), r = [];
-    for (let l = 0; l < d.length; ) {
-      let u = "", c = l;
-      for (; c < d.length; ) {
-        const h = u + (u ? " " : "") + d[c];
+    let n = 0, s = 0, r = 0;
+    for (let o = 0; o < t.length; o++)
+      n += t[o] * e[o], s += t[o] * t[o], r += e[o] * e[o];
+    const l = Math.sqrt(s) * Math.sqrt(r);
+    return l === 0 ? 0 : n / l;
+  }
+  chunk(t, e = 500, n = 50) {
+    const s = (d, p = "") => d ? Object.entries(d).flatMap(([a, m]) => {
+      const h = p ? `${p}${isNaN(+a) ? `.${a}` : `[${a}]`}` : a;
+      return typeof m == "object" && !Array.isArray(m) ? s(m, h) : `${h}: ${Array.isArray(m) ? m.join(", ") : m}`;
+    }) : [], l = (typeof t == "object" ? s(t) : t.split(`
+`)).flatMap((d) => [...d.split(/\s+/).filter(Boolean), `
+`]), o = [];
+    for (let d = 0; d < l.length; ) {
+      let p = "", a = d;
+      for (; a < l.length; ) {
+        const h = p + (p ? " " : "") + l[a];
         if (this.estimateTokens(h.replace(/\s*\n\s*/g, `
-`)) > e && u) break;
-        u = h, c++;
+`)) > e && p) break;
+        p = h, a++;
       }
-      const m = u.replace(/\s*\n\s*/g, `
+      const m = p.replace(/\s*\n\s*/g, `
 `).trim();
-      m && r.push(m), l = Math.max(c - s, c === l ? l + 1 : c);
+      m && o.push(m), d = Math.max(a - n, a === d ? d + 1 : a);
     }
-    return r;
-  }
-  embedding(t, e = 500, s = 50) {
-    const n = (d) => new Promise((r, l) => {
-      const u = this.embedId++;
-      this.embedQueue.set(u, { resolve: r, reject: l }), this.embedWorker?.postMessage({ id: u, text: d });
-    }), i = this.chunk(t, e, s);
-    return Promise.all(i.map(async (d, r) => ({
-      index: r,
-      embedding: await n(d),
-      text: d,
-      tokens: this.estimateTokens(d)
+    return o;
+  }
+  embedding(t, e = 500, n = 50) {
+    const s = (l) => new Promise((o, d) => {
+      const p = this.embedId++;
+      this.embedQueue.set(p, { resolve: o, reject: d }), this.embedWorker?.postMessage({ id: p, text: l });
+    }), r = this.chunk(t, e, n);
+    return Promise.all(r.map(async (l, o) => ({
+      index: o,
+      embedding: await s(l),
+      text: l,
+      tokens: this.estimateTokens(l)
     })));
   }
   /**
@@ -408,8 +409,8 @@ class G {
    */
   fuzzyMatch(t, ...e) {
     if (e.length < 2) throw new Error("Requires at least 2 strings to compare");
-    const s = (d, r = 10) => d.toLowerCase().split("").map((l, u) => l.charCodeAt(0) * (u + 1) % r / r).slice(0, r), n = s(t), i = e.map((d) => s(d)).map((d) => this.cosineSimilarity(n, d));
-    return { avg: i.reduce((d, r) => d + r, 0) / i.length, max: Math.max(...i), similarities: i };
+    const n = (l, o = 10) => l.toLowerCase().split("").map((d, p) => d.charCodeAt(0) * (p + 1) % o / o).slice(0, o), s = n(t), r = e.map((l) => n(l)).map((l) => this.cosineSimilarity(s, l));
+    return { avg: r.reduce((l, o) => l + o, 0) / r.length, max: Math.max(...r), similarities: r };
   }
   /**
    * Ask a question with JSON response
@@ -418,11 +419,11 @@ class G {
    * @returns {Promise<{} | {} | RegExpExecArray | null>}
    */
   async json(t, e) {
-    let s = await this.ask(t, {
+    let n = await this.ask(t, {
       system: "Respond using a JSON blob",
       ...e
     });
-    return s?.[0]?.content ? _(new RegExp("{[sS]*}").exec(s[0].content), {}) : {};
+    return n?.[0]?.content ? _(new RegExp("{[sS]*}").exec(n[0].content), {}) : {};
   }
   /**
    * Create a summary of some text
@@ -431,75 +432,102 @@ class G {
    * @param options LLM request options
    * @returns {Promise<string>} Summary
    */
-  summarize(t, e, s) {
-    return this.ask(t, { system: `Generate a brief summary <= ${e} tokens. Output nothing else`, temperature: 0.3, ...s }).then((n) => n.pop()?.content || null);
+  summarize(t, e, n) {
+    return this.ask(t, { system: `Generate a brief summary <= ${e} tokens. Output nothing else`, temperature: 0.3, ...n }).then((s) => s.pop()?.content || null);
   }
 }
-class B {
+class C {
   constructor(t) {
-    this.ai = t, t.options.whisper?.binary && (this.whisperModel = t.options.whisper?.model.endsWith(".bin") ? t.options.whisper?.model : t.options.whisper?.model + ".bin", this.downloadAsrModel());
+    if (this.ai = t, t.options.whisper?.binary && (this.whisperModel = t.options.whisper?.model.endsWith(".bin") ? t.options.whisper?.model : t.options.whisper?.model + ".bin", this.downloadAsrModel()), t.options.piper?.model) {
+      if (!t.options.piper.model.startsWith("http") || !t.options.piper.model.endsWith(".onnx"))
+        throw new Error("Piper model should be a URL to an onnx file to download");
+      if (E() != "linux" || T() != "x64" && T() != "arm64")
+        throw new Error("Piper TTS only supported on Linux x64/arm64");
+      this.piperBinary = y.join(import.meta.dirname, "../bin/piper"), this.downloadTtsModel();
+    }
   }
   downloads = {};
   whisperModel;
-  /**
-   * Convert audio to text using Auditory Speech Recognition
-   * @param {string} path Path to audio
-   * @param model Whisper model
-   * @returns {Promise<any>} Extracted text
-   */
+  piperBinary;
   asr(t, e = this.whisperModel) {
     if (!this.ai.options.whisper?.binary) throw new Error("Whisper not configured");
+    let n = () => {
+    };
+    const s = new Promise(async (r, l) => {
+      const o = await this.downloadAsrModel(e);
+      let d = "";
+      const p = P(this.ai.options.whisper?.binary, ["-nt", "-np", "-m", o, "-f", t], { stdio: ["ignore", "pipe", "ignore"] });
+      n = () => p.kill("SIGTERM"), p.on("error", (a) => l(a)), p.stdout.on("data", (a) => d += a.toString()), p.on("close", (a) => {
+        a === 0 ? r(d.trim() || null) : l(new Error(`Exit code ${a}`));
+      });
+    });
+    return Object.assign(s, { abort: n });
+  }
+  tts(t, e, n = this.ai.options.piper?.model) {
+    if (!this.piperBinary) throw new Error("Piper not configured");
+    if (!n) throw new Error("Invalid Piper model");
     let s = () => {
     };
-    return { response: new Promise((i, d) => {
-      this.downloadAsrModel(e).then((r) => {
-        let l = "";
-        const u = N(this.ai.options.whisper?.binary, ["-nt", "-np", "-m", r, "-f", t], { stdio: ["ignore", "pipe", "ignore"] });
-        s = () => u.kill("SIGTERM"), u.on("error", (c) => d(c)), u.stdout.on("data", (c) => l += c.toString()), u.on("close", (c) => {
-          c === 0 ? i(l.trim() || null) : d(new Error(`Exit code ${c}`));
-        });
+    const r = new Promise(async (l, o) => {
+      const d = await this.downloadTtsModel(n), p = e || y.join(M.tmpdir(), `piper_${Date.now()}.wav`), a = P(this.piperBinary, ["--model", d, "--output_file", p], {
+        stdio: ["pipe", "ignore", "ignore"],
+        env: { ...process.env, LD_LIBRARY_PATH: y.dirname(this.piperBinary) }
       });
-    }), abort: s };
+      s = () => a.kill("SIGTERM"), a.stdin.write(t), a.stdin.end(), a.on("error", (m) => o(m)), a.on("close", async (m) => {
+        if (m === 0)
+          if (e)
+            l(e);
+          else {
+            const h = await b.readFile(p);
+            await b.unlink(p).catch(() => {
+            }), l(h);
+          }
+        else
+          o(new Error(`Exit code ${m}`));
+      });
+    });
+    return Object.assign(r, { abort: s });
   }
-  /**
-   * Downloads the specified Whisper model if it is not already present locally.
-   *
-   * @param {string} model Whisper model that will be downloaded
-   * @return {Promise<string>} Absolute path to model file, resolves once downloaded
-   */
   async downloadAsrModel(t = this.whisperModel) {
     if (!this.ai.options.whisper?.binary) throw new Error("Whisper not configured");
     t.endsWith(".bin") || (t += ".bin");
-    const e = W.join(this.ai.options.path, t);
-    return await S.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((s) => s.arrayBuffer()).then((s) => Buffer.from(s)).then(async (s) => (await S.writeFile(e, s), delete this.downloads[t], e)), this.downloads[t]);
+    const e = y.join(this.ai.options.path, t);
+    return await b.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 b.writeFile(e, n), delete this.downloads[t], e)), this.downloads[t]);
+  }
+  async downloadTtsModel(t = this.ai.options.piper?.model) {
+    if (!t) throw new Error("Invalid Piper model");
+    const e = t.split("/").pop(), n = y.join(this.ai.options.path, e), [s, r] = await Promise.all([
+      b.stat(n).then(() => !0).catch(() => !1),
+      b.stat(n + ".json").then(() => !0).catch(() => !1)
+    ]);
+    return s && r ? n : this.downloads[e] ? this.downloads[e] : (this.downloads[e] = Promise.all([
+      s ? Promise.resolve() : fetch(t).then((l) => l.arrayBuffer()).then((l) => b.writeFile(n, Buffer.from(l))),
+      r ? Promise.resolve() : fetch(t + ".json").then((l) => l.arrayBuffer()).then((l) => b.writeFile(n + ".json", Buffer.from(l)))
+    ]).then(() => (delete this.downloads[e], n)), this.downloads[e]);
   }
 }
-class C {
+class K {
   constructor(t) {
     this.ai = t;
   }
   /**
    * Convert image to text using Optical Character Recognition
    * @param {string} path Path to image
-   * @returns {{abort: Function, response: Promise<string | null>}} Abort function & Promise of extracted text
+   * @returns {AbortablePromise<string | null>} Promise of extracted text with abort method
    */
   ocr(t) {
     let e;
-    return {
-      abort: () => {
-        e?.terminate();
-      },
-      response: new Promise(async (s) => {
-        e = await D(this.ai.options.tesseract?.model || "eng", 2, { cachePath: this.ai.options.path });
-        const { data: n } = await e.recognize(t);
-        await e.terminate(), s(n.text.trim() || null);
-      })
-    };
+    const n = new Promise(async (s) => {
+      e = await N(this.ai.options.tesseract?.model || "eng", 2, { cachePath: this.ai.options.path });
+      const { data: r } = await e.recognize(t);
+      await e.terminate(), s(r.text.trim() || null);
+    });
+    return Object.assign(n, { abort: () => e?.terminate() });
   }
 }
-class le {
+class pe {
   constructor(t) {
-    this.options = t, t.path || (t.path = j.tmpdir()), process.env.TRANSFORMERS_CACHE = t.path, this.audio = new B(this), this.language = new G(this), this.vision = new C(this);
+    this.options = t, t.path || (t.path = M.tmpdir()), process.env.TRANSFORMERS_CACHE = t.path, this.audio = new C(this), this.language = new Q(this), this.vision = new K(this);
   }
   /** Audio processing AI */
   audio;
@@ -508,38 +536,38 @@ class le {
   /** Vision processing AI */
   vision;
 }
-const Q = {
+const V = {
   name: "cli",
   description: "Use the command line interface, returns any output",
   args: { command: { type: "string", description: "Command to run", required: !0 } },
-  fn: (p) => J`${p.command}`
-}, me = {
+  fn: (u) => H`${u.command}`
+}, ue = {
   name: "get_datetime",
   description: "Get current date and time",
   args: {},
   fn: async () => (/* @__PURE__ */ new Date()).toISOString()
-}, de = {
+}, fe = {
   name: "exec",
   description: "Run code/scripts",
   args: {
     language: { type: "string", description: "Execution language", enum: ["cli", "node", "python"], required: !0 },
     code: { type: "string", description: "Code to execute", required: !0 }
   },
-  fn: async (p, t) => {
+  fn: async (u, t) => {
     try {
-      switch (p.type) {
+      switch (u.type) {
         case "bash":
-          return await Q.fn({ command: p.code }, t);
+          return await V.fn({ command: u.code }, t);
         case "node":
-          return await K.fn({ code: p.code }, t);
+          return await Y.fn({ code: u.code }, t);
         case "python":
-          return await V.fn({ code: p.code }, t);
+          return await X.fn({ code: u.code }, t);
       }
     } catch (e) {
       return { error: e?.message || e.toString() };
     }
   }
-}, ue = {
+}, he = {
   name: "fetch",
   description: "Make HTTP request to URL",
   args: {
@@ -548,54 +576,54 @@ const Q = {
     headers: { type: "object", description: "HTTP headers to send", default: {} },
     body: { type: "object", description: "HTTP body to send" }
   },
-  fn: (p) => new M({ url: p.url, headers: p.headers }).request({ method: p.method || "GET", body: p.body })
-}, K = {
+  fn: (u) => new q({ url: u.url, headers: u.headers }).request({ method: u.method || "GET", body: u.body })
+}, Y = {
   name: "exec_javascript",
   description: "Execute commonjs javascript",
   args: {
     code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
-  fn: async (p) => {
-    const t = A(null), e = await q({ console: t }, p.code, !0).catch((s) => t.output.error.push(s));
+  fn: async (u) => {
+    const t = O(null), e = await $({ console: t }, u.code, !0).catch((n) => t.output.error.push(n));
     return { ...t.output, return: e, stdout: void 0, stderr: void 0 };
   }
-}, V = {
+}, X = {
   name: "exec_javascript",
   description: "Execute commonjs javascript",
   args: {
     code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
-  fn: async (p) => ({ result: H`python -c "${p.code}"` })
-}, pe = {
+  fn: async (u) => ({ result: J`python -c "${u.code}"` })
+}, ge = {
   name: "search",
   description: "Use a search engine to find relevant URLs, should be changed with fetch to scrape sources",
   args: {
     query: { type: "string", description: "Search string", required: !0 },
     length: { type: "string", description: "Number of results to return", default: 5 }
   },
-  fn: async (p) => {
-    const t = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(p.query)}`, {
+  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((i) => i.text());
-    let e, s = /<a .*?href="(.+?)".+?<\/a>/g;
-    const n = new P();
-    for (; (e = s.exec(t)) !== null; ) {
-      let i = /uddg=(.+)&amp?/.exec(decodeURIComponent(e[1]))?.[1];
-      if (i && (i = decodeURIComponent(i)), i && n.add(i), n.size >= (p.length || 5)) break;
+    }).then((r) => r.text());
+    let e, n = /<a .*?href="(.+?)".+?<\/a>/g;
+    const s = new v();
+    for (; (e = n.exec(t)) !== null; ) {
+      let r = /uddg=(.+)&amp?/.exec(decodeURIComponent(e[1]))?.[1];
+      if (r && (r = decodeURIComponent(r)), r && s.add(r), s.size >= (u.length || 5)) break;
     }
-    return n;
+    return s;
   }
 };
 export {
-  le as Ai,
-  I as Anthropic,
-  Q as CliTool,
-  me as DateTimeTool,
-  de as ExecTool,
-  ue as FetchTool,
-  K as JSTool,
-  G as LLM,
-  V as PythonTool,
-  pe as SearchTool
+  pe as Ai,
+  F as Anthropic,
+  V as CliTool,
+  ue as DateTimeTool,
+  fe as ExecTool,
+  he as FetchTool,
+  Y as JSTool,
+  Q as LLM,
+  X as PythonTool,
+  ge as SearchTool
 };
 //# sourceMappingURL=index.mjs.map