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

package/dist/ai-extractors/extractionHelpers/extractStructuredDataUsingAi/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("./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/ai-extractors/extractionHelpers/extractStructuredDataUsingAi/types.js

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

package/dist/ai-extractors/extractionHelpers/extractStructuredDataUsingAi/utils.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cleanupAiResult = cleanupAiResult;
+exports.getResultFromOutputSchema = getResultFromOutputSchema;
+exports.processInputSchema = processInputSchema;
+function processInputSchema(originalJsonSchema, entityName) {
+  const internalSchema = structuredClone(originalJsonSchema);
+  delete internalSchema.description;
+  if (originalJsonSchema.type === "array") {
+    return {
+      type: "object",
+      properties: {
+        [`number_of_${entityName}`]: {
+          type: "number",
+          description: `The number of ${entityName} items in the text - not the overall total. Relay on the text to find this, if the number is not mentioned in the text, this should be null. For example, some lists say 'showing 5 our of 20 items' - 5 is the number of items in the list.`
+        },
+        [`${entityName}`]: internalSchema
+      },
+      required: [`number_of_${entityName}`, `${entityName}`]
+    };
+  }
+  return internalSchema;
+}
+function getResultFromOutputSchema(originalJsonSchema, entityName, parsedData) {
+  if (originalJsonSchema.type === "array") {
+    const items = parsedData[entityName] ?? [];
+    return items;
+  }
+  return parsedData;
+}
+function cleanUpAiReturnedString(str) {
+  return str.replaceAll(/&/g, "&");
+}
+function cleanupAiResult(obj) {
+  if (typeof obj === "string") {
+    return cleanUpAiReturnedString(obj);
+  }
+  if (typeof obj !== "object" || obj === null) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(cleanupAiResult);
+  }
+  return Object.entries(obj).reduce((acc, [key, value]) => {
+    if (value !== null && value !== undefined && value !== "") {
+      acc[key] = cleanupAiResult(value);
+    }
+    return acc;
+  }, {});
+}

package/dist/ai-extractors/extractionHelpers/types.js

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

package/dist/ai-extractors/fileExtractors.js

@@ -0,0 +1,176 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractMarkdownFromFile = extractMarkdownFromFile;
+exports.extractStructuredDataFromFile = extractStructuredDataFromFile;
+exports.extractTablesFromFile = extractTablesFromFile;
+var _jwtTokenManager = require("../common/jwtTokenManager");
+var _formatZodError = require("../common/formatZodError");
+var _validators = require("./validators");
+var _getFileTrackingHeaders = require("../common/eventTracking/getFileTrackingHeaders");
+var _environmentVariables = require("../common/environmentVariables");
+var _runtime = require("@intuned/runtime");
+var _zod = require("zod");
+var _Logger = require("../common/Logger");
+var _asyncRetry = _interopRequireDefault(require("async-retry"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const usageInfoSchema = _zod.z.object({
+  pagesProcessed: _zod.z.number().optional(),
+  aiCostInCents: _zod.z.number().optional()
+});
+const serializeFile = file => {
+  if (file.source.type == "buffer") {
+    return {
+      ...file,
+      source: {
+        type: "base64",
+        data: file.source.data.toString("base64")
+      }
+    };
+  }
+  return file;
+};
+async function extractMarkdownFromFile(file, options) {
+  const fileParsingErrors = (0, _validators.validateFileSchema)(file);
+  if (fileParsingErrors && fileParsingErrors.length > 0) {
+    const message = `invalid extractMarkdownFromFile input: ${fileParsingErrors.join("\n")}`;
+    throw new Error(message);
+  }
+  const identifierParsingResult = _validators.labelSchema.safeParse(options.label);
+  if (identifierParsingResult.success === false) {
+    const message = `invalid identifier: ${(0, _formatZodError.formatZodError)(identifierParsingResult.error).join("\n")}`;
+    throw new Error(message);
+  }
+  const operationId = await initiateExtraction({
+    operationName: "toMd",
+    label: options.label,
+    requestBody: JSON.stringify({
+      file: serializeFile(file)
+    })
+  });
+  const pollingResult = await pollForExtractionResult("toMd", operationId);
+  if (pollingResult.usage) {
+    const usageParsing = usageInfoSchema.safeParse(pollingResult.usage);
+    if (usageParsing.success && usageParsing.data.pagesProcessed !== undefined) {
+      _Logger.logger.info(`extractMarkdownFromFile with label ${options.label} used ${usageParsing.data.pagesProcessed} pages in file processing`);
+    }
+  }
+  return pollingResult.result;
+}
+async function extractTablesFromFile(file, options) {
+  const fileParsingErrors = (0, _validators.validateFileSchema)(file);
+  if (fileParsingErrors && fileParsingErrors.length > 0) {
+    const message = `invalid extractTablesFromFile input: ${fileParsingErrors.join("\n")}`;
+    throw new Error(message);
+  }
+  const identifierParsingResult = _validators.labelSchema.safeParse(options.label);
+  if (identifierParsingResult.success === false) {
+    const message = `invalid identifier: ${(0, _formatZodError.formatZodError)(identifierParsingResult.error).join("\n")}`;
+    throw new Error(message);
+  }
+  const operationId = await initiateExtraction({
+    operationName: "extractTables",
+    label: options.label,
+    requestBody: JSON.stringify({
+      file: serializeFile(file)
+    })
+  });
+  const pollingResult = await pollForExtractionResult("extractTables", operationId);
+  if (pollingResult.usage) {
+    const usageParsing = usageInfoSchema.safeParse(pollingResult.usage);
+    if (usageParsing.success && usageParsing.data.pagesProcessed !== undefined) {
+      _Logger.logger.info(`extractTablesFromFile with label ${options.label} used ${usageParsing.data.pagesProcessed} pages in file processing`);
+    }
+  }
+  return pollingResult.result;
+}
+async function extractStructuredDataFromFile(file, options) {
+  const fileParsingErrors = (0, _validators.validateFileSchema)(file);
+  if (fileParsingErrors && fileParsingErrors.length > 0) {
+    const message = `invalid file: ${fileParsingErrors.join("\n")}`;
+    throw new Error(message);
+  }
+  const optionsParsingResult = _validators.extractDataFromFileOptionsSchema.safeParse(options);
+  if (!optionsParsingResult.success) {
+    const message = `invalid options: ${(0, _formatZodError.formatZodError)(optionsParsingResult.error).join("\n")}`;
+    throw new Error(message);
+  }
+  const operationId = await initiateExtraction({
+    operationName: "extractData",
+    label: options.label,
+    requestBody: JSON.stringify({
+      file: serializeFile(file),
+      ...optionsParsingResult.data
+    })
+  });
+  const pollingResult = await pollForExtractionResult("extractData", operationId);
+  if (pollingResult.usage) {
+    const usageParsing = usageInfoSchema.safeParse(pollingResult.usage);
+    if (usageParsing.success) {
+      if (usageParsing.data.pagesProcessed !== undefined) {
+        _Logger.logger.info(`extractStructuredDataFromFile with label ${options.label} used ${usageParsing.data.pagesProcessed} pages in file processing`);
+      }
+      if (usageParsing.data.aiCostInCents !== undefined) {
+        _Logger.logger.info(`extractStructuredDataFromFile with label ${options.label} Ai cost is $${usageParsing.data.aiCostInCents / 100}`);
+      }
+    }
+  }
+  return pollingResult.result;
+}
+async function initiateExtraction({
+  operationName,
+  label,
+  requestBody
+}) {
+  var _getExecutionContext, _getExecutionContext2, _getExecutionContext3, _getExecutionContext4;
+  const response = await (0, _jwtTokenManager.callBackendFunctionWithToken)(`files/${operationName}/start`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...(0, _getFileTrackingHeaders.getFilesTrackingHeaders)({
+        environment: (0, _environmentVariables.getEnvironmentVariable)("RUN_ENVIRONMENT"),
+        runId: (_getExecutionContext = (0, _runtime.getExecutionContext)()) === null || _getExecutionContext === void 0 ? void 0 : _getExecutionContext.runId,
+        identifier: label,
+        jobId: (_getExecutionContext2 = (0, _runtime.getExecutionContext)()) === null || _getExecutionContext2 === void 0 ? void 0 : _getExecutionContext2.jobId,
+        jobRunId: (_getExecutionContext3 = (0, _runtime.getExecutionContext)()) === null || _getExecutionContext3 === void 0 ? void 0 : _getExecutionContext3.jobRunId,
+        queueId: (_getExecutionContext4 = (0, _runtime.getExecutionContext)()) === null || _getExecutionContext4 === void 0 ? void 0 : _getExecutionContext4.queueId
+      })
+    },
+    body: requestBody
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to initiate ${operationName} extraction: HTTP ${response.status} - ${await response.text()}`);
+  }
+  const responseJson = await response.json();
+  const operationId = responseJson === null || responseJson === void 0 ? void 0 : responseJson.operationId;
+  if (!operationId) {
+    throw new Error("Failed to get operation ID from workflow response");
+  }
+  return operationId;
+}
+async function pollForExtractionResult(fileOperationType, operationId) {
+  return (0, _asyncRetry.default)(async bail => {
+    const pollRes = await (0, _jwtTokenManager.callBackendFunctionWithToken)(`files/${fileOperationType}/${operationId}/check`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    if (!pollRes.ok) {
+      bail(new Error(`Failed to check ${fileOperationType} results (non-retryable), ${pollRes.status} ${await pollRes.text()}`));
+      return;
+    }
+    const pollResJson = await pollRes.json();
+    if (pollResJson.status === "completed" || pollResJson.status === "failed") {
+      return pollResJson;
+    }
+    throw new Error("Operation not completed yet");
+  }, {
+    retries: 100,
+    factor: 1,
+    minTimeout: 3000,
+    maxTimeout: 3000
+  });
+}

package/dist/ai-extractors/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "extractMarkdownFromFile", {
+  enumerable: true,
+  get: function () {
+    return _fileExtractors.extractMarkdownFromFile;
+  }
+});
+Object.defineProperty(exports, "extractStructuredDataFromContent", {
+  enumerable: true,
+  get: function () {
+    return _extractStructuredData.extractStructuredDataFromContent;
+  }
+});
+Object.defineProperty(exports, "extractStructuredDataFromFile", {
+  enumerable: true,
+  get: function () {
+    return _fileExtractors.extractStructuredDataFromFile;
+  }
+});
+Object.defineProperty(exports, "extractTablesFromFile", {
+  enumerable: true,
+  get: function () {
+    return _fileExtractors.extractTablesFromFile;
+  }
+});
+var _fileExtractors = require("./fileExtractors");
+var _extractStructuredData = require("./extractStructuredData");

package/dist/ai-extractors/jsonSchema.d.js

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

package/dist/ai-extractors/jsonSchema.d.ts

@@ -0,0 +1,49 @@
+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/ai-extractors/openAiClients/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createOpenAIInstance = createOpenAIInstance;
+var _openai = require("openai");
+var _dotenv = require("dotenv");
+var _jwtTokenManager = require("../../common/jwtTokenManager");
+(0, _dotenv.config)();
+function createOpenAIInstance(options) {
+  if (options !== null && options !== void 0 && options.apiKey) {
+    return new _openai.OpenAI({
+      apiKey: options.apiKey
+    });
+  }
+  const openai = new _openai.OpenAI({
+    apiKey: "",
+    baseURL: `${process.env.FUNCTIONS_DOMAIN}/api/${process.env.INTUNED_WORKSPACE_ID}/functions/${process.env.INTUNED_INTEGRATION_ID}/openai`,
+    fetch: _jwtTokenManager.backendFunctionsTokenManager.fetchWithToken.bind(_jwtTokenManager.backendFunctionsTokenManager)
+  });
+  return openai;
+}

package/dist/ai-extractors/validators.js

@@ -0,0 +1,239 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sheetFileSchema = exports.pdfFileSchema = exports.labelSchema = exports.jsonSchema = exports.imageFileSchema = exports.genericExtractDataInputSchema = exports.extractDataInputJsonSchema = exports.extractDataFromFileOptionsSchema = exports.docFileSchema = exports.contentValidationSchema = void 0;
+exports.validateFileSchema = validateFileSchema;
+var _zod = require("zod");
+var _locatorHelpers = require("../common/locatorHelpers");
+var _ajv = _interopRequireDefault(require("ajv"));
+var _formatZodError = require("../common/formatZodError");
+var _aiModelsValidations = require("../common/aiModelsValidations");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const labelSchema = exports.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 htmlStrategySchema = _zod.z.object({
+  model: _zod.z.enum(_aiModelsValidations.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(_aiModelsValidations.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 markdownStrategySchema = _zod.z.object({
+  model: _zod.z.enum(_aiModelsValidations.SUPPORTED_TEXT_MODELS, {
+    required_error: "strategy model is required",
+    invalid_type_error: "strategy model is invalid"
+  }),
+  type: _zod.z.literal("MARKDOWN", {
+    required_error: "strategy type is required",
+    invalid_type_error: "strategy type is invalid"
+  })
+});
+const strategySchema = _zod.z.union([htmlStrategySchema, imageStrategySchema], {
+  errorMap: (err, context) => {
+    console.log(context.data);
+    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 basicSchema = _zod.z.object({
+  type: _zod.z.string(),
+  description: _zod.z.string().optional()
+});
+const stringSchema = basicSchema.extend({
+  type: _zod.z.literal("string"),
+  enum: _zod.z.array(_zod.z.string()).optional(),
+  maxLength: _zod.z.number().optional(),
+  minLength: _zod.z.number().optional(),
+  pattern: _zod.z.string().optional()
+});
+const numberSchema = basicSchema.extend({
+  type: _zod.z.union([_zod.z.literal("number"), _zod.z.literal("integer")]),
+  multipleOf: _zod.z.number().optional(),
+  maximum: _zod.z.number().optional(),
+  exclusiveMaximum: _zod.z.number().optional(),
+  minimum: _zod.z.number().optional(),
+  exclusiveMinimum: _zod.z.number().optional()
+});
+const booleanSchema = basicSchema.extend({
+  type: _zod.z.literal("boolean")
+});
+const arraySchema = basicSchema.extend({
+  type: _zod.z.literal("array"),
+  items: _zod.z.lazy(() => jsonSchema),
+  maxItems: _zod.z.number().min(0).optional(),
+  minItems: _zod.z.number().min(0).optional(),
+  uniqueItems: _zod.z.boolean().optional()
+});
+const objectSchema = basicSchema.extend({
+  type: _zod.z.literal("object"),
+  properties: _zod.z.record(_zod.z.string(), _zod.z.lazy(() => jsonSchema)),
+  required: _zod.z.array(_zod.z.string()),
+  maxProperties: _zod.z.number().min(1).optional(),
+  minProperties: _zod.z.number().min(1).optional()
+});
+const jsonSchema = exports.jsonSchema = _zod.z.union([stringSchema, numberSchema, booleanSchema, arraySchema, objectSchema]);
+const jsonSchemaCustomValidation = _zod.z.any().refine(value => {
+  try {
+    const ajv = new _ajv.default({});
+    void ajv.validateSchema(value, true);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}, value => {
+  try {
+    const ajv = new _ajv.default({
+      strict: true,
+      strictRequired: true
+    });
+    value && void ajv.validateSchema(value, true);
+  } catch (e) {
+    const message = e.message.replace("schema is invalid: ", "").split(", ")[0].replace("data/", "").replaceAll("/", ".");
+    return {
+      message
+    };
+  }
+  return {
+    message: "invalid data schema"
+  };
+}).refine(v => {
+  if (v && v.type !== "object" && v.type !== "array") {
+    return false;
+  }
+  return true;
+}, {
+  message: "root schema must be an object or an array"
+}).refine(v => {
+  if (v && v.type !== "object") {
+    return true;
+  }
+  return !!(v !== null && v !== void 0 && v.properties);
+}, {
+  message: "object schema must have properties"
+}).refine(v => {
+  if (v && v.type !== "array") {
+    return true;
+  }
+  return !!(v !== null && v !== void 0 && v.items);
+}, {
+  message: "array schema must have items"
+});
+const extractDataInputJsonSchema = exports.extractDataInputJsonSchema = _zod.z.object({
+  label: labelSchema,
+  dataSchema: jsonSchemaCustomValidation,
+  strategy: strategySchema,
+  prompt: _zod.z.string().optional(),
+  searchRegion: _zod.z.any().refine(_locatorHelpers.isLocator, {
+    message: "invalid search region, search region must be a playwright locator"
+  }).optional(),
+  apiKey: _zod.z.string().optional()
+});
+const base64Schema = _zod.z.object({
+  type: _zod.z.literal("base64"),
+  data: _zod.z.string()
+});
+const bufferSchema = _zod.z.object({
+  type: _zod.z.literal("buffer"),
+  data: _zod.z.instanceof(Buffer)
+});
+const urlSchema = _zod.z.object({
+  type: _zod.z.literal("url"),
+  data: _zod.z.string().url()
+});
+const sourceSchema = _zod.z.union([base64Schema, urlSchema, bufferSchema], {
+  errorMap: err => {
+    if (err.code === "invalid_union") {
+      return {
+        message: "source must be a valid base64, buffer or url"
+      };
+    }
+    return {
+      message: err.message ?? ""
+    };
+  }
+});
+const pagesSchema = _zod.z.array(_zod.z.number()).optional();
+const pdfFileSchema = exports.pdfFileSchema = _zod.z.object({
+  type: _zod.z.literal("pdf"),
+  pages: pagesSchema,
+  source: sourceSchema
+});
+const imageFileSchema = exports.imageFileSchema = _zod.z.object({
+  type: _zod.z.literal("image"),
+  source: sourceSchema
+});
+const sheetFileSchema = exports.sheetFileSchema = _zod.z.object({
+  type: _zod.z.literal("spreadsheet"),
+  sheetName: _zod.z.string(),
+  source: sourceSchema
+});
+const docFileSchema = exports.docFileSchema = _zod.z.object({
+  type: _zod.z.literal("document"),
+  pages: pagesSchema,
+  source: sourceSchema
+});
+const fileSchemas = [pdfFileSchema, imageFileSchema, sheetFileSchema, docFileSchema];
+function validateFileSchema(data) {
+  if (!data) {
+    return [`"file" is required`];
+  }
+  const schema = fileSchemas.find(schema => schema.shape.type.safeParse(data.type).success);
+  if (!schema) {
+    const validTypes = fileSchemas.map(s => s.shape.type.value);
+    return [`data.type must be either ${validTypes.join(" or ")}, got ${data.type}`];
+  }
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    return (0, _formatZodError.formatZodError)(result.error);
+  }
+}
+const extractDataFromFileOptionsSchema = exports.extractDataFromFileOptionsSchema = _zod.z.object({
+  dataSchema: jsonSchemaCustomValidation,
+  label: labelSchema,
+  prompt: _zod.z.string().optional(),
+  strategy: _zod.z.union([markdownStrategySchema, imageStrategySchema]).optional()
+});
+const contentItemValidationSchema = _zod.z.union([_zod.z.object({
+  type: _zod.z.literal("text"),
+  data: _zod.z.string()
+}), _zod.z.object({
+  type: _zod.z.literal("image-buffer"),
+  data: _zod.z.instanceof(Buffer),
+  image_type: _zod.z.enum(["png", "jpeg", "gif", "webp"])
+}), _zod.z.object({
+  type: _zod.z.literal("image-url"),
+  data: _zod.z.string().url(),
+  image_type: _zod.z.enum(["png", "jpeg", "gif", "webp"])
+})]);
+const contentValidationSchema = exports.contentValidationSchema = _zod.z.union([_zod.z.array(contentItemValidationSchema).min(1, "content should have at least one item"), contentItemValidationSchema]);
+const genericExtractDataInputSchema = exports.genericExtractDataInputSchema = _zod.z.object({
+  dataSchema: jsonSchemaCustomValidation,
+  prompt: _zod.z.string().optional(),
+  model: _zod.z.enum(_aiModelsValidations.SUPPORTED_TEXT_MODELS)
+});

package/dist/browser/ai/export.d.js

@@ -0,0 +1,3 @@
+"use strict";
+
+var _jsonSchema = require("./jsonSchema");