@intuned/browser-dev 2.2.3-unify-sdks.20

package/dist/browser/ai/extractStructuredData.js

@@ -0,0 +1,231 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractStructuredData = void 0;
+var _extractStructuredDataUsingAi = require("./extractStructuredDataUsingAi");
+var _validators = require("./validators");
+var _screenshotHelpers = require("./extractionHelpers/screenshotHelpers");
+var _formatZodError = require("../../common/formatZodError");
+var _cache = require("../../intunedServices/cache/cache");
+var _locatorHelpers = require("../../common/locatorHelpers");
+var _extractionHelpers = require("../../common/extractionHelpers");
+var _getSimplifiedHtml = require("../../common/getSimplifiedHtml");
+var _hashObject = require("../../common/hashObject");
+var _Logger = require("../../common/Logger");
+var _helpers = require("../../helpers");
+var _xpathMapping = require("../../common/xpathMapping");
+const extractStructuredData = async options => {
+  const pageOrLocator = options.source;
+  const isPageInput = (0, _locatorHelpers.isPage)(pageOrLocator);
+  const {
+    model,
+    strategy,
+    prompt,
+    apiKey,
+    enableDomMatching = false,
+    maxRetries = 3,
+    dataSchema,
+    enableCache = true
+  } = options;
+  const inputParsingResult = await _validators.extractDataInputJsonSchema.safeParseAsync({
+    source: pageOrLocator,
+    model,
+    strategy,
+    prompt,
+    apiKey,
+    enableDomMatching,
+    enableCache,
+    maxRetries,
+    dataSchema
+  });
+  if (!inputParsingResult.success) {
+    const errors = (0, _formatZodError.formatZodError)(inputParsingResult.error);
+    const message = `invalid input parameters for extractStructuredData: ${errors}`;
+    throw new Error(message);
+  }
+  const validatedData = inputParsingResult.data;
+  const pageObject = isPageInput ? pageOrLocator : pageOrLocator.page();
+  if (validatedData.enableDomMatching) {
+    if (!(0, _validators.checkAllTypesAreStrings)(validatedData.dataSchema)) {
+      throw new Error("For DOM matching, all types of the extraction fields must be STRINGS, to match with the DOM.");
+    }
+  }
+  let cacheKey = "";
+  if (validatedData.strategy === "HTML") {
+    const containerHandle = isPageInput ? await pageOrLocator.locator("html").elementHandle() : await pageOrLocator.elementHandle();
+    if (!containerHandle) {
+      throw new Error("No HTML content found in the specified region.");
+    }
+    const simplifiedHtml = await (0, _getSimplifiedHtml.getSimplifiedHtml)(containerHandle);
+    if (validatedData.enableCache) {
+      cacheKey = (0, _hashObject.hashObject)({
+        pageUrl: pageObject.url(),
+        dataSchema: validatedData.dataSchema,
+        strategy: validatedData.strategy,
+        model: validatedData.model,
+        prompt: validatedData.prompt,
+        searchRegion: !isPageInput ? pageOrLocator.toString() : undefined,
+        ...(validatedData.enableDomMatching ? {} : {
+          html: (0, _extractionHelpers.compressStringSpaces)(simplifiedHtml)
+        })
+      }, true);
+      const cachedResult = await _cache.cache.get(cacheKey);
+      if (validatedData.enableDomMatching && cachedResult && cachedResult.matchesMapping) {
+        const isValid = await (0, _xpathMapping.validateXPathMapping)(pageObject, cachedResult.matchesMapping);
+        if (isValid) {
+          _Logger.logger.info(`Cached results matched correctly with the current page, returning cached result`);
+          return cachedResult.result;
+        }
+      } else if (cachedResult && !validatedData.enableDomMatching) {
+        _Logger.logger.info(`Results for the extractor found in the cache, returning cached result`);
+        return cachedResult;
+      }
+    }
+    const result = await (0, _extractStructuredDataUsingAi.extractStructuredDataUsingAi)(pageObject, {
+      apiKey: validatedData.apiKey,
+      enableDomMatching: validatedData.enableDomMatching,
+      jsonSchema: validatedData.dataSchema,
+      model: validatedData.model,
+      content: simplifiedHtml,
+      prompt: validatedData.prompt,
+      images: [],
+      maxRetries: validatedData.maxRetries
+    });
+    if (result.isErr()) {
+      throw new Error(result.error.context);
+    }
+    if (validatedData.enableCache) {
+      if (!validatedData.enableDomMatching) {
+        await _cache.cache.set(cacheKey, result.value.result);
+      } else {
+        const resultsToCache = {
+          result: result.value.result,
+          matchesMapping: result.value.xpathMapping || {}
+        };
+        await _cache.cache.set(cacheKey, resultsToCache);
+      }
+    }
+    return result.value.result;
+  }
+  if (validatedData.strategy === "IMAGE") {
+    const containerHandle = isPageInput ? undefined : await pageOrLocator.elementHandle();
+    const images = await (0, _screenshotHelpers.buildImagesFromPageOrHandle)(pageObject, containerHandle);
+    if (validatedData.enableCache) {
+      cacheKey = (0, _hashObject.hashObject)({
+        pageUrl: pageObject.url(),
+        dataSchema: validatedData.dataSchema,
+        strategy: validatedData.strategy,
+        model: validatedData.model,
+        prompt: validatedData.prompt,
+        searchRegion: !isPageInput ? pageOrLocator.toString() : undefined,
+        ...(validatedData.enableDomMatching ? {} : {
+          html: await pageObject.evaluate(() => document.documentElement.outerHTML)
+        })
+      }, true);
+      const cachedResult = await _cache.cache.get(cacheKey);
+      if (validatedData.enableDomMatching && cachedResult && cachedResult.matchesMapping) {
+        const isValid = await (0, _xpathMapping.validateXPathMapping)(pageObject, cachedResult.matchesMapping);
+        if (isValid) {
+          _Logger.logger.info("Cached results matched correctly with the data in the current page.\nReturning cached result");
+          return cachedResult.result;
+        }
+      } else if (cachedResult && !validatedData.enableDomMatching) {
+        _Logger.logger.info("Results for the extractor found in the cache.\nReturning cached result");
+        return cachedResult;
+      }
+    }
+    if (images.isErr()) {
+      throw new Error(images.error.context);
+    }
+    const result = await (0, _extractStructuredDataUsingAi.extractStructuredDataUsingAi)(pageObject, {
+      apiKey: validatedData.apiKey,
+      enableDomMatching: validatedData.enableDomMatching,
+      jsonSchema: validatedData.dataSchema,
+      model: validatedData.model,
+      content: "Extract structured data from the following images.",
+      prompt: validatedData.prompt,
+      images: images.value,
+      maxRetries: validatedData.maxRetries
+    });
+    if (result.isErr()) {
+      throw new Error(result.error.context);
+    }
+    if (validatedData.enableCache) {
+      if (!validatedData.enableDomMatching) {
+        await _cache.cache.set(cacheKey, result.value.result);
+      } else {
+        const resultsToCache = {
+          result: result.value.result,
+          matchesMapping: result.value.xpathMapping || {}
+        };
+        await _cache.cache.set(cacheKey, resultsToCache);
+      }
+    }
+    return result.value.result;
+  }
+  if (validatedData.strategy === "MARKDOWN") {
+    const containerHandle = isPageInput ? await pageOrLocator.locator("html").elementHandle() : await pageOrLocator.elementHandle();
+    const html = await (containerHandle === null || containerHandle === void 0 ? void 0 : containerHandle.innerHTML());
+    if (!html) {
+      throw new Error("No HTML content found in the specified region.");
+    }
+    const markdown = await (0, _helpers.extractMarkdown)({
+      source: pageObject
+    });
+    if (validatedData.enableCache) {
+      cacheKey = (0, _hashObject.hashObject)({
+        pageUrl: pageObject.url(),
+        dataSchema: validatedData.dataSchema,
+        strategy: validatedData.strategy,
+        model: validatedData.model,
+        prompt: validatedData.prompt,
+        searchRegion: !isPageInput ? pageOrLocator.toString() : undefined,
+        ...(validatedData.enableDomMatching ? {} : {
+          html: await pageObject.evaluate(() => document.documentElement.outerHTML),
+          markdown
+        })
+      }, true);
+      const cachedResult = await _cache.cache.get(cacheKey);
+      if (enableDomMatching && cachedResult && cachedResult.matchesMapping) {
+        const cachedXpathMapping = cachedResult.matchesMapping;
+        const isValid = await (0, _xpathMapping.validateXPathMapping)(pageObject, cachedXpathMapping);
+        if (isValid) {
+          console.log(`Cached results matched correctly with the data in the current page.\nReturning cached result`);
+          return cachedResult.result;
+        }
+      } else if (cachedResult && !enableDomMatching) {
+        _Logger.logger.info(`Results for the extractor found in the cache.\nReturning cached result`);
+        return cachedResult;
+      }
+    }
+    const result = await (0, _extractStructuredDataUsingAi.extractStructuredDataUsingAi)(pageObject, {
+      apiKey: validatedData.apiKey,
+      enableDomMatching: validatedData.enableDomMatching,
+      jsonSchema: validatedData.dataSchema,
+      model: validatedData.model,
+      content: markdown,
+      prompt: validatedData.prompt,
+      images: [],
+      maxRetries: validatedData.maxRetries
+    });
+    if (result.isErr()) {
+      throw new Error(result.error.context);
+    }
+    if (validatedData.enableCache) {
+      if (!enableDomMatching) {
+        await _cache.cache.set(cacheKey, result.value.result);
+        return result.value.result;
+      }
+      const resultsToCache = {
+        result: result.value.result,
+        matchesMapping: result.value.xpathMapping || {}
+      };
+      await _cache.cache.set(cacheKey, resultsToCache);
+    }
+    return result.value.result;
+  }
+  throw new Error(`Unsupported strategy type: ${validatedData.strategy}. Supported types are: HTML, IMAGE, and MARKDOWN.`);
+};
+exports.extractStructuredData = extractStructuredData;

package/dist/browser/ai/extractStructuredDataUsingAi.js

@@ -0,0 +1,140 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractStructuredDataUsingAi = extractStructuredDataUsingAi;
+var _neverthrow = require("neverthrow");
+var Errors = _interopRequireWildcard(require("./types/errors"));
+var _getAiTrackingHeaders = require("../../common/eventTracking/getAiTrackingHeaders");
+var _environmentVariables = require("../../common/environmentVariables");
+var _Logger = require("../../common/Logger");
+var _collectStrings = require("../../common/matching/collectStrings");
+var _matching = require("../../common/matching/matching");
+var _validateSchema = require("./extractionHelpers/validateSchema");
+var _factory = require("../../intunedServices/ApiGateway/factory");
+var _tools = require("./tools");
+var _prompt = require("./prompt");
+var _ai = require("ai");
+var _loadRuntime = require("../../common/loadRuntime");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+async function extractStructuredDataUsingAi(page, input) {
+  var _getExecutionContext, _getExecutionContext2, _getExecutionContext3;
+  const {
+    apiKey,
+    enableDomMatching,
+    jsonSchema,
+    model,
+    content,
+    prompt,
+    images,
+    maxRetries = 3
+  } = input;
+  let accumulatedCost = 0;
+  const getExecutionContext = await (0, _loadRuntime.loadRuntime)();
+  const toolName = `extract_data`;
+  const headers = (0, _getAiTrackingHeaders.getAiTrackingHeaders)({
+    environment: (0, _environmentVariables.getEnvironmentVariable)("RUN_ENVIRONMENT"),
+    type: "DYNAMIC_LIST",
+    runId: ((_getExecutionContext = getExecutionContext()) === null || _getExecutionContext === void 0 ? void 0 : _getExecutionContext.runId) || undefined,
+    jobId: ((_getExecutionContext2 = getExecutionContext()) === null || _getExecutionContext2 === void 0 ? void 0 : _getExecutionContext2.jobId) || undefined,
+    jobRunId: ((_getExecutionContext3 = getExecutionContext()) === null || _getExecutionContext3 === void 0 ? void 0 : _getExecutionContext3.jobRunId) || undefined
+  });
+  const gateway = _factory.GatewayFactory.createAIGateway();
+  const gatewayModel = gateway.getModel(model, apiKey);
+  const tools = (0, _tools.getTools)(toolName, jsonSchema);
+  const messages = (0, _prompt.getMessages)({
+    prompt,
+    content,
+    images,
+    enableDomMatching
+  });
+  const messagesHistory = messages;
+  let currentRetry = 0;
+  let result;
+  while (currentRetry < maxRetries) {
+    try {
+      var _result$usage;
+      result = await (0, _ai.generateText)({
+        model: gatewayModel,
+        messages: messagesHistory,
+        tools: tools.isOk() ? tools.value : {},
+        toolChoice: "required",
+        maxRetries,
+        headers
+      });
+      accumulatedCost += ((_result$usage = result.usage) === null || _result$usage === void 0 ? void 0 : _result$usage.totalTokens) ?? 0;
+      _Logger.logger.info(`AI extraction cost:  ${accumulatedCost}`);
+      const toolCall = result.toolCalls[0] ?? null;
+      let extractedData = toolCall.input;
+      const isArray = jsonSchema.type === "array";
+      if (isArray && extractedData.extracted_data) {
+        extractedData = extractedData.extracted_data;
+      }
+      const errors = (0, _validateSchema.validateToolCallSchema)(extractedData, jsonSchema);
+      if (errors.length > 0) {
+        const reaskMessage = (0, _validateSchema.createReaskMessage)(errors);
+        const modelMessages = (0, _ai.convertToModelMessages)([{
+          role: "assistant",
+          parts: [{
+            type: "step-start"
+          }, {
+            type: "text",
+            text: result.text,
+            state: "done"
+          }, {
+            type: `tool-${toolName}`,
+            state: "output-error",
+            toolCallId: toolCall.toolCallId,
+            input: extractedData,
+            errorText: reaskMessage
+          }]
+        }]);
+        messagesHistory.push(...modelMessages);
+        currentRetry++;
+        continue;
+      }
+      if (!enableDomMatching) {
+        return (0, _neverthrow.ok)({
+          result: extractedData,
+          usage: accumulatedCost,
+          xpathMapping: {}
+        });
+      }
+      const stringsToMatch = (0, _collectStrings.collectStrings)({
+        dataStructure: extractedData
+      });
+      if (!stringsToMatch || stringsToMatch.length === 0) {
+        return (0, _neverthrow.ok)({
+          result: [],
+          usage: accumulatedCost,
+          xpathMapping: {}
+        });
+      }
+      const {
+        replacements,
+        xpathMapping
+      } = await (0, _matching.replaceWithBestMatches)({
+        stringsToMatch,
+        pageObject: page
+      });
+      const stringReplacements = {};
+      Object.entries(replacements).forEach(([key, value]) => {
+        stringReplacements[key] = (value === null || value === void 0 ? void 0 : value.matchText) || null;
+      });
+      const matchesData = await (0, _validateSchema.recursivelyReplaceStrings)(extractedData, stringReplacements);
+      return (0, _neverthrow.ok)({
+        result: matchesData,
+        usage: accumulatedCost,
+        xpathMapping
+      });
+    } catch (error) {
+      _Logger.logger.error("Error during AI extraction", {
+        error,
+        model
+      });
+      return (0, _neverthrow.err)(Errors.invalidExtractionResult(error instanceof Error ? error.message : "Unknown error during extraction"));
+    }
+  }
+  return (0, _neverthrow.err)(Errors.maxRetriesExceeded(`Max retries of ${maxRetries} exceeded for extraction`));
+}

package/dist/browser/ai/extractionHelpers/screenshotHelpers.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildImagesFromPageOrHandle = buildImagesFromPageOrHandle;
+exports.captureFullPageImagesWithOverlap = captureFullPageImagesWithOverlap;
+var _neverthrow = require("neverthrow");
+var errors = _interopRequireWildcard(require("../types/errors"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+async function captureFullPageImagesWithOverlap(page, options = {
+  overlap: 200,
+  sliceHeight: 1000
+}) {
+  const totalHeight = await page.evaluate(() => document.body.scrollHeight);
+  let currentHeight = 0;
+  const buffers = [];
+  while (currentHeight < totalHeight) {
+    if (buffers.length > 10) {
+      console.info(`the page is too long, only first ${totalHeight} px of the page will be captured.`);
+      break;
+    }
+    await page.setViewportSize({
+      width: 1200,
+      height: options.sliceHeight
+    });
+    await page.evaluate(y => window.scrollTo(0, y), currentHeight - (currentHeight > 0 ? options.overlap : 0));
+    await page.waitForTimeout(500);
+    const buffer = await page.screenshot();
+    buffers.push(buffer);
+    currentHeight += options.sliceHeight - options.overlap;
+  }
+  return buffers;
+}
+async function buildImagesFromPageOrHandle(page, searchRegionHandler) {
+  const originalViewPortSize = page.viewportSize();
+  await page.setViewportSize({
+    width: 1200,
+    height: 800
+  });
+  if (searchRegionHandler) {
+    const size = await searchRegionHandler.boundingBox();
+    if (!size) {
+      return (0, _neverthrow.err)(errors.other("the provided search region is very large, image extraction support up to 5000px height."));
+    }
+    return (0, _neverthrow.ok)([await searchRegionHandler.screenshot({
+      type: "png"
+    })]);
+  }
+  const fullPageImages = await captureFullPageImagesWithOverlap(page);
+  if (originalViewPortSize) {
+    await page.setViewportSize(originalViewPortSize);
+  }
+  return (0, _neverthrow.ok)(fullPageImages);
+}

package/dist/browser/ai/extractionHelpers/validateSchema.js

@@ -0,0 +1,148 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createReaskMessage = createReaskMessage;
+exports.recursivelyReplaceStrings = recursivelyReplaceStrings;
+exports.validateJSONSchema = validateJSONSchema;
+exports.validateToolCallSchema = validateToolCallSchema;
+var _neverthrow = require("neverthrow");
+var errors = _interopRequireWildcard(require("../types/errors"));
+var _ajv = _interopRequireDefault(require("ajv"));
+var _ajvFormats = _interopRequireDefault(require("ajv-formats"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function validateJSONSchema(schema) {
+  if (!schema || typeof schema !== "object") {
+    return (0, _neverthrow.err)(errors.invalidJsonSchema("Schema must be an object"));
+  }
+  if (!schema.type) {
+    return (0, _neverthrow.err)(errors.invalidJsonSchema("Schema must have a 'type' property"));
+  }
+  const validTypes = ["string", "number", "integer", "boolean", "array", "object"];
+  if (!validTypes.includes(schema.type)) {
+    return (0, _neverthrow.err)(errors.invalidJsonSchema(`Invalid schema type: ${schema.type}`));
+  }
+  if (schema.type === "array") {
+    if (!schema.items) {
+      return (0, _neverthrow.err)(errors.invalidJsonSchema("Array schema must have 'items' property"));
+    }
+    const itemsValidation = validateJSONSchema(schema.items);
+    if (itemsValidation.isErr()) {
+      return itemsValidation;
+    }
+  }
+  if (schema.type === "object") {
+    if (!schema.properties || typeof schema.properties !== "object") {
+      return (0, _neverthrow.err)(errors.invalidJsonSchema("Object schema must have 'properties' object"));
+    }
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      const propValidation = validateJSONSchema(propSchema);
+      if (propValidation.isErr()) {
+        return (0, _neverthrow.err)(errors.invalidJsonSchema(`Invalid schema for property '${key}': ${propValidation.error.context}`));
+      }
+    }
+    if (schema.required && !Array.isArray(schema.required)) {
+      return (0, _neverthrow.err)(errors.invalidJsonSchema("'required' must be an array of property names"));
+    }
+  }
+  if (schema.type === "number" || schema.type === "integer") {
+    if (schema.maximum !== undefined && schema.exclusiveMaximum !== undefined) {
+      return (0, _neverthrow.err)(errors.invalidJsonSchema("Cannot have both 'maximum' and 'exclusiveMaximum'"));
+    }
+    if (schema.minimum !== undefined && schema.exclusiveMinimum !== undefined) {
+      return (0, _neverthrow.err)(errors.invalidJsonSchema("Cannot have both 'minimum' and 'exclusiveMinimum'"));
+    }
+    if (schema.minimum > schema.maximum) {
+      return (0, _neverthrow.err)(errors.invalidJsonSchema("'minimum' cannot be greater than 'maximum'"));
+    }
+  }
+  if (schema.type === "string") {
+    if (schema.maxLength !== undefined && schema.minLength !== undefined) {
+      if (schema.minLength > schema.maxLength) {
+        return (0, _neverthrow.err)(errors.invalidJsonSchema("'minLength' cannot be greater than 'maxLength'"));
+      }
+    }
+  }
+  return (0, _neverthrow.ok)(schema);
+}
+function recursivelyReplaceStrings(dataStructure, replacements) {
+  if (typeof dataStructure === "string") {
+    return replacements[dataStructure] ?? dataStructure;
+  } else if (typeof dataStructure === "number") {
+    const replacement = replacements[dataStructure.toString()];
+    return replacement !== null && replacement !== undefined ? replacement : dataStructure;
+  } else if (Array.isArray(dataStructure)) {
+    return dataStructure.map(item => recursivelyReplaceStrings(item, replacements));
+  } else if (dataStructure !== null && typeof dataStructure === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(dataStructure)) {
+      result[key] = recursivelyReplaceStrings(value, replacements);
+    }
+    return result;
+  } else {
+    return dataStructure;
+  }
+}
+function validateToolCallSchema(instance, schema) {
+  const ajv = new _ajv.default({
+    allErrors: true,
+    verbose: true
+  });
+  (0, _ajvFormats.default)(ajv);
+  const validate = ajv.compile(schema);
+  const isValid = validate(instance);
+  if (isValid) {
+    return [];
+  }
+  const errors = [];
+  if (validate.errors) {
+    for (const error of validate.errors) {
+      let pathString = "root";
+      if (error.instancePath) {
+        const pathParts = error.instancePath.slice(1).split("/").map(part => {
+          if (/^\d+$/.test(part)) {
+            return `[${part}]`;
+          }
+          return part;
+        });
+        if (pathParts.length > 0) {
+          pathString = "root." + pathParts.join(".");
+          pathString = pathString.replace(/\.\[/g, "[");
+        }
+      }
+      let schemaPathString = "schema";
+      if (error.schemaPath) {
+        const schemaParts = error.schemaPath.slice(1).split("/");
+        if (schemaParts.length > 0) {
+          schemaPathString = "schema." + schemaParts.join(".");
+        }
+      }
+      let invalidValue = instance;
+      if (error.instancePath) {
+        const pathParts = error.instancePath.slice(1).split("/");
+        for (const part of pathParts) {
+          if (!invalidValue) {
+            invalidValue = invalidValue[part];
+          }
+        }
+      }
+      errors.push({
+        path: pathString,
+        message: error.message || "Validation error",
+        value: invalidValue,
+        schema_path: schemaPathString
+      });
+    }
+  }
+  return errors;
+}
+function createReaskMessage(validationErrors) {
+  const formattedErrors = validationErrors.map((error, index) => `${index + 1}. Path "${error.path}": ${error.message}`).join("\n");
+  return `The extracted data has the following validation errors that need to be fixed:
+
+${formattedErrors}
+
+Please extract the data again, ensuring it follows the exact schema requirements.`;
+}