@ztimson/ai-utils 0.1.0

package/dist/index.mjs

@@ -0,0 +1,621 @@
+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 {
+}
+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 });
+  }
+  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: 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 = 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(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: 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$1({ 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: 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(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;
+            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" }) };
+            }
+          }));
+          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({ 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: 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: 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(findByProp("name", toolCall.function.name));
+            if (!tool) return { role: "tool", tool_call_id: toolCall.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" }) };
+            }
+          }));
+          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 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 $`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 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.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 };
+  }
+}
+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) => $`${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 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 = 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 };
+  }
+};
+const PythonTool = {
+  name: "exec_javascript",
+  description: "Execute commonjs javascript",
+  args: {
+    code: { type: "string", description: "CommonJS javascript", required: true }
+  },
+  fn: async (args) => ({ result: $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 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;
+  }
+};
+export {
+  Ai,
+  Anthropic,
+  CliTool,
+  DateTimeTool,
+  ExecTool,
+  FetchTool,
+  JSTool,
+  LLM,
+  PythonTool,
+  SearchTool
+};
+//# sourceMappingURL=index.mjs.map