@intuned/browser-dev 0.1.4-dev.0

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
+});

package/dist/optimized-extractors/validators.js

@@ -0,0 +1,152 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.strategySchema = exports.simpleObjectJsonSchema = exports.simpleArrayItemJsonSchema = exports.extractObjectOptimizedInputSchema = exports.extractArrayOptimizedInputSchema = void 0;
+var _zod = require("zod");
+var _aiModelsValidation = require("./types/aiModelsValidation");
+const htmlStrategySchema = _zod.z.object({
+  model: _zod.z.enum(_aiModelsValidation.SUPPORTED_TEXT_MODELS, {
+    required_error: "strategy model is required",
+    invalid_type_error: "strategy model is invalid"
+  }),
+  type: _zod.z.literal("HTML", {
+    required_error: "strategy type is required",
+    invalid_type_error: "strategy type is invalid"
+  })
+});
+const imageStrategySchema = _zod.z.object({
+  model: _zod.z.enum(_aiModelsValidation.SUPPORTED_VISION_MODELS, {
+    required_error: "strategy model is required",
+    invalid_type_error: "strategy model is invalid"
+  }),
+  type: _zod.z.literal("IMAGE", {
+    required_error: "strategy type is required",
+    invalid_type_error: "strategy type is invalid"
+  })
+});
+const simpleStringSchema = _zod.z.object({
+  type: _zod.z.literal("string", {
+    required_error: "property type is required",
+    invalid_type_error: "optimized extractors only support string types"
+  }),
+  description: _zod.z.string({
+    required_error: "property description is required",
+    invalid_type_error: "property description must be a string"
+  }).optional()
+});
+const simpleArrayStringSchema = simpleStringSchema.extend({
+  primary: _zod.z.boolean().optional()
+});
+const simpleObjectJsonSchema = exports.simpleObjectJsonSchema = _zod.z.object({
+  type: _zod.z.literal("object", {
+    errorMap: () => ({
+      message: 'schema type is required, and must have the value "object"'
+    })
+  }),
+  description: _zod.z.string().optional(),
+  properties: _zod.z.record(_zod.z.string(), simpleStringSchema, {
+    required_error: "properties is required in object schemas"
+  }),
+  required: _zod.z.array(_zod.z.string(), {
+    required_error: "required must be an array of strings",
+    invalid_type_error: "required must be an array of strings"
+  }).min(1, {
+    message: "at least one property must be required"
+  })
+}, {
+  required_error: "schema is required"
+}).refine(data => {
+  return data.required.every(key => Object.keys(data.properties).includes(key));
+}, {
+  message: "All required keys must be defined in the properties object"
+}).refine(data => {
+  return Object.keys(data.properties).length > 0;
+}, {
+  message: "you must have at least one property in the properties object"
+});
+const simpleArrayItemJsonSchema = exports.simpleArrayItemJsonSchema = _zod.z.object({
+  type: _zod.z.literal("object", {
+    errorMap: () => ({
+      message: 'schema type is required, and must have the value "object"'
+    })
+  }),
+  description: _zod.z.string().optional(),
+  properties: _zod.z.record(_zod.z.string(), simpleArrayStringSchema, {
+    required_error: "properties is required in object schemas"
+  }),
+  required: _zod.z.array(_zod.z.string(), {
+    required_error: "required must be an array of strings",
+    invalid_type_error: "required must be an array of strings"
+  }).min(1, {
+    message: "at least one property must be required"
+  })
+}, {
+  required_error: "schema is required"
+}).refine(data => {
+  return data.required.every(key => Object.keys(data.properties).includes(key));
+}, {
+  message: "All required keys must be defined in the properties object"
+}).refine(data => {
+  const primaryField = Object.entries(data.properties).find(([_, v]) => v.primary);
+  return primaryField;
+}, {
+  message: "you must have one primary property"
+}).refine(data => {
+  const primaryField = Object.entries(data.properties).find(([_, v]) => v.primary);
+  if (!primaryField) {
+    return false;
+  }
+  return data.required.includes(primaryField[0]);
+}, {
+  message: "The primary field must be required"
+});
+const strategySchema = exports.strategySchema = _zod.z.union([htmlStrategySchema, imageStrategySchema], {
+  errorMap: (err, context) => {
+    if (err.code === "invalid_union" && context.data.model === "gpt3.5-turbo" && context.data.type === "IMAGE") {
+      return {
+        message: "gpt3.5-turbo does not support IMAGE strategy"
+      };
+    }
+    return {
+      message: err.message ?? "invalid strategy configuration"
+    };
+  }
+}).optional().default({
+  model: "claude-3-haiku",
+  type: "HTML"
+});
+const labelSchema = _zod.z.string({
+  invalid_type_error: "label must be a string",
+  required_error: "label is required"
+}).min(1, "label must be at least 1 character long");
+const entityNameSchema = _zod.z.string().min(1, {
+  message: "entity name must be at least 1 character long."
+}).max(50, {
+  message: "entity name must be no more than 50 characters long."
+}).regex(/^[a-zA-Z0-9_-]+$/, {
+  message: "entity name can only contain letters, digits, underscores, and hyphens."
+});
+const extractObjectOptimizedInputSchema = exports.extractObjectOptimizedInputSchema = _zod.z.object({
+  label: labelSchema,
+  strategy: strategySchema,
+  entityName: entityNameSchema,
+  entitySchema: simpleObjectJsonSchema,
+  variantKey: _zod.z.string().optional().default("about:blank"),
+  prompt: _zod.z.string().optional(),
+  optionalPropertiesInvalidator: _zod.z.function().returns(_zod.z.array(_zod.z.string())).optional().default(() => () => []),
+  apiKey: _zod.z.string().optional()
+}, {
+  required_error: "extractObjectOptimized function missing configurations"
+});
+const extractArrayOptimizedInputSchema = exports.extractArrayOptimizedInputSchema = _zod.z.object({
+  label: labelSchema,
+  strategy: strategySchema,
+  prompt: _zod.z.string().optional(),
+  itemEntityName: entityNameSchema,
+  itemEntitySchema: simpleArrayItemJsonSchema,
+  variantKey: _zod.z.string().optional(),
+  optionalPropertiesInvalidator: _zod.z.function().returns(_zod.z.array(_zod.z.string())).optional().default(() => () => []),
+  apiKey: _zod.z.string().optional()
+});

package/dist/types/intuned-runtime.d.js

@@ -0,0 +1 @@
+"use strict";

package/dist/types/intuned-runtime.d.ts

@@ -0,0 +1,64 @@
+// Type declaration for optional peer dependency @intuned/runtime
+// When the package is installed, its actual types will be used instead
+declare module "@intuned/runtime" {
+  import type { BrowserContext, Page } from "playwright";
+
+  export interface Proxy {
+    server: string;
+    username: string;
+    password: string;
+  }
+
+  export type WithPlaywrightContextWrappedFunction<R> = (
+    context: BrowserContext,
+    page: Page
+  ) => Promise<any>;
+
+  export function getExecutionContext(): any;
+  export function extendTimeout(): void;
+  export function runWithContext<T>(
+    context: any,
+    fn: () => T | Promise<T>
+  ): Promise<T>;
+  export function getDownloadDirectoryPath(): string;
+
+  export function withPlaywrightContext<R>(
+    options: {
+      proxy?: Proxy;
+      headless: boolean;
+      downloadsPath: string;
+      importFunction?: any;
+      apiName?: string;
+      apiParameters?: any;
+    },
+    fn: WithPlaywrightContextWrappedFunction<R>
+  ): Promise<any>;
+
+  export function withPlaywrightContext<R>(
+    options: {
+      cdpAddress: string;
+      importFunction?: any;
+      apiName?: string;
+      apiParameters?: any;
+    },
+    fn: WithPlaywrightContextWrappedFunction<R>
+  ): Promise<any>;
+
+  // Add other exports from @intuned/runtime if needed
+}
+
+declare module "@intuned/runtime/dist/common/jwtTokenManager" {
+  export interface BackendFunctionsTokenManager {
+    getToken(): Promise<string>;
+    refreshToken(): Promise<string>;
+    clearToken(): void;
+    // Add other methods as needed
+  }
+
+  export const backendFunctionsTokenManager: BackendFunctionsTokenManager;
+
+  export function callBackendFunctionWithToken<T = any>(
+    functionName: string,
+    params?: any
+  ): Promise<T>;
+}

package/dist/vite-env.d.js

@@ -0,0 +1 @@
+"use strict";

package/dist/vite-env.d.ts

@@ -0,0 +1,9 @@
+interface ImportMetaEnv {
+  readonly VITE_S3_BUCKET: string;
+  readonly VITE_AWS_REGION?: string;
+  readonly VITE_API_URL?: string;
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv;
+}