@visulima/error 4.4.18 → 4.6.0

package/dist/index.cjs

@@ -3,23 +3,41 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
 
 const codeFrame_index = require('./code-frame/index.cjs');
-const indexToLineColumn = require('./packem_shared/indexToLineColumn-DjmjeiIY.cjs');
+const indexToLineColumn = require('./packem_shared/indexToLineColumn-Cro5eT8v.cjs');
+const solution_ai_aiPrompt = require('./solution/ai/ai-prompt.cjs');
+const aiSolutionResponse = require('./packem_shared/aiSolutionResponse-Cqi0mFxy.cjs');
+const errorHintFinder = require('./packem_shared/errorHintFinder-DZugFHq0.cjs');
+const ruleBasedFinder = require('./packem_shared/ruleBasedFinder-CkybTSHw.cjs');
 const captureRawStackTrace = require('./packem_shared/captureRawStackTrace-ClSI1tHb.cjs');
+const deserializeError = require('./packem_shared/deserializeError-Be3qOGBQ.cjs');
 const getErrorCauses = require('./packem_shared/getErrorCauses-miTeYJEG.cjs');
-const parseStacktrace = require('./packem_shared/parseStacktrace-6pFoXW43.cjs');
-const isVisulimaError = require('./packem_shared/isVisulimaError-BVLWvREw.cjs');
-const renderError = require('./packem_shared/renderError-CXZTAXig.cjs');
-const serializeError = require('./packem_shared/serializeError-CT7s0Ffk.cjs');
+const NonError = require('./packem_shared/NonError-DqwGL5Cy.cjs');
+const parseStacktrace = require('./packem_shared/parseStacktrace-woJgU2XY.cjs');
+const addKnownErrorConstructor = require('./packem_shared/addKnownErrorConstructor-J1_ZUURa.cjs');
+const isVisulimaError = require('./packem_shared/isVisulimaError-Bb1_TB6w.cjs');
+const renderError = require('./packem_shared/renderError-n3kXGdYj.cjs');
+const serializeError = require('./packem_shared/serializeError-Dt7oFM2R.cjs');
+const formatStackFrameLine = require('./packem_shared/formatStackFrameLine-DcXSX--m.cjs');
 
 
 
 exports.CODE_FRAME_POINTER = codeFrame_index.CODE_FRAME_POINTER;
 exports.codeFrame = codeFrame_index.codeFrame;
 exports.indexToLineColumn = indexToLineColumn;
+exports.aiPrompt = solution_ai_aiPrompt;
+exports.aiSolutionResponse = aiSolutionResponse;
+exports.errorHintFinder = errorHintFinder;
+exports.ruleBasedFinder = ruleBasedFinder;
 exports.captureRawStackTrace = captureRawStackTrace;
+exports.deserializeError = deserializeError;
 exports.getErrorCauses = getErrorCauses;
+exports.NonError = NonError;
 exports.parseStacktrace = parseStacktrace;
+exports.addKnownErrorConstructor = addKnownErrorConstructor.addKnownErrorConstructor;
+exports.isErrorLike = addKnownErrorConstructor.isErrorLike;
 exports.VisulimaError = isVisulimaError.VisulimaError;
 exports.isVisulimaError = isVisulimaError.isVisulimaError;
 exports.renderError = renderError.renderError;
 exports.serializeError = serializeError.serialize;
+exports.formatStackFrameLine = formatStackFrameLine.formatStackFrameLine;
+exports.formatStacktrace = formatStackFrameLine.formatStacktrace;

package/dist/index.d.cts

@@ -1,6 +1,10 @@
 export { CODE_FRAME_POINTER, codeFrame } from './code-frame/index.cjs';
-export { ErrorHint, ErrorLocation, ErrorProperties, ErrorWithCauseSerializerOptions, RenderErrorOptions, SerializedError, VisulimaError, captureRawStackTrace, getErrorCauses, isVisulimaError, renderError, serializeError } from './error/index.cjs';
-export { Trace, TraceType, parseStacktrace } from './stacktrace/index.cjs';
+export { default as aiPrompt } from './solution/ai/ai-prompt.cjs';
+export { a as aiSolutionResponse } from './packem_shared/ai-solution-response-BuaDQAEU.cjs';
+export { errorHintFinder, ruleBasedFinder } from './solution/index.cjs';
+export { S as Solution, a as SolutionError, b as SolutionFinder, c as SolutionFinderFile } from './packem_shared/types-BtQS7FHG.cjs';
+export { ErrorHint, ErrorLocation, ErrorProperties, ErrorWithCauseSerializerOptions, NonError, RenderErrorOptions, SerializedError, VisulimaError, addKnownErrorConstructor, captureRawStackTrace, deserializeError, getErrorCauses, isErrorLike, isVisulimaError, renderError, serializeError } from './error/index.cjs';
+export { Trace, TraceType, formatStackFrameLine, formatStacktrace, parseStacktrace } from './stacktrace/index.cjs';
 export { C as CodeFrameLocation, a as CodeFrameNodeLocation, b as CodeFrameOptions, c as ColorizeMethod } from './packem_shared/types-CrVmNoPV.cjs';
 
 declare const indexToLineColumn: (input: number[] | string, index: number, options?: {

package/dist/index.d.mts

@@ -1,6 +1,10 @@
 export { CODE_FRAME_POINTER, codeFrame } from './code-frame/index.mjs';
-export { ErrorHint, ErrorLocation, ErrorProperties, ErrorWithCauseSerializerOptions, RenderErrorOptions, SerializedError, VisulimaError, captureRawStackTrace, getErrorCauses, isVisulimaError, renderError, serializeError } from './error/index.mjs';
-export { Trace, TraceType, parseStacktrace } from './stacktrace/index.mjs';
+export { default as aiPrompt } from './solution/ai/ai-prompt.mjs';
+export { a as aiSolutionResponse } from './packem_shared/ai-solution-response-BuaDQAEU.mjs';
+export { errorHintFinder, ruleBasedFinder } from './solution/index.mjs';
+export { S as Solution, a as SolutionError, b as SolutionFinder, c as SolutionFinderFile } from './packem_shared/types-BtQS7FHG.mjs';
+export { ErrorHint, ErrorLocation, ErrorProperties, ErrorWithCauseSerializerOptions, NonError, RenderErrorOptions, SerializedError, VisulimaError, addKnownErrorConstructor, captureRawStackTrace, deserializeError, getErrorCauses, isErrorLike, isVisulimaError, renderError, serializeError } from './error/index.mjs';
+export { Trace, TraceType, formatStackFrameLine, formatStacktrace, parseStacktrace } from './stacktrace/index.mjs';
 export { C as CodeFrameLocation, a as CodeFrameNodeLocation, b as CodeFrameOptions, c as ColorizeMethod } from './packem_shared/types-CrVmNoPV.mjs';
 
 declare const indexToLineColumn: (input: number[] | string, index: number, options?: {

package/dist/index.d.ts

@@ -1,6 +1,10 @@
 export { CODE_FRAME_POINTER, codeFrame } from './code-frame/index.js';
-export { ErrorHint, ErrorLocation, ErrorProperties, ErrorWithCauseSerializerOptions, RenderErrorOptions, SerializedError, VisulimaError, captureRawStackTrace, getErrorCauses, isVisulimaError, renderError, serializeError } from './error/index.js';
-export { Trace, TraceType, parseStacktrace } from './stacktrace/index.js';
+export { default as aiPrompt } from './solution/ai/ai-prompt.js';
+export { a as aiSolutionResponse } from './packem_shared/ai-solution-response-BuaDQAEU.js';
+export { errorHintFinder, ruleBasedFinder } from './solution/index.js';
+export { S as Solution, a as SolutionError, b as SolutionFinder, c as SolutionFinderFile } from './packem_shared/types-BtQS7FHG.js';
+export { ErrorHint, ErrorLocation, ErrorProperties, ErrorWithCauseSerializerOptions, NonError, RenderErrorOptions, SerializedError, VisulimaError, addKnownErrorConstructor, captureRawStackTrace, deserializeError, getErrorCauses, isErrorLike, isVisulimaError, renderError, serializeError } from './error/index.js';
+export { Trace, TraceType, formatStackFrameLine, formatStacktrace, parseStacktrace } from './stacktrace/index.js';
 export { C as CodeFrameLocation, a as CodeFrameNodeLocation, b as CodeFrameOptions, c as ColorizeMethod } from './packem_shared/types-CrVmNoPV.js';
 
 declare const indexToLineColumn: (input: number[] | string, index: number, options?: {

package/dist/index.mjs

@@ -1,8 +1,16 @@
 export { CODE_FRAME_POINTER, codeFrame } from './code-frame/index.mjs';
-export { default as indexToLineColumn } from './packem_shared/indexToLineColumn-Dx91YDU1.mjs';
+export { default as indexToLineColumn } from './packem_shared/indexToLineColumn-CKQKtKEK.mjs';
+export { default as aiPrompt } from './solution/ai/ai-prompt.mjs';
+export { default as aiSolutionResponse } from './packem_shared/aiSolutionResponse-BaN1M990.mjs';
+export { default as errorHintFinder } from './packem_shared/errorHintFinder-CQy_qIK3.mjs';
+export { default as ruleBasedFinder } from './packem_shared/ruleBasedFinder-Cbmc6N7f.mjs';
 export { default as captureRawStackTrace } from './packem_shared/captureRawStackTrace-Tl3Rqkat.mjs';
+export { default as deserializeError } from './packem_shared/deserializeError-DuzHucBb.mjs';
 export { default as getErrorCauses } from './packem_shared/getErrorCauses-CG_JRE6j.mjs';
-export { default as parseStacktrace } from './packem_shared/parseStacktrace-BKGoWCwC.mjs';
-export { VisulimaError, isVisulimaError } from './packem_shared/isVisulimaError-H6TqEA42.mjs';
-export { renderError } from './packem_shared/renderError-BWpM2m6k.mjs';
-export { serialize as serializeError } from './packem_shared/serializeError-DusTUACt.mjs';
+export { default as NonError } from './packem_shared/NonError-BrwMc2LE.mjs';
+export { default as parseStacktrace } from './packem_shared/parseStacktrace-BlguTUcF.mjs';
+export { addKnownErrorConstructor, isErrorLike } from './packem_shared/addKnownErrorConstructor-DBmmT2OF.mjs';
+export { VisulimaError, isVisulimaError } from './packem_shared/isVisulimaError-zyd80Gui.mjs';
+export { renderError } from './packem_shared/renderError-Cn8M0fQ3.mjs';
+export { serialize as serializeError } from './packem_shared/serializeError-DHIelq5o.mjs';
+export { formatStackFrameLine, formatStacktrace } from './packem_shared/formatStackFrameLine-DqkmKWH3.mjs';

package/dist/packem_shared/NonError-BrwMc2LE.mjs

@@ -0,0 +1,13 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class NonError extends Error {
+  static {
+    __name(this, "NonError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "NonError";
+  }
+}
+
+export { NonError as default };

package/dist/packem_shared/NonError-DqwGL5Cy.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class NonError extends Error {
+  static {
+    __name(this, "NonError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "NonError";
+  }
+}
+
+module.exports = NonError;

package/dist/packem_shared/addKnownErrorConstructor-DBmmT2OF.mjs

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const defaultErrorConstructors = /* @__PURE__ */ new Map([
+  ["Error", Error],
+  ["EvalError", EvalError],
+  ["RangeError", RangeError],
+  ["ReferenceError", ReferenceError],
+  ["SyntaxError", SyntaxError],
+  ["TypeError", TypeError],
+  ["URIError", URIError]
+]);
+if (typeof AggregateError !== "undefined") {
+  defaultErrorConstructors.set("AggregateError", AggregateError);
+}
+const addKnownErrorConstructor = /* @__PURE__ */ __name((constructor, name) => {
+  let instance;
+  try {
+    instance = new constructor();
+  } catch (error) {
+    throw new Error(`The error constructor "${constructor.name}" is not compatible`, { cause: error });
+  }
+  const resolvedName = name ?? instance.name;
+  if (defaultErrorConstructors.has(resolvedName)) {
+    throw new Error(`The error constructor "${resolvedName}" is already known.`);
+  }
+  defaultErrorConstructors.set(resolvedName, constructor);
+}, "addKnownErrorConstructor");
+const getKnownErrorConstructors = /* @__PURE__ */ __name(() => new Map(defaultErrorConstructors), "getKnownErrorConstructors");
+const getErrorConstructor = /* @__PURE__ */ __name((name) => defaultErrorConstructors.get(name), "getErrorConstructor");
+const isErrorLike = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && typeof value.name === "string" && typeof value.message === "string" && (getErrorConstructor(value.name) !== void 0 || value.name === "Error"), "isErrorLike");
+
+export { addKnownErrorConstructor, getErrorConstructor, getKnownErrorConstructors, isErrorLike };

package/dist/packem_shared/addKnownErrorConstructor-J1_ZUURa.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const defaultErrorConstructors = /* @__PURE__ */ new Map([
+  ["Error", Error],
+  ["EvalError", EvalError],
+  ["RangeError", RangeError],
+  ["ReferenceError", ReferenceError],
+  ["SyntaxError", SyntaxError],
+  ["TypeError", TypeError],
+  ["URIError", URIError]
+]);
+if (typeof AggregateError !== "undefined") {
+  defaultErrorConstructors.set("AggregateError", AggregateError);
+}
+const addKnownErrorConstructor = /* @__PURE__ */ __name((constructor, name) => {
+  let instance;
+  try {
+    instance = new constructor();
+  } catch (error) {
+    throw new Error(`The error constructor "${constructor.name}" is not compatible`, { cause: error });
+  }
+  const resolvedName = name ?? instance.name;
+  if (defaultErrorConstructors.has(resolvedName)) {
+    throw new Error(`The error constructor "${resolvedName}" is already known.`);
+  }
+  defaultErrorConstructors.set(resolvedName, constructor);
+}, "addKnownErrorConstructor");
+const getKnownErrorConstructors = /* @__PURE__ */ __name(() => new Map(defaultErrorConstructors), "getKnownErrorConstructors");
+const getErrorConstructor = /* @__PURE__ */ __name((name) => defaultErrorConstructors.get(name), "getErrorConstructor");
+const isErrorLike = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && typeof value.name === "string" && typeof value.message === "string" && (getErrorConstructor(value.name) !== void 0 || value.name === "Error"), "isErrorLike");
+
+exports.addKnownErrorConstructor = addKnownErrorConstructor;
+exports.getErrorConstructor = getErrorConstructor;
+exports.getKnownErrorConstructors = getKnownErrorConstructors;
+exports.isErrorLike = isErrorLike;

package/dist/packem_shared/ai-solution-response-BuaDQAEU.d.cts

@@ -0,0 +1,3 @@
+declare const aiSolutionResponse: (rawText: string) => string;
+
+export { aiSolutionResponse as a };

package/dist/packem_shared/ai-solution-response-BuaDQAEU.d.mts

@@ -0,0 +1,3 @@
+declare const aiSolutionResponse: (rawText: string) => string;
+
+export { aiSolutionResponse as a };

package/dist/packem_shared/ai-solution-response-BuaDQAEU.d.ts

@@ -0,0 +1,3 @@
+declare const aiSolutionResponse: (rawText: string) => string;
+
+export { aiSolutionResponse as a };

package/dist/packem_shared/aiFinder-BR9Pq804.cjs

@@ -0,0 +1,259 @@
+'use strict';
+
+const node_crypto = require('node:crypto');
+const node_fs = require('node:fs');
+const node_os = require('node:os');
+const ai = require('ai');
+const solution_ai_aiPrompt = require('../solution/ai/ai-prompt.cjs');
+const aiSolutionResponse = require('./aiSolutionResponse-Cqi0mFxy.cjs');
+
+var __defProp$1 = Object.defineProperty;
+var __name$1 = (target, value) => __defProp$1(target, "name", { value, configurable: true });
+var __defProp$1$1 = Object.defineProperty;
+var __name$1$1 = /* @__PURE__ */ __name$1((target, value) => __defProp$1$1(target, "name", { value, configurable: true }), "__name$1");
+const DRIVE_LETTER_START_RE = /^[A-Z]:\//i;
+const normalizeWindowsPath = /* @__PURE__ */ __name$1$1((input = "") => {
+  if (!input) {
+    return input;
+  }
+  return input.replaceAll("\\", "/").replace(DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}, "normalizeWindowsPath");
+var __defProp2 = Object.defineProperty;
+var __name2 = /* @__PURE__ */ __name$1((target, value) => __defProp2(target, "name", { value, configurable: true }), "__name");
+const UNC_REGEX = /^[/\\]{2}/;
+const IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Z]:[/\\]/i;
+const DRIVE_LETTER_RE = /^[A-Z]:$/i;
+const normalizeString = /* @__PURE__ */ __name2((path2, allowAboveRoot) => {
+  let result = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path2.length; ++index) {
+    if (index < path2.length) {
+      char = path2[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ;
+      else if (dots === 2) {
+        if (result.length < 2 || lastSegmentLength !== 2 || !result.endsWith(".") || result.at(-2) !== ".") {
+          if (result.length > 2) {
+            const lastSlashIndex = result.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              result = "";
+              lastSegmentLength = 0;
+            } else {
+              result = result.slice(0, lastSlashIndex);
+              lastSegmentLength = result.length - 1 - result.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (result.length > 0) {
+            result = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          result += result.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (result.length > 0) {
+          result += `/${path2.slice(lastSlash + 1, index)}`;
+        } else {
+          result = path2.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return result;
+}, "normalizeString");
+const isAbsolute = /* @__PURE__ */ __name2((path2) => IS_ABSOLUTE_RE.test(path2), "isAbsolute");
+const normalize = /* @__PURE__ */ __name2(function(path2) {
+  if (path2.length === 0) {
+    return ".";
+  }
+  path2 = normalizeWindowsPath(path2);
+  const isUNCPath = UNC_REGEX.exec(path2);
+  const isPathAbsolute = isAbsolute(path2);
+  const trailingSeparator = path2.at(-1) === "/";
+  path2 = normalizeString(path2, !isPathAbsolute);
+  if (path2.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path2 += "/";
+  }
+  if (DRIVE_LETTER_RE.test(path2)) {
+    path2 += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path2}`;
+    }
+    return `//${path2}`;
+  }
+  return isPathAbsolute && !isAbsolute(path2) ? `/${path2}` : path2;
+}, "normalize");
+const join = /* @__PURE__ */ __name2((...segments) => {
+  let path2 = "";
+  for (const seg of segments) {
+    if (!seg) {
+      continue;
+    }
+    if (path2.length > 0) {
+      const pathTrailing = path2[path2.length - 1] === "/";
+      const segLeading = seg[0] === "/";
+      const both = pathTrailing && segLeading;
+      if (both) {
+        path2 += seg.slice(1);
+      } else {
+        path2 += pathTrailing || segLeading ? seg : `/${seg}`;
+      }
+    } else {
+      path2 += seg;
+    }
+  }
+  return normalize(path2);
+}, "join");
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const DEFAULT_HEADER = "## Ai Generated Solution";
+const DEFAULT_ERROR_MESSAGE = "Creation of a AI solution failed.";
+const generateCacheKey = /* @__PURE__ */ __name((error, file, temperature) => {
+  const keyData = {
+    error: {
+      message: error.message,
+      name: error.name,
+      stack: error.stack
+    },
+    file: {
+      file: file.file,
+      language: file.language,
+      line: file.line,
+      snippet: file.snippet
+    },
+    temperature
+  };
+  return node_crypto.createHash("sha256").update(JSON.stringify(keyData)).digest("hex");
+}, "generateCacheKey");
+const getCacheDirectory = /* @__PURE__ */ __name((directory) => {
+  if (directory) {
+    return directory;
+  }
+  return join(node_os.tmpdir(), "visulima-error-cache");
+}, "getCacheDirectory");
+const ensureCacheDirectory = /* @__PURE__ */ __name((cacheDirectory) => {
+  if (!node_fs.existsSync(cacheDirectory)) {
+    node_fs.mkdirSync(cacheDirectory, { recursive: true });
+  }
+}, "ensureCacheDirectory");
+const getCacheFilePath = /* @__PURE__ */ __name((cacheDirectory, key) => join(cacheDirectory, `${key}.json`), "getCacheFilePath");
+const readFromCache = /* @__PURE__ */ __name((cacheFilePath, ttl) => {
+  try {
+    if (!node_fs.existsSync(cacheFilePath)) {
+      return void 0;
+    }
+    const cacheContent = node_fs.readFileSync(cacheFilePath, "utf8");
+    const cacheEntry = JSON.parse(cacheContent);
+    const now = Date.now();
+    if (now - cacheEntry.timestamp > ttl) {
+      return void 0;
+    }
+    return cacheEntry.solution;
+  } catch {
+    return void 0;
+  }
+}, "readFromCache");
+const writeToCache = /* @__PURE__ */ __name((cacheFilePath, solution, ttl) => {
+  try {
+    const cacheEntry = {
+      solution,
+      timestamp: Date.now(),
+      ttl
+    };
+    node_fs.writeFileSync(cacheFilePath, JSON.stringify(cacheEntry, null, 2), "utf8");
+  } catch {
+  }
+}, "writeToCache");
+const aiFinder = /* @__PURE__ */ __name((model, options) => {
+  return {
+    handle: /* @__PURE__ */ __name(async (error, file) => {
+      const cacheOptions = options?.cache;
+      const temperature = options?.temperature ?? 0;
+      const ttl = cacheOptions?.ttl ?? 24 * 60 * 60 * 1e3;
+      const cacheDirectory = getCacheDirectory(cacheOptions?.directory);
+      if (cacheOptions?.enabled !== false) {
+        const cacheKey = generateCacheKey(error, file, temperature);
+        const cacheFilePath = getCacheFilePath(cacheDirectory, cacheKey);
+        const cachedSolution = readFromCache(cacheFilePath, ttl);
+        if (cachedSolution) {
+          return cachedSolution;
+        }
+        ensureCacheDirectory(cacheDirectory);
+      }
+      const content = solution_ai_aiPrompt({ applicationType: void 0, error, file });
+      try {
+        const result = await ai.generateText({
+          model,
+          prompt: content,
+          temperature
+        });
+        const messageContent = result.text;
+        let solution;
+        if (messageContent) {
+          solution = {
+            body: aiSolutionResponse(messageContent),
+            header: DEFAULT_HEADER
+          };
+        } else {
+          solution = {
+            body: aiSolutionResponse(DEFAULT_ERROR_MESSAGE),
+            header: DEFAULT_HEADER
+          };
+        }
+        if (cacheOptions?.enabled !== false) {
+          const cacheKey = generateCacheKey(error, file, temperature);
+          const cacheFilePath = getCacheFilePath(cacheDirectory, cacheKey);
+          writeToCache(cacheFilePath, solution, ttl);
+        }
+        return solution;
+      } catch (error_) {
+        console.error(error_);
+        const solution = {
+          body: aiSolutionResponse(DEFAULT_ERROR_MESSAGE),
+          header: DEFAULT_HEADER
+        };
+        if (cacheOptions?.enabled !== false) {
+          const cacheKey = generateCacheKey(error, file, temperature);
+          const cacheFilePath = getCacheFilePath(cacheDirectory, cacheKey);
+          writeToCache(cacheFilePath, solution, ttl);
+        }
+        return solution;
+      }
+    }, "handle"),
+    name: "AI SDK",
+    priority: 99
+  };
+}, "aiFinder");
+
+module.exports = aiFinder;