@ztimson/ai-utils 0.1.0

package/dist/index.js

@@ -0,0 +1,633 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("@ztimson/node-utils"), require("tesseract.js"), require("@ztimson/utils"), require("@anthropic-ai/sdk"), require("ollama"), require("openai"), require("node:fs/promises"), require("node:path"), require("@tensorflow/tfjs")) : typeof define === "function" && define.amd ? define(["exports", "@ztimson/node-utils", "tesseract.js", "@ztimson/utils", "@anthropic-ai/sdk", "ollama", "openai", "node:fs/promises", "node:path", "@tensorflow/tfjs"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.utils = {}, global.nodeUtils, global.tesseract_js, global.utils, global.sdk, global.ollama, global.openai, global.fs, global.Path, global.tf));
+})(this, function(exports2, nodeUtils, tesseract_js, utils, sdk, ollama, openai, fs, Path, tf) {
+  "use strict";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);
+
+  function _interopNamespaceDefault(e) {
+    const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+    if (e) {
+      for (const k in e) {
+        if (k !== "default") {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          Object.defineProperty(n, k, d.get ? d : {
+            enumerable: true,
+            get: () => e[k]
+          });
+        }
+      }
+    }
+    n.default = e;
+    return Object.freeze(n);
+  }
+  const tf__namespace = /* @__PURE__ */ _interopNamespaceDefault(tf);
+  class LLMProvider {
+  }
+  class Anthropic extends LLMProvider {
+    constructor(ai, apiToken, model) {
+      super();
+      __publicField(this, "client");
+      this.ai = ai;
+      this.apiToken = apiToken;
+      this.model = model;
+      this.client = new sdk.Anthropic({ apiKey: apiToken });
+    }
+    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");
+        }
+      }
+      return history.filter((h) => !!h.content);
+    }
+    fromStandard(history) {
+      for (let i = 0; i < history.length; i++) {
+        if (history[i].role == "tool") {
+          const h = history[i];
+          history.splice(
+            i,
+            0,
+            { 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 += 2;
+        }
+      }
+      return history;
+    }
+    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,
+            input_schema: {
+              type: "object",
+              properties: utils.objectMap(t.args, (key, value) => ({ ...value, required: void 0 })),
+              required: Object.entries(t.args || {}).filter((t2) => t2[1].required).map((t2) => t2[0])
+            },
+            fn: void 0
+          })),
+          messages: history,
+          stream: !!options.stream
+        };
+        let resp;
+        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) last.input = utils.JSONAttemptParse(last.input, {});
+              } else if (chunk.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(utils.findByProp("name", toolCall.name));
+              if (!tool) return { tool_use_id: toolCall.id, is_error: true, content: "Tool not found" };
+              try {
+                const result = await tool.fn(toolCall.input, this.ai);
+                return { type: "tool_result", tool_use_id: toolCall.id, content: utils.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" };
+              }
+            }));
+            history.push({ role: "user", content: results });
+            requestParams.messages = history;
+          }
+        } while (!controller.signal.aborted && resp.content.some((c) => c.type === "tool_use"));
+        if (options.stream) options.stream({ done: true });
+        res(this.toStandard([...history, {
+          role: "assistant",
+          content: resp.content.filter((c) => c.type == "text").map((c) => c.text).join("\n\n")
+        }]));
+      });
+      return Object.assign(response, { abort: () => controller.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.Ollama({ host });
+    }
+    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 };
+        }
+      }
+      return history;
+    }
+    fromStandard(history) {
+      return history.map((h) => {
+        if (h.role != "tool") return h;
+        return { role: "tool", tool_name: h.name, content: h.error || h.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,
+          options: {
+            temperature: options.temperature || this.ai.options.temperature || 0.7,
+            num_predict: options.max_tokens || this.ai.options.max_tokens || 4096
+          },
+          tools: (options.tools || this.ai.options.tools || []).map((t) => ({
+            type: "function",
+            function: {
+              name: t.name,
+              description: t.description,
+              parameters: {
+                type: "object",
+                properties: utils.objectMap(t.args, (key, value) => ({ ...value, required: void 0 })),
+                required: Object.entries(t.args || {}).filter((t2) => t2[1].required).map((t2) => t2[0])
+              }
+            }
+          }))
+        };
+        let resp;
+        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 (((_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(utils.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" ? utils.JSONAttemptParse(toolCall.function.arguments, {}) : toolCall.function.arguments;
+              try {
+                const result = await tool.fn(args, this.ai);
+                return { role: "tool", tool_name: toolCall.function.name, args, content: utils.JSONSanitize(result) };
+              } catch (err) {
+                return { role: "tool", tool_name: toolCall.function.name, args, content: utils.JSONSanitize({ error: (err == null ? void 0 : err.message) || (err == null ? void 0 : err.toString()) || "Unknown" }) };
+              }
+            }));
+            history.push(...results);
+            requestParams.messages = history;
+          }
+        } 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 }]));
+      });
+      return Object.assign(response, { abort: () => controller.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.OpenAI({ apiKey: apiToken });
+    }
+    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) => ({
+            role: "tool",
+            id: tc.id,
+            name: tc.function.name,
+            args: utils.JSONAttemptParse(tc.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--;
+        }
+      }
+      return history;
+    }
+    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;
+      }, []);
+    }
+    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) => ({
+            type: "function",
+            function: {
+              name: t.name,
+              description: t.description,
+              parameters: {
+                type: "object",
+                properties: utils.objectMap(t.args, (key, value) => ({ ...value, required: void 0 })),
+                required: Object.entries(t.args || {}).filter((t2) => t2[1].required).map((t2) => t2[0])
+              }
+            }
+          }))
+        };
+        let resp;
+        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 });
+              }
+            }
+          }
+          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(utils.findByProp("name", toolCall.function.name));
+              if (!tool) return { role: "tool", tool_call_id: toolCall.id, content: '{"error": "Tool not found"}' };
+              try {
+                const args = utils.JSONAttemptParse(toolCall.function.arguments, {});
+                const result = await tool.fn(args, this.ai);
+                return { role: "tool", tool_call_id: toolCall.id, content: utils.JSONSanitize(result) };
+              } catch (err) {
+                return { role: "tool", tool_call_id: toolCall.id, content: utils.JSONSanitize({ error: (err == null ? void 0 : err.message) || (err == null ? void 0 : err.toString()) || "Unknown" }) };
+              }
+            }));
+            history.push(...results);
+            requestParams.messages = history;
+          }
+        } 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 || "" }]));
+      });
+      return Object.assign(response, { abort: () => controller.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);
+    }
+    /**
+     * 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;
+      const model = [((_a = options.model) == null ? void 0 : _a[0]) || this.options.model[0], ((_b = options.model) == null ? void 0 : _b[1]) || this.options.model[1]];
+      if (!this.providers[model[0]]) throw new Error(`Unknown LLM provider: ${model[0]}`);
+      return this.providers[model[0]].ask(message, { ...options, model: model[1] });
+    }
+    /**
+     * Compress chat history to reduce context size
+     * @param {LLMMessage[]} history Chatlog that will be compressed
+     * @param max Trigger compression once context is larger than max
+     * @param min Summarize until context size is less than min
+     * @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++;
+        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];
+    }
+    /**
+     * 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);
+    }
+    async json(message, options) {
+      var _a;
+      let resp = await this.ask(message, {
+        system: "",
+        ...options
+      });
+      if (!((_a = resp == null ? void 0 : resp[0]) == null ? void 0 : _a.content)) return {};
+      return utils.JSONAttemptParse(new RegExp("{[sS]*}").exec(resp[0].content), {});
+    }
+    /**
+     * Create a summary of some text
+     * @param {string} text Text to summarize
+     * @param {number} tokens Max number of tokens
+     * @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;
+      });
+    }
+  }
+  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);
+    }
+    /**
+     * 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 nodeUtils.$`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(() => {
+      }));
+    }
+    /**
+     * Downloads the specified Whisper model if it is not already present locally.
+     *
+     * @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];
+    }
+    /**
+     * 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;
+      return {
+        abort: () => {
+          worker == null ? void 0 : worker.terminate();
+        },
+        response: new Promise(async (res) => {
+          worker = await tesseract_js.createWorker("eng");
+          const { data } = await worker.recognize(path);
+          await worker.terminate();
+          res(data.text.trim() || null);
+        })
+      };
+    }
+    /**
+     * Compare the difference between two strings using tensor math
+     * @param target Text that will checked
+     * @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__namespace.tensor1d(v1), tensor2 = tf__namespace.tensor1d(v2);
+        const dotProduct = tf__namespace.dot(tensor1, tensor2);
+        const magnitude1 = tf__namespace.norm(tensor1);
+        const magnitude2 = tf__namespace.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 };
+    }
+  }
+  const CliTool = {
+    name: "cli",
+    description: "Use the command line interface, returns any output",
+    args: { command: { type: "string", description: "Command to run", required: true } },
+    fn: (args) => nodeUtils.$`${args.command}`
+  };
+  const DateTimeTool = {
+    name: "get_datetime",
+    description: "Get current date and time",
+    fn: async () => (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const ExecTool = {
+    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 }
+    },
+    fn: async (args, ai) => {
+      try {
+        switch (args.type) {
+          case "bash":
+            return await CliTool.fn({ command: args.code }, ai);
+          case "node":
+            return await JSTool.fn({ code: args.code }, ai);
+          case "python": {
+            return await PythonTool.fn({ code: args.code }, ai);
+          }
+        }
+      } catch (err) {
+        return { error: (err == null ? void 0 : err.message) || err.toString() };
+      }
+    }
+  };
+  const FetchTool = {
+    name: "fetch",
+    description: "Make HTTP request to URL",
+    args: {
+      url: { type: "string", description: "URL to fetch", required: true },
+      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 utils.Http({ url: args.url, headers: args.headers }).request({ method: args.method || "GET", body: args.body })
+  };
+  const JSTool = {
+    name: "exec_javascript",
+    description: "Execute commonjs javascript",
+    args: {
+      code: { type: "string", description: "CommonJS javascript", required: true }
+    },
+    fn: async (args) => {
+      const console = utils.consoleInterceptor(null);
+      const resp = await utils.fn({ console }, args.code, true).catch((err) => console.output.error.push(err));
+      return { ...console.output, return: resp, stdout: void 0, stderr: void 0 };
+    }
+  };
+  const PythonTool = {
+    name: "exec_javascript",
+    description: "Execute commonjs javascript",
+    args: {
+      code: { type: "string", description: "CommonJS javascript", required: true }
+    },
+    fn: async (args) => ({ result: nodeUtils.$Sync`python -c "${args.code}"` })
+  };
+  const SearchTool = {
+    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 },
+      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)}`, {
+        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 utils.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;
+      }
+      return results;
+    }
+  };
+  exports2.Ai = Ai;
+  exports2.Anthropic = Anthropic;
+  exports2.CliTool = CliTool;
+  exports2.DateTimeTool = DateTimeTool;
+  exports2.ExecTool = ExecTool;
+  exports2.FetchTool = FetchTool;
+  exports2.JSTool = JSTool;
+  exports2.LLM = LLM;
+  exports2.PythonTool = PythonTool;
+  exports2.SearchTool = SearchTool;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+});
+//# sourceMappingURL=index.js.map