@ztimson/ai-utils 0.8.0 → 0.8.1

package/dist/index.mjs

@@ -1,40 +1,40 @@
-import * as O from "node:os";
-import { tmpdir as q } from "node:os";
-import { objectMap as $, JSONAttemptParse as _, findByProp as P, JSONSanitize as x, clean as R, Http as U, consoleInterceptor as z, fn as N, ASet as L } from "@ztimson/utils";
-import { Anthropic as C } from "@anthropic-ai/sdk";
-import { OpenAI as W } from "openai";
-import { fileURLToPath as I } from "url";
-import { join as J, dirname as D } from "path";
-import { spawn as k, execSync as F } from "node:child_process";
-import { mkdtempSync as H } from "node:fs";
-import b from "node:fs/promises";
-import * as j from "node:path";
-import E, { join as T } from "node:path";
-import { createWorker as G } from "tesseract.js";
-import * as B from "cheerio";
-import { $ as K, $Sync as V } from "@ztimson/node-utils";
-class v {
+import * as U from "node:os";
+import { tmpdir as W } from "node:os";
+import { objectMap as q, JSONAttemptParse as _, findByProp as O, JSONSanitize as S, clean as z, Http as N, consoleInterceptor as C, fn as L, ASet as J } from "@ztimson/utils";
+import { Anthropic as F } from "@anthropic-ai/sdk";
+import { OpenAI as I } from "openai";
+import { fileURLToPath as H } from "url";
+import { join as D, dirname as G } from "path";
+import { spawn as b, execSync as B } from "node:child_process";
+import { mkdtempSync as K } from "node:fs";
+import w from "node:fs/promises";
+import * as $ from "node:path";
+import v, { join as M } from "node:path";
+import { createWorker as V } from "tesseract.js";
+import * as Y from "cheerio";
+import { $ as Z, $Sync as Q } from "@ztimson/node-utils";
+class R {
 }
-class Y extends v {
+class X extends R {
   constructor(r, e, t) {
-    super(), this.ai = r, this.apiToken = e, this.model = t, this.client = new C({ apiKey: e });
+    super(), this.ai = r, this.apiToken = e, this.model = t, this.client = new F({ apiKey: e });
   }
   client;
   toStandard(r) {
     const e = Date.now(), t = [];
-    for (let c of r)
-      if (typeof c.content == "string")
-        t.push({ timestamp: e, ...c });
+    for (let l of r)
+      if (typeof l.content == "string")
+        t.push({ timestamp: e, ...l });
       else {
-        const o = c.content?.filter((s) => s.type == "text").map((s) => s.text).join(`
+        const n = l.content?.filter((s) => s.type == "text").map((s) => s.text).join(`
 
 `);
-        o && t.push({ timestamp: e, role: c.role, content: o }), c.content.forEach((s) => {
+        n && t.push({ timestamp: e, role: l.role, content: n }), l.content.forEach((s) => {
           if (s.type == "tool_use")
             t.push({ timestamp: e, role: "tool", id: s.id, name: s.name, args: s.input, content: void 0 });
           else if (s.type == "tool_result") {
-            const l = t.findLast((n) => n.id == s.tool_use_id);
-            l && (l[s.is_error ? "error" : "content"] = s.content);
+            const c = t.findLast((a) => a.id == s.tool_use_id);
+            c && (c[s.is_error ? "error" : "content"] = s.content);
           }
         });
       }
@@ -55,78 +55,78 @@ class Y extends v {
   }
   ask(r, e = {}) {
     const t = new AbortController();
-    return Object.assign(new Promise(async (c) => {
-      let o = this.fromStandard([...e.history || [], { role: "user", content: r, timestamp: Date.now() }]);
-      const s = e.tools || this.ai.options.llm?.tools || [], l = {
+    return Object.assign(new Promise(async (l) => {
+      let n = this.fromStandard([...e.history || [], { role: "user", content: r, timestamp: Date.now() }]);
+      const s = e.tools || this.ai.options.llm?.tools || [], c = {
         model: e.model || this.model,
         max_tokens: e.max_tokens || this.ai.options.llm?.max_tokens || 4096,
         system: e.system || this.ai.options.llm?.system || "",
         temperature: e.temperature || this.ai.options.llm?.temperature || 0.7,
-        tools: s.map((d) => ({
-          name: d.name,
-          description: d.description,
+        tools: s.map((m) => ({
+          name: m.name,
+          description: m.description,
           input_schema: {
             type: "object",
-            properties: d.args ? $(d.args, (i, m) => ({ ...m, required: void 0 })) : {},
-            required: d.args ? Object.entries(d.args).filter((i) => i[1].required).map((i) => i[0]) : []
+            properties: m.args ? q(m.args, (i, u) => ({ ...u, required: void 0 })) : {},
+            required: m.args ? Object.entries(m.args).filter((i) => i[1].required).map((i) => i[0]) : []
           },
           fn: void 0
         })),
-        messages: o,
+        messages: n,
         stream: !!e.stream
       };
-      let n, a = !0;
+      let a, o = !0;
       do {
-        if (n = await this.client.messages.create(l).catch((i) => {
+        if (a = await this.client.messages.create(c).catch((i) => {
           throw i.message += `
 
 Messages:
-${JSON.stringify(o, null, 2)}`, i;
+${JSON.stringify(n, null, 2)}`, i;
         }), e.stream) {
-          a ? a = !1 : e.stream({ text: `
+          o ? o = !1 : e.stream({ text: `
 
-` }), n.content = [];
-          for await (const i of n) {
+` }), a.content = [];
+          for await (const i of a) {
             if (t.signal.aborted) break;
             if (i.type === "content_block_start")
-              i.content_block.type === "text" ? n.content.push({ type: "text", text: "" }) : i.content_block.type === "tool_use" && n.content.push({ type: "tool_use", id: i.content_block.id, name: i.content_block.name, input: "" });
+              i.content_block.type === "text" ? a.content.push({ type: "text", text: "" }) : i.content_block.type === "tool_use" && a.content.push({ type: "tool_use", id: i.content_block.id, name: i.content_block.name, input: "" });
             else if (i.type === "content_block_delta")
               if (i.delta.type === "text_delta") {
-                const m = i.delta.text;
-                n.content.at(-1).text += m, e.stream({ text: m });
-              } else i.delta.type === "input_json_delta" && (n.content.at(-1).input += i.delta.partial_json);
+                const u = i.delta.text;
+                a.content.at(-1).text += u, e.stream({ text: u });
+              } else i.delta.type === "input_json_delta" && (a.content.at(-1).input += i.delta.partial_json);
             else if (i.type === "content_block_stop") {
-              const m = n.content.at(-1);
-              m.input != null && (m.input = m.input ? _(m.input, {}) : {});
+              const u = a.content.at(-1);
+              u.input != null && (u.input = u.input ? _(u.input, {}) : {});
             } else if (i.type === "message_stop")
               break;
           }
         }
-        const d = n.content.filter((i) => i.type === "tool_use");
-        if (d.length && !t.signal.aborted) {
-          o.push({ role: "assistant", content: n.content });
-          const i = await Promise.all(d.map(async (m) => {
-            const p = s.find(P("name", m.name));
-            if (e.stream && e.stream({ tool: m.name }), !p) return { tool_use_id: m.id, is_error: !0, content: "Tool not found" };
+        const m = a.content.filter((i) => i.type === "tool_use");
+        if (m.length && !t.signal.aborted) {
+          n.push({ role: "assistant", content: a.content });
+          const i = await Promise.all(m.map(async (u) => {
+            const p = s.find(O("name", u.name));
+            if (e.stream && e.stream({ tool: u.name }), !p) return { tool_use_id: u.id, is_error: !0, content: "Tool not found" };
             try {
-              const u = await p.fn(m.input, e?.stream, this.ai);
-              return { type: "tool_result", tool_use_id: m.id, content: x(u) };
-            } catch (u) {
-              return { type: "tool_result", tool_use_id: m.id, is_error: !0, content: u?.message || u?.toString() || "Unknown" };
+              const d = await p.fn(u.input, e?.stream, this.ai);
+              return { type: "tool_result", tool_use_id: u.id, content: S(d) };
+            } catch (d) {
+              return { type: "tool_result", tool_use_id: u.id, is_error: !0, content: d?.message || d?.toString() || "Unknown" };
             }
           }));
-          o.push({ role: "user", content: i }), l.messages = o;
+          n.push({ role: "user", content: i }), c.messages = n;
         }
-      } while (!t.signal.aborted && n.content.some((d) => d.type === "tool_use"));
-      o.push({ role: "assistant", content: n.content.filter((d) => d.type == "text").map((d) => d.text).join(`
+      } while (!t.signal.aborted && a.content.some((m) => m.type === "tool_use"));
+      n.push({ role: "assistant", content: a.content.filter((m) => m.type == "text").map((m) => m.text).join(`
 
-`) }), o = this.toStandard(o), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...o), c(o.at(-1)?.content);
+`) }), n = this.toStandard(n), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...n), l(n.at(-1)?.content);
     }), { abort: () => t.abort() });
   }
 }
-class M extends v {
-  constructor(r, e, t, c) {
-    super(), this.ai = r, this.host = e, this.token = t, this.model = c, this.client = new W(R({
+class A extends R {
+  constructor(r, e, t, l) {
+    super(), this.ai = r, this.host = e, this.token = t, this.model = l, this.client = new I(z({
       baseURL: e,
       apiKey: t
     }));
@@ -136,17 +136,17 @@ class M extends v {
     for (let e = 0; e < r.length; e++) {
       const t = r[e];
       if (t.role === "assistant" && t.tool_calls) {
-        const c = t.tool_calls.map((o) => ({
+        const l = t.tool_calls.map((n) => ({
           role: "tool",
-          id: o.id,
-          name: o.function.name,
-          args: _(o.function.arguments, {}),
+          id: n.id,
+          name: n.function.name,
+          args: _(n.function.arguments, {}),
           timestamp: t.timestamp
         }));
-        r.splice(e, 1, ...c), e += c.length - 1;
+        r.splice(e, 1, ...l), e += l.length - 1;
       } else if (t.role === "tool" && t.content) {
-        const c = r.find((o) => t.tool_call_id == o.id);
-        c && (t.content.includes('"error":') ? c.error = t.content : c.content = t.content), r.splice(e, 1), e--;
+        const l = r.find((n) => t.tool_call_id == n.id);
+        l && (t.content.includes('"error":') ? l.error = t.content : l.content = t.content), r.splice(e, 1), e--;
       }
       r[e]?.timestamp || (r[e].timestamp = Date.now());
     }
@@ -167,76 +167,76 @@ class M extends v {
           content: t.error || t.content
         });
       else {
-        const { timestamp: c, ...o } = t;
-        e.push(o);
+        const { timestamp: l, ...n } = t;
+        e.push(n);
       }
       return e;
     }, []);
   }
   ask(r, e = {}) {
     const t = new AbortController();
-    return Object.assign(new Promise(async (c, o) => {
+    return Object.assign(new Promise(async (l, n) => {
       e.system && e.history?.[0]?.role != "system" && e.history?.splice(0, 0, { role: "system", content: e.system, timestamp: Date.now() });
       let s = this.fromStandard([...e.history || [], { role: "user", content: r, timestamp: Date.now() }]);
-      const l = e.tools || this.ai.options.llm?.tools || [], n = {
+      const c = e.tools || this.ai.options.llm?.tools || [], a = {
         model: e.model || this.model,
         messages: s,
         stream: !!e.stream,
         max_tokens: e.max_tokens || this.ai.options.llm?.max_tokens || 4096,
         temperature: e.temperature || this.ai.options.llm?.temperature || 0.7,
-        tools: l.map((i) => ({
+        tools: c.map((i) => ({
           type: "function",
           function: {
             name: i.name,
             description: i.description,
             parameters: {
               type: "object",
-              properties: i.args ? $(i.args, (m, p) => ({ ...p, required: void 0 })) : {},
-              required: i.args ? Object.entries(i.args).filter((m) => m[1].required).map((m) => m[0]) : []
+              properties: i.args ? q(i.args, (u, p) => ({ ...p, required: void 0 })) : {},
+              required: i.args ? Object.entries(i.args).filter((u) => u[1].required).map((u) => u[0]) : []
             }
           }
         }))
       };
-      let a, d = !0;
+      let o, m = !0;
       do {
-        if (a = await this.client.chat.completions.create(n).catch((m) => {
-          throw m.message += `
+        if (o = await this.client.chat.completions.create(a).catch((u) => {
+          throw u.message += `
 
 Messages:
-${JSON.stringify(s, null, 2)}`, m;
+${JSON.stringify(s, null, 2)}`, u;
         }), e.stream) {
-          d ? d = !1 : e.stream({ text: `
+          m ? m = !1 : e.stream({ text: `
 
-` }), a.choices = [{ message: { content: "", tool_calls: [] } }];
-          for await (const m of a) {
+` }), o.choices = [{ message: { content: "", tool_calls: [] } }];
+          for await (const u of o) {
             if (t.signal.aborted) break;
-            m.choices[0].delta.content && (a.choices[0].message.content += m.choices[0].delta.content, e.stream({ text: m.choices[0].delta.content })), m.choices[0].delta.tool_calls && (a.choices[0].message.tool_calls = m.choices[0].delta.tool_calls);
+            u.choices[0].delta.content && (o.choices[0].message.content += u.choices[0].delta.content, e.stream({ text: u.choices[0].delta.content })), u.choices[0].delta.tool_calls && (o.choices[0].message.tool_calls = u.choices[0].delta.tool_calls);
           }
         }
-        const i = a.choices[0].message.tool_calls || [];
+        const i = o.choices[0].message.tool_calls || [];
         if (i.length && !t.signal.aborted) {
-          s.push(a.choices[0].message);
-          const m = await Promise.all(i.map(async (p) => {
-            const u = l?.find(P("name", p.function.name));
-            if (e.stream && e.stream({ tool: p.function.name }), !u) return { role: "tool", tool_call_id: p.id, content: '{"error": "Tool not found"}' };
+          s.push(o.choices[0].message);
+          const u = await Promise.all(i.map(async (p) => {
+            const d = c?.find(O("name", p.function.name));
+            if (e.stream && e.stream({ tool: p.function.name }), !d) return { role: "tool", tool_call_id: p.id, content: '{"error": "Tool not found"}' };
             try {
-              const h = _(p.function.arguments, {}), y = await u.fn(h, e.stream, this.ai);
-              return { role: "tool", tool_call_id: p.id, content: x(y) };
-            } catch (h) {
-              return { role: "tool", tool_call_id: p.id, content: x({ error: h?.message || h?.toString() || "Unknown" }) };
+              const f = _(p.function.arguments, {}), y = await d.fn(f, e.stream, this.ai);
+              return { role: "tool", tool_call_id: p.id, content: S(y) };
+            } catch (f) {
+              return { role: "tool", tool_call_id: p.id, content: S({ error: f?.message || f?.toString() || "Unknown" }) };
             }
           }));
-          s.push(...m), n.messages = s;
+          s.push(...u), a.messages = s;
         }
-      } while (!t.signal.aborted && a.choices?.[0]?.message?.tool_calls?.length);
-      s.push({ role: "assistant", content: a.choices[0].message.content || "" }), s = this.toStandard(s), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...s), c(s.at(-1)?.content);
+      } while (!t.signal.aborted && o.choices?.[0]?.message?.tool_calls?.length);
+      s.push({ role: "assistant", content: o.choices[0].message.content || "" }), s = this.toStandard(s), e.stream && e.stream({ done: !0 }), e.history && e.history.splice(0, e.history.length, ...s), l(s.at(-1)?.content);
     }), { abort: () => t.abort() });
   }
 }
-class Q {
+class ee {
   constructor(r) {
     this.ai = r, r.options.llm?.models && Object.entries(r.options.llm.models).forEach(([e, t]) => {
-      this.defaultModel || (this.defaultModel = e), t.proto == "anthropic" ? this.models[e] = new Y(this.ai, t.token, e) : t.proto == "ollama" ? this.models[e] = new M(this.ai, t.host, "not-needed", e) : t.proto == "openai" && (this.models[e] = new M(this.ai, t.host || null, t.token, e));
+      this.defaultModel || (this.defaultModel = e), t.proto == "anthropic" ? this.models[e] = new X(this.ai, t.token, e) : t.proto == "ollama" ? this.models[e] = new A(this.ai, t.host, "not-needed", e) : t.proto == "openai" && (this.models[e] = new A(this.ai, t.host || null, t.token, e));
     });
   }
   defaultModel;
@@ -250,22 +250,22 @@ class Q {
   ask(r, e = {}) {
     const t = e.model || this.defaultModel;
     if (!this.models[t]) throw new Error(`Model does not exist: ${t}`);
-    let c = () => {
+    let l = () => {
     };
-    return Object.assign(new Promise(async (o) => {
+    return Object.assign(new Promise(async (n) => {
       if (e.history || (e.history = []), e.memory) {
         e.system = (e.system || "") + `
 You have passive persistent memory never make any mention of your memory capabilities and what you can/cannot remember
 `;
-        const l = async (a, d, i = 50) => {
-          const [m, p] = await Promise.all([
-            d ? this.embedding(d) : Promise.resolve(null),
-            a ? this.embedding(a) : Promise.resolve(null)
+        const c = async (o, m, i = 50) => {
+          const [u, p] = await Promise.all([
+            m ? this.embedding(m) : Promise.resolve(null),
+            o ? this.embedding(o) : Promise.resolve(null)
           ]);
-          return (e.memory || []).map((u) => ({ ...u, score: m ? this.cosineSimilarity(u.embeddings[0], m[0].embedding) : 1 })).filter((u) => u.score >= 0.8).map((u) => ({ ...u, score: p ? this.cosineSimilarity(u.embeddings[1], p[0].embedding) : u.score })).filter((u) => u.score >= 0.2).toSorted((u, h) => u.score - h.score).slice(0, i);
-        }, n = await l(r);
-        n.length && e.history.push({ role: "assistant", content: `Things I remembered:
-` + n.map((a) => `${a.owner}: ${a.fact}`).join(`
+          return (e.memory || []).map((d) => ({ ...d, score: u ? this.cosineSimilarity(d.embeddings[0], u[0].embedding) : 1 })).filter((d) => d.score >= 0.8).map((d) => ({ ...d, score: p ? this.cosineSimilarity(d.embeddings[1], p[0].embedding) : d.score })).filter((d) => d.score >= 0.2).toSorted((d, f) => d.score - f.score).slice(0, i);
+        }, a = await c(r);
+        a.length && e.history.push({ role: "assistant", content: `Things I remembered:
+` + a.map((o) => `${o.owner}: ${o.fact}`).join(`
 `) }), e.tools = [...e.tools || [], {
           name: "read_memory",
           description: "Check your long-term memory for more information",
@@ -274,32 +274,40 @@ You have passive persistent memory never make any mention of your memory capabil
             query: { type: "string", description: "Search memory based on a query, can be used with or without subject argument" },
             limit: { type: "number", description: "Result limit, default 5" }
           },
-          fn: (a) => {
-            if (!a.subject && !a.query) throw new Error("Either a subject or query argument is required");
-            return l(a.query, a.subject, a.limit || 5);
+          fn: (o) => {
+            if (!o.subject && !o.query) throw new Error("Either a subject or query argument is required");
+            return c(o.query, o.subject, o.limit || 5);
           }
         }];
       }
       const s = await this.models[t].ask(r, e);
       if (e.memory) {
-        const l = e.history?.findIndex((n) => n.role == "assistant" && n.content.startsWith("Things I remembered:"));
-        l != null && l >= 0 && e.history?.splice(l, 1);
+        const c = e.history?.findIndex((a) => a.role == "assistant" && a.content.startsWith("Things I remembered:"));
+        c != null && c >= 0 && e.history?.splice(c, 1);
       }
       if (e.compress || e.memory) {
-        let l = null;
+        let c = null;
         if (e.compress)
-          l = await this.ai.language.compressHistory(e.history, e.compress.max, e.compress.min, e), e.history.splice(0, e.history.length, ...l.history);
+          c = await this.ai.language.compressHistory(e.history, e.compress.max, e.compress.min, e), e.history.splice(0, e.history.length, ...c.history);
         else {
-          const n = e.history?.findLastIndex((a) => a.role == "user") ?? -1;
-          l = await this.ai.language.compressHistory(n != -1 ? e.history.slice(n) : e.history, 0, 0, e);
+          const a = e.history?.findLastIndex((o) => o.role == "user") ?? -1;
+          c = await this.ai.language.compressHistory(a != -1 ? e.history.slice(a) : e.history, 0, 0, e);
         }
         if (e.memory) {
-          const n = e.memory.filter((a) => !l.memory.some((d) => this.cosineSimilarity(a.embeddings[1], d.embeddings[1]) > 0.8)).concat(l.memory);
-          e.memory.splice(0, e.memory.length, ...n);
+          const a = e.memory.filter((o) => !c.memory.some((m) => this.cosineSimilarity(o.embeddings[1], m.embeddings[1]) > 0.8)).concat(c.memory);
+          e.memory.splice(0, e.memory.length, ...a);
         }
       }
-      return o(s);
-    }), { abort: c });
+      return n(s);
+    }), { abort: l });
+  }
+  async code(r, e) {
+    const t = await this.ask(r, { ...e, system: [
+      e?.system,
+      "Return your response in a code block"
+    ].filter((n) => !!n).join(`
+`) }), l = /```(?:.+)?\s*([\s\S]*?)```/.exec(t);
+    return l ? l[1].trim() : null;
   }
   /**
    * Compress chat history to reduce context size
@@ -309,24 +317,24 @@ You have passive persistent memory never make any mention of your memory capabil
    * @param {LLMRequest} options LLM options
    * @returns {Promise<LLMMessage[]>} New chat history will summary at index 0
    */
-  async compressHistory(r, e, t, c) {
+  async compressHistory(r, e, t, l) {
     if (this.estimateTokens(r) < e) return { history: r, memory: [] };
-    let o = 0, s = 0;
-    for (let u of r.toReversed())
-      if (s += this.estimateTokens(u.content), s < t) o++;
+    let n = 0, s = 0;
+    for (let d of r.toReversed())
+      if (s += this.estimateTokens(d.content), s < t) n++;
       else break;
-    if (r.length <= o) return { history: r, memory: [] };
-    const l = r[0].role == "system" ? r[0] : null, n = o == 0 ? [] : r.slice(-o), a = (o == 0 ? r : r.slice(0, -o)).filter((u) => u.role === "assistant" || u.role === "user"), d = await this.json(a.map((u) => `${u.role}: ${u.content}`).join(`
+    if (r.length <= n) return { history: r, memory: [] };
+    const c = r[0].role == "system" ? r[0] : null, a = n == 0 ? [] : r.slice(-n), o = (n == 0 ? r : r.slice(0, -n)).filter((d) => d.role === "assistant" || d.role === "user"), m = await this.json(o.map((d) => `${d.role}: ${d.content}`).join(`
 
 `), "{summary: string, facts: [[subject, fact]]}", {
       system: "Create the smallest summary possible, no more than 500 tokens. Create a list of NEW facts (split by subject [pro]noun and fact) about what you learned from this conversation that you didn't already know or get from a tool call or system prompt. Focus only on new information about people, topics, or facts. Avoid generating facts about the AI.",
-      model: c?.model,
-      temperature: c?.temperature || 0.3
-    }), i = /* @__PURE__ */ new Date(), m = await Promise.all((d?.facts || [])?.map(async ([u, h]) => {
-      const y = await Promise.all([this.embedding(u), this.embedding(`${u}: ${h}`)]);
-      return { owner: u, fact: h, embeddings: [y[0][0].embedding, y[1][0].embedding], timestamp: i };
-    })), p = [{ role: "assistant", content: `Conversation Summary: ${d?.summary}`, timestamp: Date.now() }, ...n];
-    return l && p.splice(0, 0, l), { history: p, memory: m };
+      model: l?.model,
+      temperature: l?.temperature || 0.3
+    }), i = /* @__PURE__ */ new Date(), u = await Promise.all((m?.facts || [])?.map(async ([d, f]) => {
+      const y = await Promise.all([this.embedding(d), this.embedding(`${d}: ${f}`)]);
+      return { owner: d, fact: f, embeddings: [y[0][0].embedding, y[1][0].embedding], timestamp: i };
+    })), p = [{ role: "assistant", content: `Conversation Summary: ${m?.summary}`, timestamp: Date.now() }, ...a];
+    return c && p.splice(0, 0, c), { history: p, memory: u };
   }
   /**
    * Compare the difference between embeddings (calculates the angle between two vectors)
@@ -336,10 +344,10 @@ You have passive persistent memory never make any mention of your memory capabil
    */
   cosineSimilarity(r, e) {
     if (r.length !== e.length) throw new Error("Vectors must be same length");
-    let t = 0, c = 0, o = 0;
-    for (let l = 0; l < r.length; l++)
-      t += r[l] * e[l], c += r[l] * r[l], o += e[l] * e[l];
-    const s = Math.sqrt(c) * Math.sqrt(o);
+    let t = 0, l = 0, n = 0;
+    for (let c = 0; c < r.length; c++)
+      t += r[c] * e[c], l += r[c] * r[c], n += e[c] * e[c];
+    const s = Math.sqrt(l) * Math.sqrt(n);
     return s === 0 ? 0 : t / s;
   }
   /**
@@ -350,25 +358,25 @@ You have passive persistent memory never make any mention of your memory capabil
    * @returns {string[]} Chunked strings
    */
   chunk(r, e = 500, t = 50) {
-    const c = (n, a = "") => n ? Object.entries(n).flatMap(([d, i]) => {
-      const m = a ? `${a}${isNaN(+d) ? `.${d}` : `[${d}]`}` : d;
-      return typeof i == "object" && !Array.isArray(i) ? c(i, m) : `${m}: ${Array.isArray(i) ? i.join(", ") : i}`;
-    }) : [], s = (typeof r == "object" ? c(r) : r.split(`
-`)).flatMap((n) => [...n.split(/\s+/).filter(Boolean), `
-`]), l = [];
-    for (let n = 0; n < s.length; ) {
-      let a = "", d = n;
-      for (; d < s.length; ) {
-        const m = a + (a ? " " : "") + s[d];
-        if (this.estimateTokens(m.replace(/\s*\n\s*/g, `
-`)) > e && a) break;
-        a = m, d++;
+    const l = (a, o = "") => a ? Object.entries(a).flatMap(([m, i]) => {
+      const u = o ? `${o}${isNaN(+m) ? `.${m}` : `[${m}]`}` : m;
+      return typeof i == "object" && !Array.isArray(i) ? l(i, u) : `${u}: ${Array.isArray(i) ? i.join(", ") : i}`;
+    }) : [], s = (typeof r == "object" ? l(r) : r.split(`
+`)).flatMap((a) => [...a.split(/\s+/).filter(Boolean), `
+`]), c = [];
+    for (let a = 0; a < s.length; ) {
+      let o = "", m = a;
+      for (; m < s.length; ) {
+        const u = o + (o ? " " : "") + s[m];
+        if (this.estimateTokens(u.replace(/\s*\n\s*/g, `
+`)) > e && o) break;
+        o = u, m++;
       }
-      const i = a.replace(/\s*\n\s*/g, `
+      const i = o.replace(/\s*\n\s*/g, `
 `).trim();
-      i && l.push(i), n = Math.max(d - t, d === n ? n + 1 : d);
+      i && c.push(i), a = Math.max(m - t, m === a ? a + 1 : m);
     }
-    return l;
+    return c;
   }
   /**
    * Create a vector representation of a string
@@ -377,39 +385,39 @@ You have passive persistent memory never make any mention of your memory capabil
    * @returns {Promise<Awaited<{index: number, embedding: number[], text: string, tokens: number}>[]>} Chunked embeddings
    */
   embedding(r, e = {}) {
-    let { maxTokens: t = 500, overlapTokens: c = 50 } = e, o = !1;
+    let { maxTokens: t = 500, overlapTokens: l = 50 } = e, n = !1;
     const s = () => {
-      o = !0;
-    }, l = (a) => new Promise((d, i) => {
-      if (o) return i(new Error("Aborted"));
-      const m = [
-        J(D(I(import.meta.url)), "embedder.js"),
+      n = !0;
+    }, c = (o) => new Promise((m, i) => {
+      if (n) return i(new Error("Aborted"));
+      const u = [
+        D(G(H(import.meta.url)), "embedder.js"),
         this.ai.options.path,
         this.ai.options?.embedder || "bge-small-en-v1.5"
-      ], p = k("node", m, { stdio: ["pipe", "pipe", "ignore"] });
-      p.stdin.write(a), p.stdin.end();
-      let u = "";
-      p.stdout.on("data", (h) => u += h.toString()), p.on("close", (h) => {
-        if (o) return i(new Error("Aborted"));
-        if (h === 0)
+      ], p = b("node", u, { stdio: ["pipe", "pipe", "ignore"] });
+      p.stdin.write(o), p.stdin.end();
+      let d = "";
+      p.stdout.on("data", (f) => d += f.toString()), p.on("close", (f) => {
+        if (n) return i(new Error("Aborted"));
+        if (f === 0)
           try {
-            const y = JSON.parse(u);
-            d(y.embedding);
+            const y = JSON.parse(d);
+            m(y.embedding);
           } catch {
             i(new Error("Failed to parse embedding output"));
           }
         else
-          i(new Error(`Embedder process exited with code ${h}`));
+          i(new Error(`Embedder process exited with code ${f}`));
       }), p.on("error", i);
-    }), n = (async () => {
-      const a = this.chunk(r, t, c), d = [];
-      for (let i = 0; i < a.length && !o; i++) {
-        const m = a[i], p = await l(m);
-        d.push({ index: i, embedding: p, text: m, tokens: this.estimateTokens(m) });
+    }), a = (async () => {
+      const o = this.chunk(r, t, l), m = [];
+      for (let i = 0; i < o.length && !n; i++) {
+        const u = o[i], p = await c(u);
+        m.push({ index: i, embedding: p, text: u, tokens: this.estimateTokens(u) });
       }
-      return d;
+      return m;
     })();
-    return Object.assign(n, { abort: s });
+    return Object.assign(a, { abort: s });
   }
   /**
    * Estimate variable as tokens
@@ -428,8 +436,8 @@ You have passive persistent memory never make any mention of your memory capabil
    */
   fuzzyMatch(r, ...e) {
     if (e.length < 2) throw new Error("Requires at least 2 strings to compare");
-    const t = (s, l = 10) => s.toLowerCase().split("").map((n, a) => n.charCodeAt(0) * (a + 1) % l / l).slice(0, l), c = t(r), o = e.map((s) => t(s)).map((s) => this.cosineSimilarity(c, s));
-    return { avg: o.reduce((s, l) => s + l, 0) / o.length, max: Math.max(...o), similarities: o };
+    const t = (s, c = 10) => s.toLowerCase().split("").map((a, o) => a.charCodeAt(0) * (o + 1) % c / c).slice(0, c), l = t(r), n = e.map((s) => t(s)).map((s) => this.cosineSimilarity(l, s));
+    return { avg: n.reduce((s, c) => s + c, 0) / n.length, max: Math.max(...n), similarities: n };
   }
   /**
    * Ask a question with JSON response
@@ -439,14 +447,15 @@ You have passive persistent memory never make any mention of your memory capabil
    * @returns {Promise<{} | {} | RegExpExecArray | null>}
    */
   async json(r, e, t) {
-    let c = await this.ask(r, { ...t, system: (t?.system ? `${t.system}
-` : "") + `Only respond using a JSON code block matching this schema:
+    const l = await this.code(r, { ...t, system: [
+      t?.system,
+      `Only respond using JSON matching this schema:
 \`\`\`json
 ${e}
-\`\`\`` });
-    if (!c) return {};
-    const o = /```(?:.+)?\s*([\s\S]*?)```/.exec(c), s = o ? o[1].trim() : c;
-    return _(s, {});
+\`\`\``
+    ].filter((n) => !!n).join(`
+`) });
+    return l ? _(l, {}) : null;
   }
   /**
    * Create a summary of some text
@@ -459,7 +468,7 @@ ${e}
     return this.ask(r, { system: `Generate a brief summary <= ${e} tokens. Output nothing else`, temperature: 0.3, ...t });
   }
 }
-class X {
+class te {
   constructor(r) {
     this.ai = r, r.options.whisper && (this.whisperModel = r.options.asr || "ggml-base.en.bin", this.downloadAsrModel()), this.pyannote = `
 import sys
@@ -481,147 +490,166 @@ print(json.dumps(segments))
   downloads = {};
   pyannote;
   whisperModel;
+  async addPunctuation(r, e, t = 150) {
+    const l = (s) => {
+      if (s = s.toLowerCase().replace(/[^a-z]/g, ""), s.length <= 3) return 1;
+      const c = s.match(/[aeiouy]+/g);
+      let a = c ? c.length : 1;
+      return s.endsWith("e") && a--, Math.max(1, a);
+    };
+    let n = "";
+    return r.transcription.filter((s, c) => {
+      let a = !1;
+      const o = r.transcription[c - 1], m = r.transcription[c + 1];
+      return !s.text && m ? (m.offsets.from = s.offsets.from, m.timestamps.from = s.offsets.from) : s.text && s.text[0] != " " && o && (o.offsets.to = s.offsets.to, o.timestamps.to = s.timestamps.to, o.text += s.text, a = !0), !!s.text && !a;
+    }).forEach((s) => {
+      const c = /^[A-Z]/.test(s.text.trim()), a = s.offsets.to - s.offsets.from, m = l(s.text.trim()) * t;
+      c && a > m * 2 && s.text[0] == " " && (n += "."), n += s.text;
+    }), e ? this.ai.language.ask(n, {
+      system: "Remove any misplaced punctuation from the following ASR transcript using the replace tool. Avoid modifying words unless there is an obvious typo",
+      temperature: 0.1,
+      tools: [{
+        name: "replace",
+        description: "Use find and replace to fix errors",
+        args: {
+          find: { type: "string", description: "Text to find", required: !0 },
+          replace: { type: "string", description: "Text to replace", required: !0 }
+        },
+        fn: (s) => n = n.replace(s.find, s.replace)
+      }]
+    }).then(() => n) : n.trim();
+  }
+  async diarizeTranscript(r, e, t) {
+    const l = /* @__PURE__ */ new Map();
+    let n = 0;
+    e.forEach((d) => {
+      l.has(d.speaker) || l.set(d.speaker, ++n);
+    });
+    const s = await this.addPunctuation(r, t), c = s.match(/[^.!?]+[.!?]+/g) || [s], a = r.transcription.filter((d) => d.text.trim()), o = c.map((d) => {
+      if (d = d.trim(), !d) return null;
+      const f = d.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/), y = /* @__PURE__ */ new Map();
+      f.forEach((k) => {
+        const x = a.find((g) => k === g.text.trim().toLowerCase().replace(/[^\w]/g, ""));
+        if (!x) return;
+        const E = x.offsets.from / 1e3, P = e.find((g) => E >= g.start && E <= g.end);
+        if (P) {
+          const g = l.get(P.speaker);
+          y.set(g, (y.get(g) || 0) + 1);
+        }
+      });
+      let j = 1, T = 0;
+      return y.forEach((k, x) => {
+        k > T && (T = k, j = x);
+      }), { speaker: j, text: d };
+    }).filter((d) => d !== null), m = [];
+    o.forEach((d) => {
+      const f = m[m.length - 1];
+      f && f.speaker === d.speaker ? f.text += " " + d.text : m.push({ ...d });
+    });
+    let i = m.map((d) => `[Speaker ${d.speaker}]: ${d.text}`).join(`
+`).trim();
+    if (!t) return i;
+    let u = this.ai.language.chunk(i, 500, 0);
+    u.length > 4 && (u = [...u.slice(0, 3), u.at(-1)]);
+    const p = await this.ai.language.json(u.join(`
+`), '{1: "Detected Name", 2: "Second Name"}', {
+      system: "Use the following transcript to identify speakers. Only identify speakers you are positive about, dont mention speakers you are unsure about in your response",
+      temperature: 0.1
+    });
+    return Object.entries(p).forEach(([d, f]) => i = i.replaceAll(`[Speaker ${d}]`, `[${f}]`)), i;
+  }
   runAsr(r, e = {}) {
     let t;
-    const c = new Promise((o, s) => {
-      this.downloadAsrModel(e.model).then((l) => {
+    const l = new Promise((n, s) => {
+      this.downloadAsrModel(e.model).then((c) => {
         if (e.diarization) {
-          let n = j.join(j.dirname(r), "transcript");
-          t = k(
+          let a = $.join($.dirname(r), "transcript");
+          t = b(
             this.ai.options.whisper,
-            ["-m", l, "-f", r, "-np", "-ml", "1", "-oj", "-of", n],
+            ["-m", c, "-f", r, "-np", "-ml", "1", "-oj", "-of", a],
             { stdio: ["ignore", "ignore", "pipe"] }
-          ), t.on("error", (a) => s(a)), t.on("close", async (a) => {
-            if (a === 0) {
-              n = await b.readFile(n + ".json", "utf-8"), b.rm(n + ".json").catch(() => {
+          ), t.on("error", (o) => s(o)), t.on("close", async (o) => {
+            if (o === 0) {
+              a = await w.readFile(a + ".json", "utf-8"), w.rm(a + ".json").catch(() => {
               });
               try {
-                o(JSON.parse(n));
+                n(JSON.parse(a));
               } catch {
                 s(new Error("Failed to parse whisper JSON"));
               }
             } else
-              s(new Error(`Exit code ${a}`));
+              s(new Error(`Exit code ${o}`));
           });
         } else {
-          let n = "";
-          t = k(this.ai.options.whisper, ["-m", l, "-f", r, "-np", "-nt"]), t.on("error", (a) => s(a)), t.stdout.on("data", (a) => n += a.toString()), t.on("close", async (a) => {
-            a === 0 ? o(n.trim() || null) : s(new Error(`Exit code ${a}`));
+          let a = "";
+          t = b(this.ai.options.whisper, ["-m", c, "-f", r, "-np", "-nt"]), t.on("error", (o) => s(o)), t.stdout.on("data", (o) => a += o.toString()), t.on("close", async (o) => {
+            o === 0 ? n(a.trim() || null) : s(new Error(`Exit code ${o}`));
           });
         }
       });
     });
-    return Object.assign(c, { abort: () => t?.kill("SIGTERM") });
+    return Object.assign(l, { abort: () => t?.kill("SIGTERM") });
   }
   runDiarization(r) {
     let e = !1, t = () => {
       e = !0;
     };
-    const c = (s) => new Promise((l) => {
-      const n = k(s, ["-W", "ignore", "-c", "import pyannote.audio"]);
-      n.on("close", (a) => l(a === 0)), n.on("error", () => l(!1));
-    }), o = Promise.all([
-      c("python"),
-      c("python3")
-    ]).then((async ([s, l]) => {
+    const l = (s) => new Promise((c) => {
+      const a = b(s, ["-W", "ignore", "-c", "import pyannote.audio"]);
+      a.on("close", (o) => c(o === 0)), a.on("error", () => c(!1));
+    }), n = Promise.all([
+      l("python"),
+      l("python3")
+    ]).then((async ([s, c]) => {
       if (e) return;
-      if (!s && !l) throw new Error("Pyannote is not installed: pip install pyannote.audio");
-      const n = l ? "python3" : "python";
-      return new Promise((a, d) => {
+      if (!s && !c) throw new Error("Pyannote is not installed: pip install pyannote.audio");
+      const a = c ? "python3" : "python";
+      return new Promise((o, m) => {
         if (e) return;
         let i = "";
-        const m = k(n, ["-W", "ignore", "-c", this.pyannote, r]);
-        m.stdout.on("data", (p) => i += p.toString()), m.stderr.on("data", (p) => console.error(p.toString())), m.on("close", (p) => {
+        const u = b(a, ["-W", "ignore", "-c", this.pyannote, r]);
+        u.stdout.on("data", (p) => i += p.toString()), u.stderr.on("data", (p) => console.error(p.toString())), u.on("close", (p) => {
           if (p === 0)
             try {
-              a(JSON.parse(i));
+              o(JSON.parse(i));
             } catch {
-              d(new Error("Failed to parse diarization output"));
+              m(new Error("Failed to parse diarization output"));
             }
           else
-            d(new Error(`Python process exited with code ${p}`));
-        }), m.on("error", d), t = () => m.kill("SIGTERM");
+            m(new Error(`Python process exited with code ${p}`));
+        }), u.on("error", m), t = () => u.kill("SIGTERM");
       });
     }));
-    return Object.assign(o, { abort: t });
-  }
-  async combineSpeakerTranscript(r, e, t) {
-    const c = /* @__PURE__ */ new Map();
-    let o = 0;
-    t.forEach((n) => {
-      c.has(n.speaker) || c.set(n.speaker, ++o);
-    });
-    const s = r.match(/[^.!?]+[.!?]+/g) || [r], l = [];
-    return s.forEach((n) => {
-      if (n = n.trim(), !n) return;
-      const a = n.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/);
-      let d = 1 / 0;
-      const i = [];
-      if (e.transcription.forEach((h) => {
-        const y = h.text.trim().toLowerCase();
-        if (a.some((g) => y.includes(g))) {
-          const g = h.offsets.from / 1e3, w = h.offsets.to / 1e3;
-          i.push({ start: g, end: w }), g < d && (d = g);
-        }
-      }), d === 1 / 0) return;
-      const m = /* @__PURE__ */ new Map();
-      i.forEach((h) => {
-        t.forEach((y) => {
-          const g = Math.max(0, Math.min(h.end, y.end) - Math.max(h.start, y.start)), w = h.end - h.start;
-          if (w > 0) {
-            const A = g / w, S = c.get(y.speaker);
-            m.set(S, (m.get(S) || 0) + A);
-          }
-        });
-      });
-      let p = 1, u = 0;
-      m.forEach((h, y) => {
-        h > u && (u = h, p = y);
-      }), l.push(`[Speaker ${p}]: ${n}`);
-    }), l.join(`
-`).trim();
+    return Object.assign(n, { abort: t });
   }
   asr(r, e = {}) {
     if (!this.ai.options.whisper) throw new Error("Whisper not configured");
-    const t = T(H(T(q(), "audio-")), "converted.wav");
-    F(`ffmpeg -i "${r}" -ar 16000 -ac 1 -f wav "${t}"`, { stdio: "ignore" });
-    const c = () => b.rm(E.dirname(t), { recursive: !0, force: !0 }).catch(() => {
-    }), o = this.runAsr(t, { model: e.model, diarization: !1 }), s = e.diarization ? this.runAsr(t, { model: e.model, diarization: !0 }) : Promise.resolve(null), l = e.diarization ? this.runDiarization(t) : Promise.resolve(null);
-    let n = !1, a = () => {
-      n = !0, o.abort(), s?.abort?.(), l?.abort?.(), c();
+    const t = M(K(M(W(), "audio-")), "converted.wav");
+    B(`ffmpeg -i "${r}" -ar 16000 -ac 1 -f wav "${t}"`, { stdio: "ignore" });
+    const l = () => w.rm(v.dirname(t), { recursive: !0, force: !0 }).catch(() => {
+    });
+    if (!e.diarization) return this.runAsr(t, { model: e.model });
+    const n = this.runAsr(t, { model: e.model, diarization: !0 }), s = this.runDiarization(t);
+    let c = !1, a = () => {
+      c = !0, n.abort(), s.abort(), l();
     };
-    const d = Promise.allSettled([o, s, l]).then(async ([i, m, p]) => {
-      if (i.status == "rejected") throw new Error(`Whisper.cpp punctuated:
-` + i.reason);
+    const o = Promise.allSettled([n, s]).then(async ([m, i]) => {
       if (m.status == "rejected") throw new Error(`Whisper.cpp timestamps:
 ` + m.reason);
-      if (p.status == "rejected") throw new Error(`Pyannote:
-` + p.reason);
-      if (n || !e.diarization) return i.value;
-      let u = await this.combineSpeakerTranscript(i.value, m.value, p.value);
-      if (!n && e.diarization === "id") {
-        if (!this.ai.language.defaultModel) throw new Error("Configure an LLM for advanced ASR speaker detection");
-        let h = this.ai.language.chunk(u, 500, 0);
-        h.length > 4 && (h = [...h.slice(0, 3), h.at(-1)]);
-        const y = await this.ai.language.json(h.join(`
-`), '{1: "Detected Name", 2: "Second Name"}', {
-          system: "Use the following transcript to identify speakers. Only identify speakers you are positive about, dont mention speakers you are unsure about in your response",
-          temperature: 0.1
-        });
-        Object.entries(y).forEach(([g, w]) => u = u.replaceAll(`[Speaker ${g}]`, `[${w}]`));
-      }
-      return u;
-    }).finally(() => c());
-    return Object.assign(d, { abort: a });
+      if (i.status == "rejected") throw new Error(`Pyannote:
+` + i.reason);
+      return c || !e.diarization ? m.value : this.diarizeTranscript(m.value, i.value, e.diarization == "llm");
+    }).finally(() => l());
+    return Object.assign(o, { abort: a });
   }
   async downloadAsrModel(r = this.whisperModel) {
     if (!this.ai.options.whisper) throw new Error("Whisper not configured");
     r.endsWith(".bin") || (r += ".bin");
-    const e = E.join(this.ai.options.path, r);
-    return await b.stat(e).then(() => !0).catch(() => !1) ? e : this.downloads[r] ? this.downloads[r] : (this.downloads[r] = fetch(`https://huggingface.co/ggerganov/whisper.cpp/resolve/main/${r}`).then((t) => t.arrayBuffer()).then((t) => Buffer.from(t)).then(async (t) => (await b.writeFile(e, t), delete this.downloads[r], e)), this.downloads[r]);
+    const e = v.join(this.ai.options.path, r);
+    return await w.stat(e).then(() => !0).catch(() => !1) ? e : this.downloads[r] ? this.downloads[r] : (this.downloads[r] = fetch(`https://huggingface.co/ggerganov/whisper.cpp/resolve/main/${r}`).then((t) => t.arrayBuffer()).then((t) => Buffer.from(t)).then(async (t) => (await w.writeFile(e, t), delete this.downloads[r], e)), this.downloads[r]);
   }
 }
-class Z {
+class re {
   constructor(r) {
     this.ai = r;
   }
@@ -632,17 +660,17 @@ class Z {
    */
   ocr(r) {
     let e;
-    const t = new Promise(async (c) => {
-      e = await G(this.ai.options.ocr || "eng", 2, { cachePath: this.ai.options.path });
-      const { data: o } = await e.recognize(r);
-      await e.terminate(), c(o.text.trim() || null);
+    const t = new Promise(async (l) => {
+      e = await V(this.ai.options.ocr || "eng", 2, { cachePath: this.ai.options.path });
+      const { data: n } = await e.recognize(r);
+      await e.terminate(), l(n.text.trim() || null);
     });
     return Object.assign(t, { abort: () => e?.terminate() });
   }
 }
-class fe {
+class we {
   constructor(r) {
-    this.options = r, r.path || (r.path = O.tmpdir()), process.env.TRANSFORMERS_CACHE = r.path, this.audio = new X(this), this.language = new Q(this), this.vision = new Z(this);
+    this.options = r, r.path || (r.path = U.tmpdir()), process.env.TRANSFORMERS_CACHE = r.path, this.audio = new te(this), this.language = new ee(this), this.vision = new re(this);
   }
   /** Audio processing AI */
   audio;
@@ -651,38 +679,38 @@ class fe {
   /** Vision processing AI */
   vision;
 }
-const ee = {
+const se = {
   name: "cli",
   description: "Use the command line interface, returns any output",
   args: { command: { type: "string", description: "Command to run", required: !0 } },
-  fn: (f) => K`${f.command}`
-}, ye = {
+  fn: (h) => Z`${h.command}`
+}, be = {
   name: "get_datetime",
   description: "Get current UTC date / time",
   args: {},
   fn: async () => (/* @__PURE__ */ new Date()).toUTCString()
-}, ge = {
+}, ke = {
   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 (f, r, e) => {
+  fn: async (h, r, e) => {
     try {
-      switch (f.type) {
+      switch (h.type) {
         case "bash":
-          return await ee.fn({ command: f.code }, r, e);
+          return await se.fn({ command: h.code }, r, e);
         case "node":
-          return await te.fn({ code: f.code }, r, e);
+          return await ne.fn({ code: h.code }, r, e);
         case "python":
-          return await re.fn({ code: f.code }, r, e);
+          return await oe.fn({ code: h.code }, r, e);
       }
     } catch (t) {
       return { error: t?.message || t.toString() };
     }
   }
-}, we = {
+}, xe = {
   name: "fetch",
   description: "Make HTTP request to URL",
   args: {
@@ -691,85 +719,85 @@ const ee = {
     headers: { type: "object", description: "HTTP headers to send", default: {} },
     body: { type: "object", description: "HTTP body to send" }
   },
-  fn: (f) => new U({ url: f.url, headers: f.headers }).request({ method: f.method || "GET", body: f.body })
-}, te = {
+  fn: (h) => new N({ url: h.url, headers: h.headers }).request({ method: h.method || "GET", body: h.body })
+}, ne = {
   name: "exec_javascript",
   description: "Execute commonjs javascript",
   args: {
     code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
-  fn: async (f) => {
-    const r = z(null), e = await N({ console: r }, f.code, !0).catch((t) => r.output.error.push(t));
+  fn: async (h) => {
+    const r = C(null), e = await L({ console: r }, h.code, !0).catch((t) => r.output.error.push(t));
     return { ...r.output, return: e, stdout: void 0, stderr: void 0 };
   }
-}, re = {
+}, oe = {
   name: "exec_javascript",
   description: "Execute commonjs javascript",
   args: {
     code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
-  fn: async (f) => ({ result: V`python -c "${f.code}"` })
-}, be = {
+  fn: async (h) => ({ result: Q`python -c "${h.code}"` })
+}, _e = {
   name: "read_webpage",
   description: "Extract clean, structured content from a webpage. Use after web_search to read specific URLs",
   args: {
     url: { type: "string", description: "URL to extract content from", required: !0 },
     focus: { type: "string", description: 'Optional: What aspect to focus on (e.g., "pricing", "features", "contact info")' }
   },
-  fn: async (f) => {
-    const r = await fetch(f.url, { headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" } }).then((s) => s.text()).catch((s) => {
+  fn: async (h) => {
+    const r = await fetch(h.url, { headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" } }).then((s) => s.text()).catch((s) => {
       throw new Error(`Failed to fetch: ${s.message}`);
-    }), e = B.load(r);
+    }), e = Y.load(r);
     e('script, style, nav, footer, header, aside, iframe, noscript, [role="navigation"], [role="banner"], .ad, .ads, .cookie, .popup').remove();
     const t = {
       title: e('meta[property="og:title"]').attr("content") || e("title").text() || "",
       description: e('meta[name="description"]').attr("content") || e('meta[property="og:description"]').attr("content") || ""
     };
-    let c = "";
-    const o = ["article", "main", '[role="main"]', ".content", ".post", ".entry", "body"];
-    for (const s of o) {
-      const l = e(s).first();
-      if (l.length && l.text().trim().length > 200) {
-        c = l.text();
+    let l = "";
+    const n = ["article", "main", '[role="main"]', ".content", ".post", ".entry", "body"];
+    for (const s of n) {
+      const c = e(s).first();
+      if (c.length && c.text().trim().length > 200) {
+        l = c.text();
         break;
       }
     }
-    return c || (c = e("body").text()), c = c.replace(/\s+/g, " ").trim().slice(0, 8e3), { url: f.url, title: t.title.trim(), description: t.description.trim(), content: c, focus: f.focus };
+    return l || (l = e("body").text()), l = l.replace(/\s+/g, " ").trim().slice(0, 8e3), { url: h.url, title: t.title.trim(), description: t.description.trim(), content: l, focus: h.focus };
   }
-}, ke = {
+}, Se = {
   name: "web_search",
   description: "Use duckduckgo (anonymous) to find find relevant online resources. Returns a list of URLs that works great with the `read_webpage` tool",
   args: {
     query: { type: "string", description: "Search string", required: !0 },
     length: { type: "string", description: "Number of results to return", default: 5 }
   },
-  fn: async (f) => {
-    const r = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(f.query)}`, {
+  fn: async (h) => {
+    const r = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(h.query)}`, {
       headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)", "Accept-Language": "en-US,en;q=0.9" }
-    }).then((o) => o.text());
+    }).then((n) => n.text());
     let e, t = /<a .*?href="(.+?)".+?<\/a>/g;
-    const c = new L();
+    const l = new J();
     for (; (e = t.exec(r)) !== null; ) {
-      let o = /uddg=(.+)&amp?/.exec(decodeURIComponent(e[1]))?.[1];
-      if (o && (o = decodeURIComponent(o)), o && c.add(o), c.size >= (f.length || 5)) break;
+      let n = /uddg=(.+)&amp?/.exec(decodeURIComponent(e[1]))?.[1];
+      if (n && (n = decodeURIComponent(n)), n && l.add(n), l.size >= (h.length || 5)) break;
     }
-    return c;
+    return l;
   }
 };
 export {
-  fe as Ai,
-  Y as Anthropic,
-  X as Audio,
-  ee as CliTool,
-  ye as DateTimeTool,
-  ge as ExecTool,
-  we as FetchTool,
-  te as JSTool,
-  v as LLMProvider,
-  M as OpenAi,
-  re as PythonTool,
-  be as ReadWebpageTool,
-  Z as Vision,
-  ke as WebSearchTool
+  we as Ai,
+  X as Anthropic,
+  te as Audio,
+  se as CliTool,
+  be as DateTimeTool,
+  ke as ExecTool,
+  xe as FetchTool,
+  ne as JSTool,
+  R as LLMProvider,
+  A as OpenAi,
+  oe as PythonTool,
+  _e as ReadWebpageTool,
+  re as Vision,
+  Se as WebSearchTool
 };
 //# sourceMappingURL=index.mjs.map