@ztimson/ai-utils 0.1.4 → 0.1.6

package/dist/index.mjs

@@ -1,387 +1,290 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { $, $Sync } from "@ztimson/node-utils";
-import { createWorker } from "tesseract.js";
-import { objectMap, JSONAttemptParse, findByProp, JSONSanitize, Http, consoleInterceptor, fn, ASet } from "@ztimson/utils";
-import { Anthropic as Anthropic$1 } from "@anthropic-ai/sdk";
-import { Ollama as Ollama$1 } from "ollama";
-import { OpenAI } from "openai";
-import fs from "node:fs/promises";
-import Path from "node:path";
-import * as tf from "@tensorflow/tfjs";
-class LLMProvider {
+import { $ as j, $Sync as T } from "@ztimson/node-utils";
+import { createWorker as q } from "tesseract.js";
+import { objectMap as b, JSONAttemptParse as w, findByProp as k, JSONSanitize as _, Http as v, consoleInterceptor as P, fn as A, ASet as O } from "@ztimson/utils";
+import { Anthropic as $ } from "@anthropic-ai/sdk";
+import { Ollama as E } from "ollama";
+import { OpenAI as M } from "openai";
+import y from "node:fs/promises";
+import S from "node:path";
+import * as g from "@tensorflow/tfjs";
+class x {
 }
-class Anthropic extends LLMProvider {
-  constructor(ai, apiToken, model) {
-    super();
-    __publicField(this, "client");
-    this.ai = ai;
-    this.apiToken = apiToken;
-    this.model = model;
-    this.client = new Anthropic$1({ apiKey: apiToken });
+class U extends x {
+  constructor(t, e, n) {
+    super(), this.ai = t, this.apiToken = e, this.model = n, this.client = new $({ apiKey: e });
   }
-  toStandard(history) {
-    for (let i = 0; i < history.length; i++) {
-      const orgI = i;
-      if (typeof history[orgI].content != "string") {
-        if (history[orgI].role == "assistant") {
-          history[orgI].content.filter((c) => c.type == "tool_use").forEach((c) => {
-            i++;
-            history.splice(i, 0, { role: "tool", id: c.id, name: c.name, args: c.input });
-          });
-        } else if (history[orgI].role == "user") {
-          history[orgI].content.filter((c) => c.type == "tool_result").forEach((c) => {
-            const h = history.find((h2) => h2.id == c.tool_use_id);
-            h[c.is_error ? "error" : "content"] = c.content;
-          });
-        }
-        history[orgI].content = history[orgI].content.filter((c) => c.type == "text").map((c) => c.text).join("\n\n");
-      }
+  client;
+  toStandard(t) {
+    for (let e = 0; e < t.length; e++) {
+      const n = e;
+      typeof t[n].content != "string" && (t[n].role == "assistant" ? t[n].content.filter((s) => s.type == "tool_use").forEach((s) => {
+        e++, t.splice(e, 0, { role: "tool", id: s.id, name: s.name, args: s.input });
+      }) : t[n].role == "user" && t[n].content.filter((s) => s.type == "tool_result").forEach((s) => {
+        const i = t.find((f) => f.id == s.tool_use_id);
+        i[s.is_error ? "error" : "content"] = s.content;
+      }), t[n].content = t[n].content.filter((s) => s.type == "text").map((s) => s.text).join(`
+
+`));
     }
-    return history.filter((h) => !!h.content);
+    return t.filter((e) => !!e.content);
   }
-  fromStandard(history) {
-    for (let i = 0; i < history.length; i++) {
-      if (history[i].role == "tool") {
-        const h = history[i];
-        history.splice(
-          i,
+  fromStandard(t) {
+    for (let e = 0; e < t.length; e++)
+      if (t[e].role == "tool") {
+        const n = t[e];
+        t.splice(
+          e,
           1,
-          { role: "assistant", content: [{ type: "tool_use", id: h.id, name: h.name, input: h.args }] },
-          { role: "user", content: [{ type: "tool_result", tool_use_id: h.id, is_error: !!h.error, content: h.error || h.content }] }
-        );
-        i++;
+          { 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 history;
+    return t;
   }
-  ask(message, options = {}) {
-    const controller = new AbortController();
-    const response = new Promise(async (res, rej) => {
-      let history = this.fromStandard([...options.history || [], { role: "user", content: message }]);
-      if (options.compress) history = await this.ai.llm.compress(history, options.compress.max, options.compress.min, options);
-      const requestParams = {
-        model: options.model || this.model,
-        max_tokens: options.max_tokens || this.ai.options.max_tokens || 4096,
-        system: options.system || this.ai.options.system || "",
-        temperature: options.temperature || this.ai.options.temperature || 0.7,
-        tools: (options.tools || this.ai.options.tools || []).map((t) => ({
-          name: t.name,
-          description: t.description,
+  ask(t, e = {}) {
+    const n = new AbortController(), s = new Promise(async (i, f) => {
+      let c = this.fromStandard([...e.history || [], { role: "user", content: t }]);
+      e.compress && (c = await this.ai.llm.compress(c, e.compress.max, e.compress.min, e));
+      const m = {
+        model: e.model || this.model,
+        max_tokens: e.max_tokens || this.ai.options.max_tokens || 4096,
+        system: e.system || this.ai.options.system || "",
+        temperature: e.temperature || this.ai.options.temperature || 0.7,
+        tools: (e.tools || this.ai.options.tools || []).map((o) => ({
+          name: o.name,
+          description: o.description,
           input_schema: {
             type: "object",
-            properties: t.args ? objectMap(t.args, (key, value) => ({ ...value, required: void 0 })) : {},
-            required: t.args ? Object.entries(t.args).filter((t2) => t2[1].required).map((t2) => t2[0]) : []
+            properties: o.args ? b(o.args, (r, a) => ({ ...a, required: void 0 })) : {},
+            required: o.args ? Object.entries(o.args).filter((r) => r[1].required).map((r) => r[0]) : []
           },
           fn: void 0
         })),
-        messages: history,
-        stream: !!options.stream
+        messages: c,
+        stream: !!e.stream
       };
-      let resp;
+      let l;
       do {
-        resp = await this.client.messages.create(requestParams);
-        if (options.stream) {
-          resp.content = [];
-          for await (const chunk of resp) {
-            if (controller.signal.aborted) break;
-            if (chunk.type === "content_block_start") {
-              if (chunk.content_block.type === "text") {
-                resp.content.push({ type: "text", text: "" });
-              } else if (chunk.content_block.type === "tool_use") {
-                resp.content.push({ type: "tool_use", id: chunk.content_block.id, name: chunk.content_block.name, input: "" });
-              }
-            } else if (chunk.type === "content_block_delta") {
-              if (chunk.delta.type === "text_delta") {
-                const text = chunk.delta.text;
-                resp.content.at(-1).text += text;
-                options.stream({ text });
-              } else if (chunk.delta.type === "input_json_delta") {
-                resp.content.at(-1).input += chunk.delta.partial_json;
-              }
-            } else if (chunk.type === "content_block_stop") {
-              const last = resp.content.at(-1);
-              if (last.input != null) last.input = last.input ? JSONAttemptParse(last.input, {}) : {};
-            } else if (chunk.type === "message_stop") {
+        if (l = await this.client.messages.create(m), e.stream) {
+          l.content = [];
+          for await (const r of l) {
+            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 a = r.delta.text;
+                l.content.at(-1).text += a, e.stream({ text: a });
+              } else r.delta.type === "input_json_delta" && (l.content.at(-1).input += r.delta.partial_json);
+            else if (r.type === "content_block_stop") {
+              const a = l.content.at(-1);
+              a.input != null && (a.input = a.input ? w(a.input, {}) : {});
+            } else if (r.type === "message_stop")
               break;
-            }
           }
         }
-        const toolCalls = resp.content.filter((c) => c.type === "tool_use");
-        if (toolCalls.length && !controller.signal.aborted) {
-          history.push({ role: "assistant", content: resp.content });
-          const results = await Promise.all(toolCalls.map(async (toolCall) => {
-            var _a;
-            const tool = (_a = options.tools) == null ? void 0 : _a.find(findByProp("name", toolCall.name));
-            if (!tool) return { tool_use_id: toolCall.id, is_error: true, content: "Tool not found" };
+        const o = l.content.filter((r) => r.type === "tool_use");
+        if (o.length && !n.signal.aborted) {
+          c.push({ role: "assistant", content: l.content });
+          const r = await Promise.all(o.map(async (a) => {
+            const u = e.tools?.find(k("name", a.name));
+            if (!u) return { tool_use_id: a.id, is_error: !0, content: "Tool not found" };
             try {
-              const result = await tool.fn(toolCall.input, this.ai);
-              return { type: "tool_result", tool_use_id: toolCall.id, content: JSONSanitize(result) };
-            } catch (err) {
-              return { type: "tool_result", tool_use_id: toolCall.id, is_error: true, content: (err == null ? void 0 : err.message) || (err == null ? void 0 : err.toString()) || "Unknown" };
+              const p = await u.fn(a.input, this.ai);
+              return { type: "tool_result", tool_use_id: a.id, content: _(p) };
+            } catch (p) {
+              return { type: "tool_result", tool_use_id: a.id, is_error: !0, content: p?.message || p?.toString() || "Unknown" };
             }
           }));
-          history.push({ role: "user", content: results });
-          requestParams.messages = history;
+          c.push({ role: "user", content: r }), m.messages = c;
         }
-      } while (!controller.signal.aborted && resp.content.some((c) => c.type === "tool_use"));
-      if (options.stream) options.stream({ done: true });
-      res(this.toStandard([...history, {
+      } while (!n.signal.aborted && l.content.some((o) => o.type === "tool_use"));
+      e.stream && e.stream({ done: !0 }), i(this.toStandard([...c, {
         role: "assistant",
-        content: resp.content.filter((c) => c.type == "text").map((c) => c.text).join("\n\n")
+        content: l.content.filter((o) => o.type == "text").map((o) => o.text).join(`
+
+`)
       }]));
     });
-    return Object.assign(response, { abort: () => controller.abort() });
+    return Object.assign(s, { abort: () => n.abort() });
   }
 }
-class Ollama extends LLMProvider {
-  constructor(ai, host, model) {
-    super();
-    __publicField(this, "client");
-    this.ai = ai;
-    this.host = host;
-    this.model = model;
-    this.client = new Ollama$1({ host });
+class L extends x {
+  constructor(t, e, n) {
+    super(), this.ai = t, this.host = e, this.model = n, this.client = new E({ host: e });
   }
-  toStandard(history) {
-    for (let i = 0; i < history.length; i++) {
-      if (history[i].role == "assistant" && history[i].tool_calls) {
-        if (history[i].content) delete history[i].tool_calls;
-        else {
-          history.splice(i, 1);
-          i--;
-        }
-      } else if (history[i].role == "tool") {
-        const error = history[i].content.startsWith('{"error":');
-        history[i] = { role: "tool", name: history[i].tool_name, args: history[i].args, [error ? "error" : "content"]: history[i].content };
+  client;
+  toStandard(t) {
+    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 };
       }
-    }
-    return history;
+    return t;
   }
-  fromStandard(history) {
-    return history.map((h) => {
-      if (h.role != "tool") return h;
-      return { role: "tool", tool_name: h.name, content: h.error || h.content };
-    });
+  fromStandard(t) {
+    return t.map((e) => e.role != "tool" ? e : { role: "tool", tool_name: e.name, content: e.error || e.content });
   }
-  ask(message, options = {}) {
-    const controller = new AbortController();
-    const response = new Promise(async (res, rej) => {
-      var _a, _b, _c, _d, _e, _f, _g;
-      let system = options.system || this.ai.options.system;
-      let history = this.fromStandard([...options.history || [], { role: "user", content: message }]);
-      if (history[0].roll == "system") {
-        if (!system) system = history.shift();
-        else history.shift();
-      }
-      if (options.compress) history = await this.ai.llm.compress(history, options.compress.max, options.compress.min);
-      if (options.system) history.unshift({ role: "system", content: system });
-      const requestParams = {
-        model: options.model || this.model,
-        messages: history,
-        stream: !!options.stream,
-        signal: controller.signal,
+  ask(t, e = {}) {
+    const n = new AbortController(), s = new Promise(async (i, f) => {
+      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 = {
+        model: e.model || this.model,
+        messages: m,
+        stream: !!e.stream,
+        signal: n.signal,
         options: {
-          temperature: options.temperature || this.ai.options.temperature || 0.7,
-          num_predict: options.max_tokens || this.ai.options.max_tokens || 4096
+          temperature: e.temperature || this.ai.options.temperature || 0.7,
+          num_predict: e.max_tokens || this.ai.options.max_tokens || 4096
         },
-        tools: (options.tools || this.ai.options.tools || []).map((t) => ({
+        tools: (e.tools || this.ai.options.tools || []).map((r) => ({
           type: "function",
           function: {
-            name: t.name,
-            description: t.description,
+            name: r.name,
+            description: r.description,
             parameters: {
               type: "object",
-              properties: t.args ? objectMap(t.args, (key, value) => ({ ...value, required: void 0 })) : {},
-              required: t.args ? Object.entries(t.args).filter((t2) => t2[1].required).map((t2) => t2[0]) : []
+              properties: r.args ? b(r.args, (a, u) => ({ ...u, required: void 0 })) : {},
+              required: r.args ? Object.entries(r.args).filter((a) => a[1].required).map((a) => a[0]) : []
             }
           }
         }))
       };
-      let resp;
+      let o;
       do {
-        resp = await this.client.chat(requestParams);
-        if (options.stream) {
-          resp.message = { role: "assistant", content: "", tool_calls: [] };
-          for await (const chunk of resp) {
-            if (controller.signal.aborted) break;
-            if ((_a = chunk.message) == null ? void 0 : _a.content) {
-              resp.message.content += chunk.message.content;
-              options.stream({ text: chunk.message.content });
-            }
-            if ((_b = chunk.message) == null ? void 0 : _b.tool_calls) resp.message.tool_calls = chunk.message.tool_calls;
-            if (chunk.done) break;
-          }
+        if (o = await this.client.chat(l), e.stream) {
+          o.message = { role: "assistant", content: "", tool_calls: [] };
+          for await (const r of o)
+            if (n.signal.aborted || (r.message?.content && (o.message.content += r.message.content, e.stream({ text: r.message.content })), r.message?.tool_calls && (o.message.tool_calls = r.message.tool_calls), r.done)) break;
         }
-        if (((_d = (_c = resp.message) == null ? void 0 : _c.tool_calls) == null ? void 0 : _d.length) && !controller.signal.aborted) {
-          history.push(resp.message);
-          const results = await Promise.all(resp.message.tool_calls.map(async (toolCall) => {
-            var _a2;
-            const tool = (_a2 = options.tools || this.ai.options.tools) == null ? void 0 : _a2.find(findByProp("name", toolCall.function.name));
-            if (!tool) return { role: "tool", tool_name: toolCall.function.name, content: '{"error": "Tool not found"}' };
-            const args = typeof toolCall.function.arguments === "string" ? JSONAttemptParse(toolCall.function.arguments, {}) : toolCall.function.arguments;
+        if (o.message?.tool_calls?.length && !n.signal.aborted) {
+          m.push(o.message);
+          const r = await Promise.all(o.message.tool_calls.map(async (a) => {
+            const u = (e.tools || this.ai.options.tools)?.find(k("name", a.function.name));
+            if (!u) return { role: "tool", tool_name: a.function.name, content: '{"error": "Tool not found"}' };
+            const p = typeof a.function.arguments == "string" ? w(a.function.arguments, {}) : a.function.arguments;
             try {
-              const result = await tool.fn(args, this.ai);
-              return { role: "tool", tool_name: toolCall.function.name, args, content: JSONSanitize(result) };
-            } catch (err) {
-              return { role: "tool", tool_name: toolCall.function.name, args, content: JSONSanitize({ error: (err == null ? void 0 : err.message) || (err == null ? void 0 : err.toString()) || "Unknown" }) };
+              const h = await u.fn(p, this.ai);
+              return { role: "tool", tool_name: a.function.name, args: p, content: _(h) };
+            } catch (h) {
+              return { role: "tool", tool_name: a.function.name, args: p, content: _({ error: h?.message || h?.toString() || "Unknown" }) };
             }
           }));
-          history.push(...results);
-          requestParams.messages = history;
+          m.push(...r), l.messages = m;
         }
-      } while (!controller.signal.aborted && ((_f = (_e = resp.message) == null ? void 0 : _e.tool_calls) == null ? void 0 : _f.length));
-      if (options.stream) options.stream({ done: true });
-      res(this.toStandard([...history, { role: "assistant", content: (_g = resp.message) == null ? void 0 : _g.content }]));
+      } while (!n.signal.aborted && o.message?.tool_calls?.length);
+      e.stream && e.stream({ done: !0 }), i(this.toStandard([...m, { role: "assistant", content: o.message?.content }]));
     });
-    return Object.assign(response, { abort: () => controller.abort() });
+    return Object.assign(s, { abort: () => n.abort() });
   }
 }
-class OpenAi extends LLMProvider {
-  constructor(ai, apiToken, model) {
-    super();
-    __publicField(this, "client");
-    this.ai = ai;
-    this.apiToken = apiToken;
-    this.model = model;
-    this.client = new OpenAI({ apiKey: apiToken });
+class R extends x {
+  constructor(t, e, n) {
+    super(), this.ai = t, this.apiToken = e, this.model = n, this.client = new M({ apiKey: e });
   }
-  toStandard(history) {
-    for (let i = 0; i < history.length; i++) {
-      const h = history[i];
-      if (h.role === "assistant" && h.tool_calls) {
-        const tools = h.tool_calls.map((tc) => ({
+  client;
+  toStandard(t) {
+    for (let e = 0; e < t.length; e++) {
+      const n = t[e];
+      if (n.role === "assistant" && n.tool_calls) {
+        const s = n.tool_calls.map((i) => ({
           role: "tool",
-          id: tc.id,
-          name: tc.function.name,
-          args: JSONAttemptParse(tc.function.arguments, {})
+          id: i.id,
+          name: i.function.name,
+          args: w(i.function.arguments, {})
         }));
-        history.splice(i, 1, ...tools);
-        i += tools.length - 1;
-      } else if (h.role === "tool" && h.content) {
-        const record = history.find((h2) => h.tool_call_id == h2.id);
-        if (record) {
-          if (h.content.includes('"error":')) record.error = h.content;
-          else record.content = h.content;
-        }
-        history.splice(i, 1);
-        i--;
+        t.splice(e, 1, ...s), e += s.length - 1;
+      } else if (n.role === "tool" && n.content) {
+        const s = t.find((i) => n.tool_call_id == i.id);
+        s && (n.content.includes('"error":') ? s.error = n.content : s.content = n.content), t.splice(e, 1), e--;
       }
     }
-    return history;
+    return t;
   }
-  fromStandard(history) {
-    return history.reduce((result, h) => {
-      if (h.role === "tool") {
-        result.push({
-          role: "assistant",
-          content: null,
-          tool_calls: [{ id: h.id, type: "function", function: { name: h.name, arguments: JSON.stringify(h.args) } }],
-          refusal: null,
-          annotations: []
-        }, {
-          role: "tool",
-          tool_call_id: h.id,
-          content: h.error || h.content
-        });
-      } else {
-        result.push(h);
-      }
-      return result;
-    }, []);
+  fromStandard(t) {
+    return t.reduce((e, n) => (n.role === "tool" ? e.push({
+      role: "assistant",
+      content: null,
+      tool_calls: [{ id: n.id, type: "function", function: { name: n.name, arguments: JSON.stringify(n.args) } }],
+      refusal: null,
+      annotations: []
+    }, {
+      role: "tool",
+      tool_call_id: n.id,
+      content: n.error || n.content
+    }) : e.push(n), e), []);
   }
-  ask(message, options = {}) {
-    const controller = new AbortController();
-    const response = new Promise(async (res, rej) => {
-      var _a, _b, _c, _d;
-      let history = this.fromStandard([...options.history || [], { role: "user", content: message }]);
-      if (options.compress) history = await this.ai.llm.compress(history, options.compress.max, options.compress.min, options);
-      const requestParams = {
-        model: options.model || this.model,
-        messages: history,
-        stream: !!options.stream,
-        max_tokens: options.max_tokens || this.ai.options.max_tokens || 4096,
-        temperature: options.temperature || this.ai.options.temperature || 0.7,
-        tools: (options.tools || this.ai.options.tools || []).map((t) => ({
+  ask(t, e = {}) {
+    const n = new AbortController(), s = new Promise(async (i, f) => {
+      let c = this.fromStandard([...e.history || [], { role: "user", content: t }]);
+      e.compress && (c = await this.ai.llm.compress(c, e.compress.max, e.compress.min, e));
+      const m = {
+        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((o) => ({
           type: "function",
           function: {
-            name: t.name,
-            description: t.description,
+            name: o.name,
+            description: o.description,
             parameters: {
               type: "object",
-              properties: t.args ? objectMap(t.args, (key, value) => ({ ...value, required: void 0 })) : {},
-              required: t.args ? Object.entries(t.args).filter((t2) => t2[1].required).map((t2) => t2[0]) : []
+              properties: o.args ? b(o.args, (r, a) => ({ ...a, required: void 0 })) : {},
+              required: o.args ? Object.entries(o.args).filter((r) => r[1].required).map((r) => r[0]) : []
             }
           }
         }))
       };
-      let resp;
+      let l;
       do {
-        resp = await this.client.chat.completions.create(requestParams);
-        if (options.stream) {
-          resp.choices = [];
-          for await (const chunk of resp) {
-            if (controller.signal.aborted) break;
-            if (chunk.choices[0].delta.content) {
-              options.stream({ text: chunk.choices[0].delta.content });
-            }
+        if (l = await this.client.chat.completions.create(m), e.stream) {
+          l.choices = [];
+          for await (const r of l) {
+            if (n.signal.aborted) break;
+            r.choices[0].delta.content && e.stream({ text: r.choices[0].delta.content });
           }
         }
-        const toolCalls = resp.choices[0].message.tool_calls || [];
-        if (toolCalls.length && !controller.signal.aborted) {
-          history.push(resp.choices[0].message);
-          const results = await Promise.all(toolCalls.map(async (toolCall) => {
-            var _a2;
-            const tool = (_a2 = options.tools) == null ? void 0 : _a2.find(findByProp("name", toolCall.function.name));
-            if (!tool) return { role: "tool", tool_call_id: toolCall.id, content: '{"error": "Tool not found"}' };
+        const o = l.choices[0].message.tool_calls || [];
+        if (o.length && !n.signal.aborted) {
+          c.push(l.choices[0].message);
+          const r = await Promise.all(o.map(async (a) => {
+            const u = e.tools?.find(k("name", a.function.name));
+            if (!u) return { role: "tool", tool_call_id: a.id, content: '{"error": "Tool not found"}' };
             try {
-              const args = JSONAttemptParse(toolCall.function.arguments, {});
-              const result = await tool.fn(args, this.ai);
-              return { role: "tool", tool_call_id: toolCall.id, content: JSONSanitize(result) };
-            } catch (err) {
-              return { role: "tool", tool_call_id: toolCall.id, content: JSONSanitize({ error: (err == null ? void 0 : err.message) || (err == null ? void 0 : err.toString()) || "Unknown" }) };
+              const p = w(a.function.arguments, {}), h = await u.fn(p, this.ai);
+              return { role: "tool", tool_call_id: a.id, content: _(h) };
+            } catch (p) {
+              return { role: "tool", tool_call_id: a.id, content: _({ error: p?.message || p?.toString() || "Unknown" }) };
             }
           }));
-          history.push(...results);
-          requestParams.messages = history;
+          c.push(...r), m.messages = c;
         }
-      } while (!controller.signal.aborted && ((_d = (_c = (_b = (_a = resp.choices) == null ? void 0 : _a[0]) == null ? void 0 : _b.message) == null ? void 0 : _c.tool_calls) == null ? void 0 : _d.length));
-      if (options.stream) options.stream({ done: true });
-      res(this.toStandard([...history, { role: "assistant", content: resp.choices[0].message.content || "" }]));
+      } while (!n.signal.aborted && l.choices?.[0]?.message?.tool_calls?.length);
+      e.stream && e.stream({ done: !0 }), i(this.toStandard([...c, { role: "assistant", content: l.choices[0].message.content || "" }]));
     });
-    return Object.assign(response, { abort: () => controller.abort() });
+    return Object.assign(s, { abort: () => n.abort() });
   }
 }
-class LLM {
-  constructor(ai, options) {
-    __publicField(this, "providers", {});
-    var _a, _b, _c;
-    this.ai = ai;
-    this.options = options;
-    if ((_a = options.anthropic) == null ? void 0 : _a.token) this.providers.anthropic = new Anthropic(this.ai, options.anthropic.token, options.anthropic.model);
-    if ((_b = options.ollama) == null ? void 0 : _b.host) this.providers.ollama = new Ollama(this.ai, options.ollama.host, options.ollama.model);
-    if ((_c = options.openAi) == null ? void 0 : _c.token) this.providers.openAi = new OpenAi(this.ai, options.openAi.token, options.openAi.model);
+class J {
+  constructor(t, e) {
+    this.ai = t, this.options = e, e.anthropic?.token && (this.providers.anthropic = new U(this.ai, e.anthropic.token, e.anthropic.model)), e.ollama?.host && (this.providers.ollama = new L(this.ai, e.ollama.host, e.ollama.model)), e.openAi?.token && (this.providers.openAi = new R(this.ai, e.openAi.token, e.openAi.model));
   }
+  providers = {};
   /**
    * Chat with LLM
    * @param {string} message Question
    * @param {LLMRequest} options Configuration options and chat history
    * @returns {{abort: () => void, response: Promise<LLMMessage[]>}} Function to abort response and chat history
    */
-  ask(message, options = {}) {
-    var _a, _b;
-    let model = [null, null];
-    if (options.model) {
-      if (typeof options.model == "object") model = options.model;
-      else model = [options.model, (_a = this.options[options.model]) == null ? void 0 : _a.model];
-    }
-    if (!options.model || model[1] == null) {
-      if (typeof this.options.model == "object") model = this.options.model;
-      else model = [this.options.model, (_b = this.options[this.options.model]) == null ? void 0 : _b.model];
-    }
-    if (!model[0] || !model[1]) throw new Error(`Unknown LLM provider or model: ${model[0]} / ${model[1]}`);
-    return this.providers[model[0]].ask(message, { ...options, model: model[1] });
+  ask(t, e = {}) {
+    let n = [null, null];
+    if (e.model && (typeof e.model == "object" ? n = e.model : n = [e.model, this.options[e.model]?.model]), (!e.model || n[1] == null) && (typeof this.options.model == "object" ? n = this.options.model : n = [this.options.model, this.options[this.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
@@ -391,36 +294,39 @@ class LLM {
    * @param {LLMRequest} options LLM options
    * @returns {Promise<LLMMessage[]>} New chat history will summary at index 0
    */
-  async compress(history, max, min, options) {
-    if (this.estimateTokens(history) < max) return history;
-    let keep = 0, tokens = 0;
-    for (let m of history.toReversed()) {
-      tokens += this.estimateTokens(m.content);
-      if (tokens < min) keep++;
+  async compress(t, e, n, s) {
+    if (this.estimateTokens(t) < e) return t;
+    let i = 0, f = 0;
+    for (let o of t.toReversed())
+      if (f += this.estimateTokens(o.content), f < n) i++;
       else break;
-    }
-    if (history.length <= keep) return history;
-    const recent = keep == 0 ? [] : history.slice(-keep), process = (keep == 0 ? history : history.slice(0, -keep)).filter((h) => h.role === "assistant" || h.role === "user");
-    const summary = await this.summarize(process.map((m) => `${m.role}: ${m.content}`).join("\n\n"), 250, options);
-    return [{ role: "assistant", content: `Conversation Summary: ${summary}` }, ...recent];
+    if (t.length <= i) return t;
+    const c = i == 0 ? [] : t.slice(-i), m = (i == 0 ? t : t.slice(0, -i)).filter((o) => o.role === "assistant" || o.role === "user");
+    return [{ role: "assistant", content: `Conversation Summary: ${await this.summarize(m.map((o) => `${o.role}: ${o.content}`).join(`
+
+`), 250, s)}` }, ...c];
   }
   /**
    * Estimate variable as tokens
    * @param history Object to size
    * @returns {number} Rough token count
    */
-  estimateTokens(history) {
-    const text = JSON.stringify(history);
-    return Math.ceil(text.length / 4 * 1.2);
+  estimateTokens(t) {
+    const e = JSON.stringify(t);
+    return Math.ceil(e.length / 4 * 1.2);
   }
-  async json(message, options) {
-    var _a;
-    let resp = await this.ask(message, {
-      system: "",
-      ...options
+  /**
+   * Ask a question with JSON response
+   * @param {string} message Question
+   * @param {LLMRequest} options Configuration options and chat history
+   * @returns {Promise<{} | {} | RegExpExecArray | null>}
+   */
+  async json(t, e) {
+    let n = await this.ask(t, {
+      system: "Respond using a JSON blob",
+      ...e
     });
-    if (!((_a = resp == null ? void 0 : resp[0]) == null ? void 0 : _a.content)) return {};
-    return JSONAttemptParse(new RegExp("{[sS]*}").exec(resp[0].content), {});
+    return n?.[0]?.content ? w(new RegExp("{[sS]*}").exec(n[0].content), {}) : {};
   }
   /**
    * Create a summary of some text
@@ -429,39 +335,29 @@ class LLM {
    * @param options LLM request options
    * @returns {Promise<string>} Summary
    */
-  summarize(text, tokens, options) {
-    return this.ask(text, { system: `Generate a brief summary <= ${tokens} tokens. Output nothing else`, temperature: 0.3, ...options }).then((history) => {
-      var _a;
-      return ((_a = history.pop()) == null ? void 0 : _a.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 Ai {
-  constructor(options) {
-    __publicField(this, "downloads", {});
-    __publicField(this, "whisperModel");
-    /** Large Language Models */
-    __publicField(this, "llm");
-    var _a;
-    this.options = options;
-    this.llm = new LLM(this, options);
-    if ((_a = this.options.whisper) == null ? void 0 : _a.binary) this.downloadAsrModel(this.options.whisper.model);
+class V {
+  constructor(t) {
+    this.options = t, this.llm = new J(this, t), this.options.whisper?.binary && this.downloadAsrModel(this.options.whisper.model);
   }
+  downloads = {};
+  whisperModel;
+  /** Large Language Models */
+  llm;
   /**
    * Convert audio to text using Auditory Speech Recognition
    * @param {string} path Path to audio
    * @param model Whisper model
    * @returns {Promise<any>} Extracted text
    */
-  async asr(path, model) {
-    var _a;
-    if (!((_a = this.options.whisper) == null ? void 0 : _a.binary)) throw new Error("Whisper not configured");
-    if (!model) model = this.options.whisper.model;
-    await this.downloadAsrModel(model);
-    const name = Math.random().toString(36).substring(2, 10) + "-" + path.split("/").pop();
-    const output = Path.join(this.options.whisper.path || "/tmp", name);
-    await $`rm -f /tmp/${name}.txt && ${this.options.whisper.binary} -nt -np -m ${this.whisperModel} -f ${path} -otxt -of ${output}`;
-    return fs.readFile(output, "utf-8").then((text) => (text == null ? void 0 : text.trim()) || null).finally(() => fs.rm(output, { force: true }).catch(() => {
+  async asr(t, e) {
+    if (!this.options.whisper?.binary) throw new Error("Whisper not configured");
+    e || (e = this.options.whisper.model), await this.downloadAsrModel(e);
+    const n = Math.random().toString(36).substring(2, 10) + "-" + t.split("/").pop(), s = S.join(this.options.whisper.path || "/tmp", n);
+    return await j`rm -f /tmp/${n}.txt && ${this.options.whisper.binary} -nt -np -m ${this.whisperModel} -f ${t} -otxt -of ${s}`, y.readFile(s, "utf-8").then((i) => i?.trim() || null).finally(() => y.rm(s, { force: !0 }).catch(() => {
     }));
   }
   /**
@@ -470,34 +366,28 @@ class Ai {
    * @param {string} model Whisper model that will be downloaded
    * @return {Promise<void>} A promise that resolves once the model is downloaded and saved locally.
    */
-  async downloadAsrModel(model) {
-    var _a, _b, _c, _d;
-    if (!((_a = this.options.whisper) == null ? void 0 : _a.binary)) throw new Error("Whisper not configured");
-    this.whisperModel = Path.join((_b = this.options.whisper) == null ? void 0 : _b.path, ((_c = this.options.whisper) == null ? void 0 : _c.model) + ".bin");
-    if (await fs.stat(this.whisperModel).then(() => true).catch(() => false)) return;
-    if (!!this.downloads[model]) return this.downloads[model];
-    this.downloads[model] = fetch(`https://huggingface.co/ggerganov/whisper.cpp/resolve/main/${(_d = this.options.whisper) == null ? void 0 : _d.model}.bin`).then((resp) => resp.arrayBuffer()).then((arr) => Buffer.from(arr)).then(async (buffer) => {
-      await fs.writeFile(this.whisperModel, buffer);
-      delete this.downloads[model];
-    });
-    return this.downloads[model];
+  async downloadAsrModel(t) {
+    if (!this.options.whisper?.binary) throw new Error("Whisper not configured");
+    if (this.whisperModel = S.join(this.options.whisper?.path, this.options.whisper?.model + ".bin"), !await y.stat(this.whisperModel).then(() => !0).catch(() => !1))
+      return this.downloads[t] ? this.downloads[t] : (this.downloads[t] = fetch(`https://huggingface.co/ggerganov/whisper.cpp/resolve/main/${this.options.whisper?.model}.bin`).then((e) => e.arrayBuffer()).then((e) => Buffer.from(e)).then(async (e) => {
+        await y.writeFile(this.whisperModel, e), delete this.downloads[t];
+      }), this.downloads[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
    */
-  ocr(path) {
-    let worker;
+  ocr(t) {
+    let e;
     return {
       abort: () => {
-        worker == null ? void 0 : worker.terminate();
+        e?.terminate();
       },
-      response: new Promise(async (res) => {
-        worker = await createWorker("eng");
-        const { data } = await worker.recognize(path);
-        await worker.terminate();
-        res(data.text.trim() || null);
+      response: new Promise(async (n) => {
+        e = await q("eng");
+        const { data: s } = await e.recognize(t);
+        await e.terminate(), n(s.text.trim() || null);
       })
     };
   }
@@ -507,124 +397,104 @@ class Ai {
    * @param {string} searchTerms Multiple search terms to check against target
    * @returns {{avg: number, max: number, similarities: number[]}} Similarity values 0-1: 0 = unique, 1 = identical
    */
-  semanticSimilarity(target, ...searchTerms) {
-    if (searchTerms.length < 2) throw new Error("Requires at least 2 strings to compare");
-    const vector = (text, dimensions = 10) => {
-      return text.toLowerCase().split("").map((char, index) => char.charCodeAt(0) * (index + 1) % dimensions / dimensions).slice(0, dimensions);
-    };
-    const cosineSimilarity = (v1, v2) => {
-      if (v1.length !== v2.length) throw new Error("Vectors must be same length");
-      const tensor1 = tf.tensor1d(v1), tensor2 = tf.tensor1d(v2);
-      const dotProduct = tf.dot(tensor1, tensor2);
-      const magnitude1 = tf.norm(tensor1);
-      const magnitude2 = tf.norm(tensor2);
-      if (magnitude1.dataSync()[0] === 0 || magnitude2.dataSync()[0] === 0) return 0;
-      return dotProduct.dataSync()[0] / (magnitude1.dataSync()[0] * magnitude2.dataSync()[0]);
-    };
-    const v = vector(target);
-    const similarities = searchTerms.map((t) => vector(t)).map((refVector) => cosineSimilarity(v, refVector));
-    return { avg: similarities.reduce((acc, s) => acc + s, 0) / similarities.length, max: Math.max(...similarities), similarities };
+  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, o) => l.charCodeAt(0) * (o + 1) % m / m).slice(0, m), s = (c, m) => {
+      if (c.length !== m.length) throw new Error("Vectors must be same length");
+      const l = g.tensor1d(c), o = g.tensor1d(m), r = g.dot(l, o), a = g.norm(l), u = g.norm(o);
+      return a.dataSync()[0] === 0 || u.dataSync()[0] === 0 ? 0 : r.dataSync()[0] / (a.dataSync()[0] * u.dataSync()[0]);
+    }, i = n(t), f = e.map((c) => n(c)).map((c) => s(i, c));
+    return { avg: f.reduce((c, m) => c + m, 0) / f.length, max: Math.max(...f), similarities: f };
   }
 }
-const CliTool = {
+const I = {
   name: "cli",
   description: "Use the command line interface, returns any output",
-  args: { command: { type: "string", description: "Command to run", required: true } },
-  fn: (args) => $`${args.command}`
-};
-const DateTimeTool = {
+  args: { command: { type: "string", description: "Command to run", required: !0 } },
+  fn: (d) => j`${d.command}`
+}, Q = {
   name: "get_datetime",
   description: "Get current date and time",
   args: {},
   fn: async () => (/* @__PURE__ */ new Date()).toISOString()
-};
-const ExecTool = {
+}, X = {
   name: "exec",
   description: "Run code/scripts",
   args: {
-    language: { type: "string", description: "Execution language", enum: ["cli", "node", "python"], required: true },
-    code: { type: "string", description: "Code to execute", required: true }
+    language: { type: "string", description: "Execution language", enum: ["cli", "node", "python"], required: !0 },
+    code: { type: "string", description: "Code to execute", required: !0 }
   },
-  fn: async (args, ai) => {
+  fn: async (d, t) => {
     try {
-      switch (args.type) {
+      switch (d.type) {
         case "bash":
-          return await CliTool.fn({ command: args.code }, ai);
+          return await I.fn({ command: d.code }, t);
         case "node":
-          return await JSTool.fn({ code: args.code }, ai);
-        case "python": {
-          return await PythonTool.fn({ code: args.code }, ai);
-        }
+          return await N.fn({ code: d.code }, t);
+        case "python":
+          return await z.fn({ code: d.code }, t);
       }
-    } catch (err) {
-      return { error: (err == null ? void 0 : err.message) || err.toString() };
+    } catch (e) {
+      return { error: e?.message || e.toString() };
     }
   }
-};
-const FetchTool = {
+}, Y = {
   name: "fetch",
   description: "Make HTTP request to URL",
   args: {
-    url: { type: "string", description: "URL to fetch", required: true },
+    url: { type: "string", description: "URL to fetch", required: !0 },
     method: { type: "string", description: "HTTP method to use", enum: ["GET", "POST", "PUT", "DELETE"], default: "GET" },
     headers: { type: "object", description: "HTTP headers to send", default: {} },
     body: { type: "object", description: "HTTP body to send" }
   },
-  fn: (args) => new Http({ url: args.url, headers: args.headers }).request({ method: args.method || "GET", body: args.body })
-};
-const JSTool = {
+  fn: (d) => new v({ url: d.url, headers: d.headers }).request({ method: d.method || "GET", body: d.body })
+}, N = {
   name: "exec_javascript",
   description: "Execute commonjs javascript",
   args: {
-    code: { type: "string", description: "CommonJS javascript", required: true }
+    code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
-  fn: async (args) => {
-    const console = consoleInterceptor(null);
-    const resp = await fn({ console }, args.code, true).catch((err) => console.output.error.push(err));
-    return { ...console.output, return: resp, stdout: void 0, stderr: void 0 };
+  fn: async (d) => {
+    const t = P(null), e = await A({ console: t }, d.code, !0).catch((n) => t.output.error.push(n));
+    return { ...t.output, return: e, stdout: void 0, stderr: void 0 };
   }
-};
-const PythonTool = {
+}, z = {
   name: "exec_javascript",
   description: "Execute commonjs javascript",
   args: {
-    code: { type: "string", description: "CommonJS javascript", required: true }
+    code: { type: "string", description: "CommonJS javascript", required: !0 }
   },
-  fn: async (args) => ({ result: $Sync`python -c "${args.code}"` })
-};
-const SearchTool = {
+  fn: async (d) => ({ result: T`python -c "${d.code}"` })
+}, Z = {
   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: true },
+    query: { type: "string", description: "Search string", required: !0 },
     length: { type: "string", description: "Number of results to return", default: 5 }
   },
-  fn: async (args) => {
-    var _a;
-    const html = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(args.query)}`, {
+  fn: async (d) => {
+    const t = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(d.query)}`, {
       headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)", "Accept-Language": "en-US,en;q=0.9" }
-    }).then((resp) => resp.text());
-    let match, regex = /<a .*?href="(.+?)".+?<\/a>/g;
-    const results = new ASet();
-    while ((match = regex.exec(html)) !== null) {
-      let url = (_a = /uddg=(.+)&amp?/.exec(decodeURIComponent(match[1]))) == null ? void 0 : _a[1];
-      if (url) url = decodeURIComponent(url);
-      if (url) results.add(url);
-      if (results.size >= (args.length || 5)) break;
+    }).then((i) => i.text());
+    let e, n = /<a .*?href="(.+?)".+?<\/a>/g;
+    const s = new O();
+    for (; (e = n.exec(t)) !== null; ) {
+      let i = /uddg=(.+)&amp?/.exec(decodeURIComponent(e[1]))?.[1];
+      if (i && (i = decodeURIComponent(i)), i && s.add(i), s.size >= (d.length || 5)) break;
     }
-    return results;
+    return s;
   }
 };
 export {
-  Ai,
-  Anthropic,
-  CliTool,
-  DateTimeTool,
-  ExecTool,
-  FetchTool,
-  JSTool,
-  LLM,
-  PythonTool,
-  SearchTool
+  V as Ai,
+  U as Anthropic,
+  I as CliTool,
+  Q as DateTimeTool,
+  X as ExecTool,
+  Y as FetchTool,
+  N as JSTool,
+  J as LLM,
+  z as PythonTool,
+  Z as SearchTool
 };
 //# sourceMappingURL=index.mjs.map