@intuned/browser-dev 2.2.3-test-build.0

package/dist/optimized-extractors/objectExtractionHelpers/dynamicObjectExtractor.js

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dynamicObjectExtractor = dynamicObjectExtractor;
+var _neverthrow = require("neverthrow");
+var Errors = _interopRequireWildcard(require("./errors"));
+var _AIExtractors = require("./AIExtractors");
+var _captureSnapshot = require("./captureSnapshot");
+var _validateDynamicObjectExtractorOptions = require("./validateDynamicObjectExtractorOptions");
+var _calculateObjectExampleHash = require("./calculateObjectExampleHash");
+var _Logger = require("../../common/Logger");
+var _cache = require("../../intunedServices/cache");
+var _xpathMapping = require("../../common/xpathMapping");
+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 dynamicObjectExtractor(page, identifier, options) {
+  const validation = await (0, _validateDynamicObjectExtractorOptions.validateDynamicObjectExtractorOptions)(page, identifier, options);
+  if (validation.isErr()) {
+    return (0, _neverthrow.err)(validation.error);
+  }
+  const {
+    entityName,
+    entitySchema,
+    entityDescription,
+    searchRegion,
+    searchRegionHandler,
+    variantKey,
+    currentPageUrl,
+    searchRegionKey,
+    strategy,
+    hasSearchRegionContainer,
+    prompt,
+    apiKey
+  } = validation.value;
+  const extractionExampleHash = (0, _calculateObjectExampleHash.calculateObjectExampleHash)({
+    currentPageUrl,
+    entityName,
+    entityDescription,
+    entitySchema,
+    variantKey,
+    strategy,
+    searchRegionLocator: searchRegionKey,
+    prompt
+  });
+  const cachedResult = await _cache.cache.get(extractionExampleHash);
+  if (cachedResult) {
+    _Logger.logger.info("Found value in cache");
+    const isValid = await (0, _xpathMapping.validateXPathMapping)(page, cachedResult.matchesMapping);
+    if (isValid) {
+      _Logger.logger.info("The values in the cache are the same as the current page, returning the cached result");
+      return (0, _neverthrow.ok)(cachedResult.result);
+    }
+    _Logger.logger.info("The values in the cache are different from the current page, running AI extraction");
+  }
+  _Logger.logger.info("No value found in the cache, running AI extraction");
+  const pageAndSearchRegion = {
+    page,
+    searchRegion,
+    searchRegionHandler: searchRegionHandler
+  };
+  const snapshot = await (0, _captureSnapshot.captureSnapshot)(pageAndSearchRegion);
+  if (snapshot.isErr()) {
+    return (0, _neverthrow.err)(snapshot.error);
+  }
+  const extractionResultWithMatches = await (0, _AIExtractors.runAIExtraction)(pageAndSearchRegion, {
+    entityName,
+    entityDescription,
+    entitySchema,
+    identifier
+  }, snapshot.value, strategy, hasSearchRegionContainer, prompt, apiKey);
+  if (extractionResultWithMatches.isErr()) {
+    return (0, _neverthrow.err)(extractionResultWithMatches.error);
+  }
+  const requiredProperties = entitySchema.required;
+  const requiredPropsNotExtracted = requiredProperties.filter(propertyName => !extractionResultWithMatches.value.extractionResultObject[propertyName]);
+  const shouldReturnNull = requiredPropsNotExtracted.length === requiredProperties.length;
+  if (!shouldReturnNull && requiredPropsNotExtracted.length > 0) {
+    return (0, _neverthrow.err)(Errors.requiredPropertyNotExtracted(`${requiredPropsNotExtracted.toString()} not found.`));
+  }
+  if (shouldReturnNull) {
+    _Logger.logger.warn("All required properties not found, returning null as extraction result");
+    return (0, _neverthrow.ok)(null);
+  }
+  const resultToReturn = extractionResultWithMatches.value.extractionResultObject;
+  const xpathMappingFromAI = extractionResultWithMatches.value.xpathMapping;
+  const xpathMapping = {};
+  Object.entries(xpathMappingFromAI).forEach(([_propertyName, {
+    matchXpath,
+    matchText,
+    matchType
+  }]) => {
+    xpathMapping[matchText] = [{
+      xpath: matchXpath,
+      matchType
+    }];
+  });
+  const resultsToCache = {
+    result: resultToReturn,
+    matchesMapping: xpathMapping
+  };
+  _Logger.logger.debug("Caching results...");
+  await _cache.cache.set(extractionExampleHash, resultsToCache);
+  _Logger.logger.debug("Results cached");
+  return (0, _neverthrow.ok)(resultToReturn);
+}

package/dist/optimized-extractors/objectExtractionHelpers/errors.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.requiredPropertyNotExtracted = exports.other = exports.invalidSearchRegion = exports.invalidPageState = exports.invalidInput = exports.invalidExtractionResult = exports.insufficientAiCredits = void 0;
+const invalidPageState = context => ({
+  type: "InvalidPageState",
+  context
+});
+exports.invalidPageState = invalidPageState;
+const other = (context, error) => ({
+  type: "Other",
+  context,
+  error
+});
+exports.other = other;
+const invalidSearchRegion = context => ({
+  type: "InvalidSearchRegion",
+  context
+});
+exports.invalidSearchRegion = invalidSearchRegion;
+const invalidInput = context => ({
+  type: "InvalidInput",
+  context
+});
+exports.invalidInput = invalidInput;
+const invalidExtractionResult = context => ({
+  type: "InvalidExtractionResult",
+  context
+});
+exports.invalidExtractionResult = invalidExtractionResult;
+const requiredPropertyNotExtracted = context => ({
+  type: "RequiredPropertyNotExtracted",
+  context
+});
+exports.requiredPropertyNotExtracted = requiredPropertyNotExtracted;
+const insufficientAiCredits = context => ({
+  type: "InsufficientAiCredits",
+  context
+});
+exports.insufficientAiCredits = insufficientAiCredits;

package/dist/optimized-extractors/objectExtractionHelpers/findDomMatches.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDomMatches = getDomMatches;
+exports.getDomMatchesFromItemsHandles = getDomMatchesFromItemsHandles;
+var _types = require("../common/matching/types");
+var _ensureBrowserScripts = require("../../common/ensureBrowserScripts");
+async function getDomMatches(page, container, searchTexts) {
+  await (0, _ensureBrowserScripts.ensureBrowserScripts)(page);
+  const result = await page.evaluate(async ({
+    container,
+    searchTexts
+  }) => {
+    const result = await window.__INTUNED__.matchStringsWithDomContent(container, searchTexts);
+    return result;
+  }, {
+    container,
+    searchTexts
+  });
+  return new Map(Object.entries(result).map(([searchText, matchResults]) => {
+    const mappedMatches = matchResults.map(matchResult => {
+      const matchedXpath = matchResult.xpath + (matchResult.match_source === _types.MatchSource.DIRECT_TEXT_NODE ? "" : matchResult.match_source === _types.MatchSource.ATTRIBUTE ? `[@${matchResult.attribute}]` : "");
+      return {
+        sourceText: matchResult.matched_source_value,
+        matchText: matchResult.matched_value,
+        nodeXpath: matchResult.xpath,
+        matchXpath: matchedXpath,
+        exact: matchResult.match_mode === _types.MatchMode.FULL,
+        matchType: matchResult.match_source === _types.MatchSource.TEXT_CONTENT ? "all-text" : matchResult.match_source === _types.MatchSource.DIRECT_TEXT_NODE ? "direct-text" : {
+          attribute: matchResult.attribute
+        },
+        isFuzzy: matchResult.match_mode === _types.MatchMode.FUZZY,
+        fuzzyDistance: matchResult.fuzzy_distance ?? undefined
+      };
+    });
+    return [searchText, mappedMatches];
+  }));
+}
+async function getDomMatchesFromItemsHandles(page, handle, searchTexts) {
+  const matchesArrays = [];
+  const matches = await getDomMatches(page, handle, searchTexts);
+  matchesArrays.push(matches);
+  const mergedMatches = new Map();
+  for (const matches of matchesArrays) {
+    for (const [searchText, matchesArray] of matches) {
+      const existingMatches = mergedMatches.get(searchText) || [];
+      existingMatches.push(...matchesArray);
+      mergedMatches.set(searchText, existingMatches);
+    }
+  }
+  return mergedMatches;
+}

package/dist/optimized-extractors/objectExtractionHelpers/getSimplifiedHtml.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSimplifiedHtml = getSimplifiedHtml;
+var _constants = require("./constants");
+async function getSimplifiedHtml(containerHandle, options) {
+  const tagName = await containerHandle.evaluateHandle(element => element.tagName.toLowerCase());
+  const shouldReturnFullHtml = (await tagName.jsonValue()) === "html";
+  const optionsWithDefault = {
+    shouldIncludeOnClick: false,
+    shouldIncludeContentAsProp: false,
+    keepOnlyVisibleElements: true,
+    shouldReturnFullHtml,
+    ...options
+  };
+  const simplifiedHtml = await containerHandle.evaluate((element, {
+    optionsWithDefault,
+    ALLOWED_ATTRIBUTES
+  }) => {
+    function truthyFilter(value) {
+      return Boolean(value);
+    }
+    function isElementNode(node) {
+      return node.nodeType === node.ELEMENT_NODE;
+    }
+    const hasAnyAllowedAttribute = (element, allowedAttributes) => {
+      const elementAttributes = element.getAttributeNames();
+      const hasAllowedAttribute = !!allowedAttributes.some(attr => {
+        if (typeof attr === "string") {
+          return element.hasAttribute(attr);
+        } else if (attr instanceof RegExp) {
+          return elementAttributes.some(attrName => attr.test(attrName));
+        }
+      });
+      return hasAllowedAttribute;
+    };
+    function isElementVisible(style) {
+      return style.opacity !== "" && style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0";
+    }
+    function isElementInteractive(element, style) {
+      return element.tagName === "A" || element.tagName === "INPUT" || element.tagName === "BUTTON" || element.tagName === "SELECT" || element.tagName === "TEXTAREA" || element.hasAttribute("onclick") || element.hasAttribute("onmousedown") || element.hasAttribute("onmouseup") || element.hasAttribute("onkeydown") || element.hasAttribute("onkeyup") || style.cursor === "pointer";
+    }
+    function getDocumentFromIframeElementSafely(element) {
+      try {
+        if (element.contentWindow && element.contentWindow.document) {
+          return element.contentWindow.document.documentElement;
+        }
+      } catch (error) {
+        return undefined;
+      }
+    }
+    function isInputWithValue(element) {
+      return element.tagName === "INPUT" && element.value && element.value.trim();
+    }
+    function generateSimplifiedDom(element, interactiveElements, document, allowedAttributes, shouldIncludeContentAsProp, keepOnlyVisibleElements) {
+      var _element$textContent;
+      if (element.nodeType === 3 && (_element$textContent = element.textContent) !== null && _element$textContent !== void 0 && _element$textContent.trim()) {
+        return document.createTextNode(element.textContent + " ");
+      }
+      const shouldSkipElementChecks = optionsWithDefault.shouldIncludeIframes ? ["BODY", "HTML", "IFRAME"] : ["BODY", "HTML"].includes(element.nodeName);
+      if (!isElementNode(element)) {
+        return null;
+      }
+      const style = window.getComputedStyle(element);
+      const isVisible = isElementVisible(style) || shouldSkipElementChecks;
+      if (keepOnlyVisibleElements && !isVisible && !isInputWithValue(element)) {
+        return null;
+      }
+      let children = optionsWithDefault.shouldIncludeIframes && element.nodeName === "IFRAME" ? [getDocumentFromIframeElementSafely(element)].filter(Boolean) : Array.from(element.childNodes).map(c => generateSimplifiedDom(c, interactiveElements, document, allowedAttributes, shouldIncludeContentAsProp, keepOnlyVisibleElements)).filter(truthyFilter);
+      if (element.tagName === "BODY") children = children.filter(c => c.nodeType !== 3);
+      const interactive = isElementInteractive(element, style) || element.hasAttribute("role");
+      const hasLabel = element.hasAttribute("aria-label") || element.hasAttribute("name");
+      const hasAllowedAttribute = hasAnyAllowedAttribute(element, allowedAttributes);
+      let includeNode = interactive || hasLabel || hasAllowedAttribute || shouldSkipElementChecks;
+      if (children.length === 0 && !hasAnyAllowedAttribute(element, allowedAttributes)) {
+        return null;
+      }
+      if (children.length === 1 && !hasAnyAllowedAttribute(element, allowedAttributes) && children[0].nodeType !== 3 && !(shouldSkipElementChecks && optionsWithDefault.shouldReturnFullHtml)) {
+        return children[0];
+      }
+      if (!includeNode && children.length === 0) return null;
+      if (!includeNode && children.some(c => c.nodeType === 3)) {
+        includeNode = true;
+      }
+      if (!includeNode && children.length === 1) {
+        return children[0];
+      }
+      const container = element.cloneNode();
+      const allAttributes = element.getAttributeNames();
+      const listOfAttributesToRemove = allAttributes.filter(attr => {
+        const isAllowedString = allowedAttributes.includes(attr);
+        const isAllowedRegExp = allowedAttributes.some(regex => regex instanceof RegExp && regex.test(attr));
+        return !isAllowedString && !isAllowedRegExp;
+      });
+      for (const attr of listOfAttributesToRemove) {
+        container.removeAttribute(attr);
+      }
+      if (interactive) {
+        interactiveElements.push(element);
+      }
+      if (shouldIncludeContentAsProp && element.textContent) {
+        container.setAttribute("content", element.textContent);
+      }
+      children.forEach(child => container.appendChild(child));
+      return container;
+    }
+    function getSimplifiedDomFromElement(htmlElement, shouldIncludeOnClick, shouldIncludeContentAsProp, keepOnlyVisibleElements) {
+      const interactiveElements = [];
+      const allowedAttributes = shouldIncludeOnClick ? [...ALLOWED_ATTRIBUTES, "onclick"] : ALLOWED_ATTRIBUTES;
+      const simplifiedDom = generateSimplifiedDom(htmlElement, interactiveElements, htmlElement.ownerDocument, allowedAttributes, shouldIncludeContentAsProp, keepOnlyVisibleElements);
+      if (!simplifiedDom) return "";
+      return simplifiedDom.outerHTML;
+    }
+    return getSimplifiedDomFromElement(element, optionsWithDefault.shouldIncludeOnClick, optionsWithDefault.shouldIncludeContentAsProp, optionsWithDefault.keepOnlyVisibleElements);
+  }, {
+    optionsWithDefault,
+    ALLOWED_ATTRIBUTES: _constants.ALLOWED_ATTRIBUTES
+  });
+  return simplifiedHtml;
+}

package/dist/optimized-extractors/objectExtractionHelpers/typesAndSchemas.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/optimized-extractors/objectExtractionHelpers/validateDynamicObjectExtractorOptions.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateDynamicObjectExtractorOptions = validateDynamicObjectExtractorOptions;
+var _neverthrow = require("neverthrow");
+var Errors = _interopRequireWildcard(require("./errors"));
+var z = _interopRequireWildcard(require("zod"));
+var _locatorHelpers = require("../../common/locatorHelpers");
+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 validateDynamicObjectExtractorOptions(page, label, options) {
+  const invalidate = options.optionalPropertiesInvalidator ?? (_extractionResult => []);
+  const searchRegion = options.searchRegion ?? page.locator("html");
+  const elementExist = (await searchRegion.count()) > 0;
+  const isElementVisible = await searchRegion.isVisible();
+  if (!elementExist || !isElementVisible) {
+    return (0, _neverthrow.err)(Errors.invalidSearchRegion(!elementExist ? "Element not found" : "Element is not visible"));
+  }
+  const searchRegionHandler = await searchRegion.elementHandle();
+  if (!searchRegionHandler) {
+    return (0, _neverthrow.err)(Errors.invalidSearchRegion());
+  }
+  let currentPageUrl = page.url();
+  const validationResult = z.string().nonempty().safeParse(currentPageUrl);
+  if (!validationResult.success) {
+    return (0, _neverthrow.err)(Errors.invalidPageState("Cannot get page url."));
+  }
+  currentPageUrl = validationResult.data;
+  const getPageUrlOrigin = () => new URL(page.url()).origin;
+  const safeGetPageUrlOrigin = (0, _neverthrow.fromThrowable)(getPageUrlOrigin, () => Errors.invalidPageState("Cannot get page url origin."));
+  const variantKey = options.variantKey ? (0, _neverthrow.ok)(options.variantKey) : safeGetPageUrlOrigin();
+  if (variantKey.isErr()) {
+    return (0, _neverthrow.err)(variantKey.error);
+  }
+  return (0, _neverthrow.ok)({
+    entityName: options.entityName,
+    entitySchema: options.entitySchema,
+    invalidate,
+    searchRegion,
+    searchRegionHandler,
+    variantKey: variantKey.value,
+    currentPageUrl,
+    searchRegionKey: options.searchRegion ? (0, _locatorHelpers.getLocatorInternalKey)(options.searchRegion) : null,
+    hasSearchRegionContainer: !!options.searchRegion,
+    label,
+    strategy: options.strategy,
+    prompt: options.prompt,
+    searchRegionXpath: options.searchRegion ? await (0, _locatorHelpers.findXPathForLocator)(options.searchRegion) : undefined,
+    apiKey: options.apiKey
+  });
+}

package/dist/optimized-extractors/types/aiModelsValidation.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SUPPORTED_VISION_MODELS = exports.SUPPORTED_TEXT_MODELS = exports.SUPPORTED_GPT_MODELS = exports.SUPPORTED_GOOGLE_MODELS = exports.SUPPORTED_CLAUDE_MODELS = exports.MODELS_MAPPINGS = exports.MAX_TOKENS_OVERRIDES = exports.GPT_MODELS_MAPPINGS = exports.GOOGLE_MODELS_MAPPINGS = exports.CLAUDE_VISION_SUPPORTED_MODELS = exports.CLAUDE_ONLY_TEXT_MODELS = exports.CLAUDE_MODELS_MAPPINGS = void 0;
+const CLAUDE_ONLY_TEXT_MODELS = exports.CLAUDE_ONLY_TEXT_MODELS = ["claude-3-5-haiku", "claude-3-5-haiku-20241022"];
+const CLAUDE_VISION_SUPPORTED_MODELS = exports.CLAUDE_VISION_SUPPORTED_MODELS = ["claude-3-haiku", "claude-3-haiku-20240307", "claude-3.5-sonnet", "claude-3-5-sonnet-20240620", "claude-3-5-sonnet-20241022", "claude-opus-4", "claude-opus-4-20250514", "claude-sonnet-4", "claude-sonnet-4-20250514"];
+const SUPPORTED_CLAUDE_MODELS = exports.SUPPORTED_CLAUDE_MODELS = [...CLAUDE_ONLY_TEXT_MODELS, ...CLAUDE_VISION_SUPPORTED_MODELS];
+const CLAUDE_MODELS_MAPPINGS = exports.CLAUDE_MODELS_MAPPINGS = {
+  "claude-3-haiku": "claude-3-haiku-20240307",
+  "claude-3-5-haiku": "claude-3-5-haiku-20241022",
+  "claude-3.5-sonnet": "claude-3-5-sonnet-20241022",
+  "claude-opus-4": "claude-opus-4-20250514",
+  "claude-sonnet-4": "claude-sonnet-4-20250514"
+};
+const GPT_ONLY_TEXT_GPT_MODELS = ["gpt3.5-turbo", "gpt-3.5-turbo-0125"];
+const GPT_VISION_SUPPORTED_MODELS = ["gpt4-turbo", "gpt-4-turbo-2024-04-09", "gpt-4o", "gpt-4o-2024-05-13", "gpt-4o-mini", "gpt-4o-mini-2024-07-18"];
+const SUPPORTED_GPT_MODELS = exports.SUPPORTED_GPT_MODELS = [...GPT_ONLY_TEXT_GPT_MODELS, ...GPT_VISION_SUPPORTED_MODELS];
+const GPT_MODELS_MAPPINGS = exports.GPT_MODELS_MAPPINGS = {
+  "gpt4-turbo": "gpt-4-turbo-2024-04-09",
+  "gpt3.5-turbo": "gpt-3.5-turbo-0125",
+  "gpt-4o": "gpt-4o-2024-05-13",
+  "gpt-4o-mini": "gpt-4o-mini-2024-07-18"
+};
+const SUPPORTED_GOOGLE_MODELS = exports.SUPPORTED_GOOGLE_MODELS = ["gemini-1.5-pro", "gemini-1.5-pro-002", "gemini-1.5-flash-8b", "gemini-1.5-flash-8b-002", "gemini-1.5-flash", "gemini-1.5-flash-002", "gemini-2.0-flash-exp"];
+const GOOGLE_MODELS_MAPPINGS = exports.GOOGLE_MODELS_MAPPINGS = {
+  "gemini-1.5-pro": "gemini-1.5-pro-002",
+  "gemini-1.5-flash-8b": "gemini-1.5-flash-8b-002",
+  "gemini-1.5-flash": "gemini-1.5-flash-002"
+};
+const SUPPORTED_TEXT_MODELS = exports.SUPPORTED_TEXT_MODELS = [...SUPPORTED_CLAUDE_MODELS, ...SUPPORTED_GPT_MODELS, ...SUPPORTED_GOOGLE_MODELS];
+const SUPPORTED_VISION_MODELS = exports.SUPPORTED_VISION_MODELS = [...CLAUDE_VISION_SUPPORTED_MODELS, ...GPT_VISION_SUPPORTED_MODELS, ...SUPPORTED_GOOGLE_MODELS];
+const MODELS_MAPPINGS = exports.MODELS_MAPPINGS = {
+  ...GPT_MODELS_MAPPINGS,
+  ...CLAUDE_MODELS_MAPPINGS,
+  ...GOOGLE_MODELS_MAPPINGS
+};
+const MAX_TOKENS_OVERRIDES = exports.MAX_TOKENS_OVERRIDES = {
+  "claude-3-5-sonnet-20240620": 8192,
+  "gemini-1.5-pro-002": 8192,
+  "gemini-1.5-flash-8b-002": 8192,
+  "gemini-1.5-flash-002": 8192,
+  "gemini-2.0-flash-exp": 8192
+};

package/dist/optimized-extractors/types/errors.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.other = exports.invalidInput = exports.invalidExtractionResult = exports.insufficientAiCredits = exports.NoToolUsage = exports.NoDataFound = exports.AiCallFailed = void 0;
+const NoDataFound = context => ({
+  type: "NoDataFound",
+  context
+});
+exports.NoDataFound = NoDataFound;
+const NoToolUsage = context => ({
+  type: "NoToolUsage",
+  context
+});
+exports.NoToolUsage = NoToolUsage;
+const AiCallFailed = (context, error) => ({
+  type: "AiCallFailed",
+  context,
+  error
+});
+exports.AiCallFailed = AiCallFailed;
+const invalidExtractionResult = context => ({
+  type: "InvalidExtractionResult",
+  context
+});
+exports.invalidExtractionResult = invalidExtractionResult;
+const invalidInput = context => ({
+  type: "invalidInput",
+  context
+});
+exports.invalidInput = invalidInput;
+const other = context => ({
+  type: "other",
+  context
+});
+exports.other = other;
+const insufficientAiCredits = context => ({
+  type: "InsufficientAiCredits",
+  context
+});
+exports.insufficientAiCredits = insufficientAiCredits;

package/dist/optimized-extractors/types/jsonSchema.d.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/optimized-extractors/types/jsonSchema.d.ts

@@ -0,0 +1,50 @@
+export interface BasicSchema {
+    type: string;
+    description?: string;
+  }
+  
+  export interface StringSchema extends BasicSchema {
+    type: "string";
+    enum?: string[];
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+  }
+  
+  export interface NumberSchema extends BasicSchema {
+    type: "number" | "integer";
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: number;
+    minimum?: number;
+    exclusiveMinimum?: number;
+  }
+  
+  export interface BooleanSchema extends BasicSchema {
+    type: "boolean";
+  }
+  
+  export interface ArraySchema extends BasicSchema {
+    type: "array";
+    items: JsonSchema;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+  }
+  
+  export interface ObjectSchema extends BasicSchema {
+    type: "object";
+    properties: Record<string, JsonSchema>;
+    required?: string[];
+  
+    maxProperties?: number;
+    minProperties?: number;
+  }
+  
+  export type JsonSchema =
+    | StringSchema
+    | NumberSchema
+    | BooleanSchema
+    | ArraySchema
+    | ObjectSchema;
+  

package/dist/optimized-extractors/types/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});