@ztimson/ai-utils 0.1.16 → 0.1.18

package/dist/index.mjs

@@ -1,39 +1,33 @@
-import { createWorker as S } from "tesseract.js";
-import { objectMap as _, JSONAttemptParse as w, findByProp as b, JSONSanitize as y, Http as j, consoleInterceptor as T, fn as q, ASet as v } from "@ztimson/utils";
-import { Anthropic as P } from "@anthropic-ai/sdk";
-import { Ollama as A } from "ollama";
-import { OpenAI as E } from "openai";
-import x from "node:fs/promises";
+import { createWorker as D } from "tesseract.js";
+import { objectMap as k, JSONAttemptParse as b, findByProp as x, JSONSanitize as y, Http as T, consoleInterceptor as q, fn as v, ASet as P } from "@ztimson/utils";
+import { Anthropic as A } from "@anthropic-ai/sdk";
+import { Ollama as E } from "ollama";
+import { OpenAI as M } from "openai";
+import j from "node:fs/promises";
 import O from "node:path";
-import * as g from "@tensorflow/tfjs";
-import { spawn as M } from "node:child_process";
-import { $ as U, $Sync as $ } from "@ztimson/node-utils";
-class k {
+import * as _ from "@tensorflow/tfjs";
+import { spawn as U } from "node:child_process";
+import { $, $Sync as L } from "@ztimson/node-utils";
+class S {
 }
-class L extends k {
+class R extends S {
   constructor(t, e, n) {
-    super(), this.ai = t, this.apiToken = e, this.model = n, this.client = new P({ apiKey: e });
+    super(), this.ai = t, this.apiToken = e, this.model = n, this.client = new A({ apiKey: e });
   }
   client;
   toStandard(t) {
-    const e = [];
-    for (let n = 0; n < t.length; n++) {
-      const i = t[n];
-      if (typeof i.content != "string" && (i.role == "assistant" ? i.content.filter((o) => o.type == "tool_use").forEach((o) => {
-        e.push({ role: "tool", id: o.id, name: o.name, args: o.input });
-      }) : i.role == "user" && i.content.filter((o) => o.type == "tool_result").forEach((o) => {
-        const p = e.find((c) => c.id == o.tool_use_id);
-        p && (p[o.is_error ? "error" : "content"] = o.content);
-      }), i.content = i.content.filter((o) => o.type == "text").map((o) => o.text).join(`
-
-`)), i.content) {
-        const o = e.at(-1);
-        o && o.role == "assistant" && i.role == "assistant" ? o.content += `
+    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 m = t.find((u) => u.id == o.tool_use_id);
+        m[o.is_error ? "error" : "content"] = o.content;
+      }), t[n].content = t[n].content.filter((o) => o.type == "text").map((o) => o.text).join(`
 
-` + i.content : e.push({ role: i.role, content: i.content });
-      }
+`)), t[n].timestamp || (t[n].timestamp = Date.now());
     }
-    return e;
+    return t.filter((e) => !!e.content);
   }
   fromStandard(t) {
     for (let e = 0; e < t.length; e++)
@@ -42,17 +36,17 @@ class L extends k {
         t.splice(
           e,
           1,
-          { 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 }] }
+          { role: "assistant", content: [{ type: "tool_use", id: n.id, name: n.name, input: n.args }], timestamp: n.timestamp },
+          { role: "user", content: [{ type: "tool_result", tool_use_id: n.id, is_error: !!n.error, content: n.error || n.content }], timestamp: Date.now() }
         ), e++;
       }
     return t;
   }
   ask(t, e = {}) {
-    const n = new AbortController(), i = new Promise(async (o, p) => {
-      let c = this.fromStandard([...e.history || [], { role: "user", content: t }]);
+    const n = new AbortController(), o = new Promise(async (m, u) => {
+      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 m = {
+      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 || "",
@@ -62,154 +56,166 @@ class L extends k {
           description: a.description,
           input_schema: {
             type: "object",
-            properties: a.args ? _(a.args, (r, d) => ({ ...d, required: void 0 })) : {},
-            required: a.args ? Object.entries(a.args).filter((r) => r[1].required).map((r) => r[0]) : []
+            properties: a.args ? k(a.args, (s, l) => ({ ...l, required: void 0 })) : {},
+            required: a.args ? Object.entries(a.args).filter((s) => s[1].required).map((s) => s[0]) : []
           },
           fn: void 0
         })),
         messages: c,
         stream: !!e.stream
       };
-      let l, s = !0;
+      let i;
+      const r = [];
       do {
-        if (l = await this.client.messages.create(m), e.stream) {
-          s || e.stream({ text: `
+        if (i = await this.client.messages.create(d), e.stream) {
+          r.length && e.stream({ text: `
 
-` }), s = !1, l.content = [];
-          for await (const r of l) {
+` }), i.content = [];
+          for await (const s of i) {
             if (n.signal.aborted) break;
-            if (r.type === "content_block_start")
-              r.content_block.type === "text" ? l.content.push({ type: "text", text: "" }) : r.content_block.type === "tool_use" && l.content.push({ type: "tool_use", id: r.content_block.id, name: r.content_block.name, input: "" });
-            else if (r.type === "content_block_delta")
-              if (r.delta.type === "text_delta") {
-                const d = r.delta.text;
-                l.content.at(-1).text += d, e.stream({ text: d });
-              } else r.delta.type === "input_json_delta" && (l.content.at(-1).input += r.delta.partial_json);
-            else if (r.type === "content_block_stop") {
-              const d = l.content.at(-1);
-              d.input != null && (d.input = d.input ? w(d.input, {}) : {});
-            } else if (r.type === "message_stop")
+            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: "" });
+            else if (s.type === "content_block_delta")
+              if (s.delta.type === "text_delta") {
+                const l = s.delta.text;
+                i.content.at(-1).text += l, e.stream({ text: l });
+              } else s.delta.type === "input_json_delta" && (i.content.at(-1).input += s.delta.partial_json);
+            else if (s.type === "content_block_stop") {
+              const l = i.content.at(-1);
+              l.input != null && (l.input = l.input ? b(l.input, {}) : {});
+            } else if (s.type === "message_stop")
               break;
           }
         }
-        const a = l.content.filter((r) => r.type === "tool_use");
+        r.push({ role: "assistant", content: i.content, timestamp: Date.now() });
+        const a = i.content.filter((s) => s.type === "tool_use");
         if (a.length && !n.signal.aborted) {
-          c.push({ role: "assistant", content: l.content });
-          const r = await Promise.all(a.map(async (d) => {
-            const f = e.tools?.find(b("name", d.name));
-            if (!f) return { tool_use_id: d.id, is_error: !0, content: "Tool not found" };
+          c.push({ role: "assistant", content: i.content, timestamp: Date.now() });
+          const l = { role: "user", content: await Promise.all(a.map(async (f) => {
+            const h = e.tools?.find(x("name", f.name));
+            if (!h) return { tool_use_id: f.id, is_error: !0, content: "Tool not found" };
             try {
-              const h = await f.fn(d.input, this.ai);
-              return { type: "tool_result", tool_use_id: d.id, content: y(h) };
-            } catch (h) {
-              return { type: "tool_result", tool_use_id: d.id, is_error: !0, content: h?.message || h?.toString() || "Unknown" };
+              const g = await h.fn(f.input, this.ai);
+              return { type: "tool_result", tool_use_id: f.id, content: y(g) };
+            } catch (g) {
+              return { type: "tool_result", tool_use_id: f.id, is_error: !0, content: g?.message || g?.toString() || "Unknown" };
             }
-          }));
-          c.push({ role: "user", content: r }), m.messages = c;
+          })), timestamp: Date.now() };
+          c.push(l), r.push(l), d.messages = c;
         }
-      } while (!n.signal.aborted && l.content.some((a) => a.type === "tool_use"));
-      e.stream && e.stream({ done: !0 }), o(this.toStandard([...c, {
-        role: "assistant",
-        content: l.content.filter((a) => a.type == "text").map((a) => a.text).join(`
+      } while (!n.signal.aborted && i.content.some((a) => a.type === "tool_use"));
+      const w = r.filter((a) => a.role === "assistant").map((a) => a.content.filter((s) => s.type == "text").map((s) => s.text).join(`
 
-`)
-      }]));
+`)).filter((a) => a).join(`
+
+`);
+      e.stream && e.stream({ done: !0 }), m(this.toStandard([...c, { role: "assistant", content: w, timestamp: Date.now() }]));
     });
-    return Object.assign(i, { abort: () => n.abort() });
+    return Object.assign(o, { abort: () => n.abort() });
   }
 }
-class R extends k {
+class I extends S {
   constructor(t, e, n) {
-    super(), this.ai = t, this.host = e, this.model = n, this.client = new A({ host: e });
+    super(), this.ai = t, this.host = e, this.model = n, this.client = new E({ host: e });
   }
   client;
   toStandard(t) {
-    for (let e = 0; e < t.length; e++)
+    for (let e = 0; e < t.length; e++) {
       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 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 };
+        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());
+    }
     return t;
   }
   fromStandard(t) {
-    return t.map((e) => e.role != "tool" ? e : { role: "tool", tool_name: e.name, content: e.error || e.content });
+    return t.map((e) => e.role != "tool" ? e : { role: "tool", tool_name: e.name, content: e.error || e.content, timestamp: e.timestamp });
   }
   ask(t, e = {}) {
-    const n = new AbortController(), i = new Promise(async (o, p) => {
-      let c = e.system || this.ai.options.system, m = this.fromStandard([...e.history || [], { role: "user", content: t }]);
-      m[0].roll == "system" && (c ? m.shift() : c = m.shift()), e.compress && (m = await this.ai.llm.compress(m, e.compress.max, e.compress.min)), e.system && m.unshift({ role: "system", content: c });
-      const l = {
+    const n = new AbortController(), o = new Promise(async (m, u) => {
+      let c = e.system || this.ai.options.system, d = this.fromStandard([...e.history || [], { role: "user", content: t, timestamp: Date.now() }]);
+      d[0].roll == "system" && (c ? d.shift() : c = d.shift()), e.compress && (d = await this.ai.llm.compress(d, e.compress.max, e.compress.min)), e.system && d.unshift({ role: "system", content: c });
+      const i = {
         model: e.model || this.model,
-        messages: m,
+        messages: d,
         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((a) => ({
+        tools: (e.tools || this.ai.options.tools || []).map((s) => ({
           type: "function",
           function: {
-            name: a.name,
-            description: a.description,
+            name: s.name,
+            description: s.description,
             parameters: {
               type: "object",
-              properties: a.args ? _(a.args, (r, d) => ({ ...d, required: void 0 })) : {},
-              required: a.args ? Object.entries(a.args).filter((r) => r[1].required).map((r) => r[0]) : []
+              properties: s.args ? k(s.args, (l, f) => ({ ...f, required: void 0 })) : {},
+              required: s.args ? Object.entries(s.args).filter((l) => l[1].required).map((l) => l[0]) : []
             }
           }
         }))
       };
-      let s;
+      let r;
+      const w = [];
       do {
-        if (s = await this.client.chat(l), e.stream) {
-          s.message = { role: "assistant", content: "", tool_calls: [] };
-          for await (const a of s)
-            if (n.signal.aborted || (a.message?.content && (s.message.content += a.message.content, e.stream({ text: a.message.content })), a.message?.tool_calls && (s.message.tool_calls = a.message.tool_calls), a.done)) break;
+        if (r = await this.client.chat(i), e.stream) {
+          w.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;
         }
-        if (s.message?.tool_calls?.length && !n.signal.aborted) {
-          m.push(s.message);
-          const a = await Promise.all(s.message.tool_calls.map(async (r) => {
-            const d = (e.tools || this.ai.options.tools)?.find(b("name", r.function.name));
-            if (!d) return { role: "tool", tool_name: r.function.name, content: '{"error": "Tool not found"}' };
-            const f = typeof r.function.arguments == "string" ? w(r.function.arguments, {}) : r.function.arguments;
+        if (w.push({ role: "assistant", content: r.message?.content, timestamp: Date.now() }), r.message?.tool_calls?.length && !n.signal.aborted) {
+          d.push({ ...r.message, timestamp: Date.now() });
+          const s = await Promise.all(r.message.tool_calls.map(async (l) => {
+            const f = (e.tools || this.ai.options.tools)?.find(x("name", l.function.name));
+            if (!f) return { role: "tool", tool_name: l.function.name, content: '{"error": "Tool not found"}', timestamp: Date.now() };
+            const h = typeof l.function.arguments == "string" ? b(l.function.arguments, {}) : l.function.arguments;
             try {
-              const h = await d.fn(f, this.ai);
-              return { role: "tool", tool_name: r.function.name, args: f, content: y(h) };
-            } catch (h) {
-              return { role: "tool", tool_name: r.function.name, args: f, content: y({ error: h?.message || h?.toString() || "Unknown" }) };
+              const g = await f.fn(h, this.ai);
+              return { role: "tool", tool_name: l.function.name, args: h, content: y(g), timestamp: Date.now() };
+            } catch (g) {
+              return { role: "tool", tool_name: l.function.name, args: h, content: y({ error: g?.message || g?.toString() || "Unknown" }), timestamp: Date.now() };
             }
           }));
-          m.push(...a), l.messages = m;
+          d.push(...s), w.push(...s), i.messages = d;
         }
-      } while (!n.signal.aborted && s.message?.tool_calls?.length);
-      e.stream && e.stream({ done: !0 }), o(this.toStandard([...m, { role: "assistant", content: s.message?.content }]));
+      } while (!n.signal.aborted && r.message?.tool_calls?.length);
+      const a = w.filter((s) => s.role === "assistant").map((s) => s.content).filter((s) => s).join(`
+
+`);
+      e.stream && e.stream({ done: !0 }), m(this.toStandard([...d, { role: "assistant", content: a, timestamp: Date.now() }]));
     });
-    return Object.assign(i, { abort: () => n.abort() });
+    return Object.assign(o, { abort: () => n.abort() });
   }
 }
-class J extends k {
+class J 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 = t[e];
       if (n.role === "assistant" && n.tool_calls) {
-        const i = n.tool_calls.map((o) => ({
+        const o = n.tool_calls.map((m) => ({
           role: "tool",
-          id: o.id,
-          name: o.function.name,
-          args: w(o.function.arguments, {})
+          id: m.id,
+          name: m.function.name,
+          args: b(m.function.arguments, {}),
+          timestamp: n.timestamp
         }));
-        t.splice(e, 1, ...i), e += i.length - 1;
+        t.splice(e, 1, ...o), e += o.length - 1;
       } else if (n.role === "tool" && n.content) {
-        const i = t.find((o) => n.tool_call_id == o.id);
-        i && (n.content.includes('"error":') ? i.error = n.content : i.content = n.content), t.splice(e, 1), e--;
+        const o = t.find((m) => n.tool_call_id == m.id);
+        o && (n.content.includes('"error":') ? o.error = n.content : o.content = n.content), t.splice(e, 1), e--;
       }
+      t[e]?.timestamp || (t[e].timestamp = Date.now());
     }
     return t;
   }
@@ -219,69 +225,78 @@ class J extends k {
       content: null,
       tool_calls: [{ id: n.id, type: "function", function: { name: n.name, arguments: JSON.stringify(n.args) } }],
       refusal: null,
-      annotations: []
+      annotations: [],
+      timestamp: n.timestamp
     }, {
       role: "tool",
       tool_call_id: n.id,
-      content: n.error || n.content
+      content: n.error || n.content,
+      timestamp: Date.now()
     }) : e.push(n), e), []);
   }
   ask(t, e = {}) {
-    const n = new AbortController(), i = new Promise(async (o, p) => {
-      let c = this.fromStandard([...e.history || [], { role: "user", content: t }]);
+    const n = new AbortController(), o = new Promise(async (m, u) => {
+      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 m = {
+      const d = {
         model: e.model || this.model,
         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((s) => ({
+        tools: (e.tools || this.ai.options.tools || []).map((a) => ({
           type: "function",
           function: {
-            name: s.name,
-            description: s.description,
+            name: a.name,
+            description: a.description,
             parameters: {
               type: "object",
-              properties: s.args ? _(s.args, (a, r) => ({ ...r, required: void 0 })) : {},
-              required: s.args ? Object.entries(s.args).filter((a) => a[1].required).map((a) => a[0]) : []
+              properties: a.args ? k(a.args, (s, l) => ({ ...l, required: void 0 })) : {},
+              required: a.args ? Object.entries(a.args).filter((s) => s[1].required).map((s) => s[0]) : []
             }
           }
         }))
       };
-      let l;
+      let i;
+      const r = [];
       do {
-        if (l = await this.client.chat.completions.create(m), e.stream) {
-          l.choices = [];
-          for await (const a of l) {
+        if (i = await this.client.chat.completions.create(d), e.stream) {
+          r.length && e.stream({ text: `
+
+` }), i.choices = [{ message: { content: "", tool_calls: [] } }];
+          for await (const s of i) {
             if (n.signal.aborted) break;
-            a.choices[0].delta.content && e.stream({ text: a.choices[0].delta.content });
+            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);
           }
         }
-        const s = l.choices[0].message.tool_calls || [];
-        if (s.length && !n.signal.aborted) {
-          c.push(l.choices[0].message);
-          const a = await Promise.all(s.map(async (r) => {
-            const d = e.tools?.find(b("name", r.function.name));
-            if (!d) return { role: "tool", tool_call_id: r.id, content: '{"error": "Tool not found"}' };
+        r.push({ role: "assistant", content: i.choices[0].message.content || "", timestamp: Date.now() });
+        const a = i.choices[0].message.tool_calls || [];
+        if (a.length && !n.signal.aborted) {
+          c.push({ ...i.choices[0].message, timestamp: Date.now() });
+          const s = await Promise.all(a.map(async (l) => {
+            const f = e.tools?.find(x("name", l.function.name));
+            if (!f) return { role: "tool", tool_call_id: l.id, content: '{"error": "Tool not found"}', timestamp: Date.now() };
             try {
-              const f = w(r.function.arguments, {}), h = await d.fn(f, this.ai);
-              return { role: "tool", tool_call_id: r.id, content: y(h) };
-            } catch (f) {
-              return { role: "tool", tool_call_id: r.id, content: y({ error: f?.message || f?.toString() || "Unknown" }) };
+              const h = b(l.function.arguments, {}), g = await f.fn(h, this.ai);
+              return { role: "tool", tool_call_id: l.id, content: y(g), timestamp: Date.now() };
+            } catch (h) {
+              return { role: "tool", tool_call_id: l.id, content: y({ error: h?.message || h?.toString() || "Unknown" }), timestamp: Date.now() };
             }
           }));
-          c.push(...a), m.messages = c;
+          c.push(...s), r.push(...s), d.messages = c;
         }
-      } while (!n.signal.aborted && l.choices?.[0]?.message?.tool_calls?.length);
-      e.stream && e.stream({ done: !0 }), o(this.toStandard([...c, { role: "assistant", content: l.choices[0].message.content || "" }]));
+      } while (!n.signal.aborted && i.choices?.[0]?.message?.tool_calls?.length);
+      const w = r.filter((a) => a.role === "assistant").map((a) => a.content).filter((a) => a).join(`
+
+`);
+      e.stream && e.stream({ done: !0 }), m(this.toStandard([...c, { role: "assistant", content: w, timestamp: Date.now() }]));
     });
-    return Object.assign(i, { abort: () => n.abort() });
+    return Object.assign(o, { abort: () => n.abort() });
   }
 }
 class W {
   constructor(t, e) {
-    this.ai = t, this.options = e, e.anthropic?.token && (this.providers.anthropic = new L(this.ai, e.anthropic.token, e.anthropic.model)), e.ollama?.host && (this.providers.ollama = new R(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 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));
   }
   providers = {};
   /**
@@ -303,17 +318,17 @@ class W {
    * @param {LLMRequest} options LLM options
    * @returns {Promise<LLMMessage[]>} New chat history will summary at index 0
    */
-  async compress(t, e, n, i) {
+  async compress(t, e, n, o) {
     if (this.estimateTokens(t) < e) return t;
-    let o = 0, p = 0;
-    for (let s of t.toReversed())
-      if (p += this.estimateTokens(s.content), p < n) o++;
+    let m = 0, u = 0;
+    for (let r of t.toReversed())
+      if (u += this.estimateTokens(r.content), u < n) m++;
       else break;
-    if (t.length <= o) return t;
-    const c = o == 0 ? [] : t.slice(-o), m = (o == 0 ? t : t.slice(0, -o)).filter((s) => s.role === "assistant" || s.role === "user");
-    return [{ role: "assistant", content: `Conversation Summary: ${await this.summarize(m.map((s) => `${s.role}: ${s.content}`).join(`
+    if (t.length <= m) return t;
+    const c = m == 0 ? [] : t.slice(-m), d = (m == 0 ? t : t.slice(0, -m)).filter((r) => r.role === "assistant" || r.role === "user");
+    return [{ role: "assistant", content: `Conversation Summary: ${await this.summarize(d.map((r) => `${r.role}: ${r.content}`).join(`
 
-`), 250, i)}` }, ...c];
+`), 250, o)}`, timestamp: Date.now() }, ...c];
   }
   /**
    * Estimate variable as tokens
@@ -335,7 +350,7 @@ class W {
       system: "Respond using a JSON blob",
       ...e
     });
-    return n?.[0]?.content ? w(new RegExp("{[sS]*}").exec(n[0].content), {}) : {};
+    return n?.[0]?.content ? b(new RegExp("{[sS]*}").exec(n[0].content), {}) : {};
   }
   /**
    * Create a summary of some text
@@ -345,10 +360,10 @@ 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((i) => i.pop()?.content || null);
+    return this.ask(t, { system: `Generate a brief summary <= ${e} tokens. Output nothing else`, temperature: 0.3, ...n }).then((o) => o.pop()?.content || null);
   }
 }
-class X {
+class Z {
   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());
   }
@@ -366,12 +381,12 @@ class X {
     if (!this.options.whisper?.binary) throw new Error("Whisper not configured");
     let n = () => {
     };
-    return { response: new Promise((o, p) => {
+    return { response: new Promise((m, u) => {
       this.downloadAsrModel(e).then((c) => {
-        let m = "";
-        const l = M(this.options.whisper?.binary, ["-nt", "-np", "-m", c, "-f", t], { stdio: ["ignore", "pipe", "ignore"] });
-        n = () => l.kill("SIGTERM"), l.on("error", (s) => p(s)), l.stdout.on("data", (s) => m += s.toString()), l.on("close", (s) => {
-          s === 0 ? o(m.trim() || null) : p(new Error(`Exit code ${s}`));
+        let d = "";
+        const i = U(this.options.whisper?.binary, ["-nt", "-np", "-m", c, "-f", t], { stdio: ["ignore", "pipe", "ignore"] });
+        n = () => i.kill("SIGTERM"), i.on("error", (r) => u(r)), i.stdout.on("data", (r) => d += r.toString()), i.on("close", (r) => {
+          r === 0 ? m(d.trim() || null) : u(new Error(`Exit code ${r}`));
         });
       });
     }), abort: n };
@@ -386,7 +401,7 @@ class X {
     if (!this.options.whisper?.binary) throw new Error("Whisper not configured");
     t.endsWith(".bin") || (t += ".bin");
     const e = O.join(this.options.whisper.path, t);
-    return await x.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 x.writeFile(e, n), delete this.downloads[t], e)), this.downloads[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]);
   }
   /**
    * Convert image to text using Optical Character Recognition
@@ -400,9 +415,9 @@ class X {
         e?.terminate();
       },
       response: new Promise(async (n) => {
-        e = await S("eng");
-        const { data: i } = await e.recognize(t);
-        await e.terminate(), n(i.text.trim() || null);
+        e = await D("eng");
+        const { data: o } = await e.recognize(t);
+        await e.terminate(), n(o.text.trim() || null);
       })
     };
   }
@@ -414,46 +429,46 @@ class X {
    */
   semanticSimilarity(t, ...e) {
     if (e.length < 2) throw new Error("Requires at least 2 strings to compare");
-    const n = (c, m = 10) => c.toLowerCase().split("").map((l, s) => l.charCodeAt(0) * (s + 1) % m / m).slice(0, m), i = (c, m) => {
-      if (c.length !== m.length) throw new Error("Vectors must be same length");
-      const l = g.tensor1d(c), s = g.tensor1d(m), a = g.dot(l, s), r = g.norm(l), d = g.norm(s);
-      return r.dataSync()[0] === 0 || d.dataSync()[0] === 0 ? 0 : a.dataSync()[0] / (r.dataSync()[0] * d.dataSync()[0]);
-    }, o = n(t), p = e.map((c) => n(c)).map((c) => i(o, c));
-    return { avg: p.reduce((c, m) => c + m, 0) / p.length, max: Math.max(...p), similarities: p };
+    const n = (c, d = 10) => c.toLowerCase().split("").map((i, r) => i.charCodeAt(0) * (r + 1) % d / d).slice(0, d), o = (c, d) => {
+      if (c.length !== d.length) throw new Error("Vectors must be same length");
+      const i = _.tensor1d(c), r = _.tensor1d(d), w = _.dot(i, r), a = _.norm(i), s = _.norm(r);
+      return a.dataSync()[0] === 0 || s.dataSync()[0] === 0 ? 0 : w.dataSync()[0] / (a.dataSync()[0] * s.dataSync()[0]);
+    }, m = n(t), u = e.map((c) => n(c)).map((c) => o(m, c));
+    return { avg: u.reduce((c, d) => c + d, 0) / u.length, max: Math.max(...u), similarities: u };
   }
 }
-const I = {
+const N = {
   name: "cli",
   description: "Use the command line interface, returns any output",
   args: { command: { type: "string", description: "Command to run", required: !0 } },
-  fn: (u) => U`${u.command}`
-}, Y = {
+  fn: (p) => $`${p.command}`
+}, ee = {
   name: "get_datetime",
   description: "Get current date and time",
   args: {},
   fn: async () => (/* @__PURE__ */ new Date()).toISOString()
-}, Z = {
+}, te = {
   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 (u, t) => {
+  fn: async (p, t) => {
     try {
-      switch (u.type) {
+      switch (p.type) {
         case "bash":
-          return await I.fn({ command: u.code }, t);
+          return await N.fn({ command: p.code }, t);
         case "node":
-          return await N.fn({ code: u.code }, t);
+          return await z.fn({ code: p.code }, t);
         case "python":
-          return await z.fn({ code: u.code }, t);
+          return await G.fn({ code: p.code }, t);
       }
     } catch (e) {
       return { error: e?.message || e.toString() };
     }
   }
-}, ee = {
+}, ne = {
   name: "fetch",
   description: "Make HTTP request to URL",
   args: {
@@ -462,54 +477,54 @@ const I = {
     headers: { type: "object", description: "HTTP headers to send", default: {} },
     body: { type: "object", description: "HTTP body to send" }
   },
-  fn: (u) => new j({ url: u.url, headers: u.headers }).request({ method: u.method || "GET", body: u.body })
-}, N = {
+  fn: (p) => new T({ url: p.url, headers: p.headers }).request({ method: p.method || "GET", body: p.body })
+}, z = {
   name: "exec_javascript",
   description: "Execute commonjs javascript",
   args: {
     code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
-  fn: async (u) => {
-    const t = T(null), e = await q({ console: t }, u.code, !0).catch((n) => t.output.error.push(n));
+  fn: async (p) => {
+    const t = q(null), e = await v({ console: t }, p.code, !0).catch((n) => t.output.error.push(n));
     return { ...t.output, return: e, stdout: void 0, stderr: void 0 };
   }
-}, z = {
+}, G = {
   name: "exec_javascript",
   description: "Execute commonjs javascript",
   args: {
     code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
-  fn: async (u) => ({ result: $`python -c "${u.code}"` })
-}, te = {
+  fn: async (p) => ({ result: L`python -c "${p.code}"` })
+}, se = {
   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 (u) => {
-    const t = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(u.query)}`, {
+  fn: async (p) => {
+    const t = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(p.query)}`, {
       headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)", "Accept-Language": "en-US,en;q=0.9" }
-    }).then((o) => o.text());
+    }).then((m) => m.text());
     let e, n = /<a .*?href="(.+?)".+?<\/a>/g;
-    const i = new v();
+    const o = new P();
     for (; (e = n.exec(t)) !== null; ) {
-      let o = /uddg=(.+)&amp?/.exec(decodeURIComponent(e[1]))?.[1];
-      if (o && (o = decodeURIComponent(o)), o && i.add(o), i.size >= (u.length || 5)) break;
+      let m = /uddg=(.+)&amp?/.exec(decodeURIComponent(e[1]))?.[1];
+      if (m && (m = decodeURIComponent(m)), m && o.add(m), o.size >= (p.length || 5)) break;
     }
-    return i;
+    return o;
   }
 };
 export {
-  X as Ai,
-  L as Anthropic,
-  I as CliTool,
-  Y as DateTimeTool,
-  Z as ExecTool,
-  ee as FetchTool,
-  N as JSTool,
+  Z as Ai,
+  R as Anthropic,
+  N as CliTool,
+  ee as DateTimeTool,
+  te as ExecTool,
+  ne as FetchTool,
+  z as JSTool,
   W as LLM,
-  z as PythonTool,
-  te as SearchTool
+  G as PythonTool,
+  se as SearchTool
 };
 //# sourceMappingURL=index.mjs.map