ocr-ai 1.0.0

package/dist/index.js

@@ -0,0 +1,1013 @@
+'use strict';
+
+var generativeAi = require('@google/generative-ai');
+var OpenAI = require('openai');
+var Anthropic = require('@anthropic-ai/sdk');
+var genai = require('@google/genai');
+var fs = require('fs/promises');
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var OpenAI__default = /*#__PURE__*/_interopDefault(OpenAI);
+var Anthropic__default = /*#__PURE__*/_interopDefault(Anthropic);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+// src/providers/base.provider.ts
+var BaseProvider = class {
+  apiKey;
+  constructor(apiKey) {
+    if (!apiKey || apiKey.trim() === "") {
+      throw new Error(`API key is required for ${this.constructor.name}`);
+    }
+    this.apiKey = apiKey;
+  }
+  supportsFileType(type) {
+    return ["pdf", "image", "text"].includes(type);
+  }
+  /**
+   * Build the text extraction prompt
+   */
+  buildTextPrompt(options) {
+    const basePrompt = options?.prompt || "Extract all text content from this document.";
+    const languageHint = options?.language && options.language !== "auto" ? ` Respond in ${options.language}.` : "";
+    return `${basePrompt}${languageHint}
+
+Please extract and return all the text content from the provided document.
+Maintain the original structure and formatting as much as possible.
+Return only the extracted text, without any additional commentary or metadata.`;
+  }
+  /**
+   * Build the JSON extraction prompt
+   */
+  buildJsonPrompt(schema, options) {
+    const basePrompt = options?.prompt || "Extract structured data from this document.";
+    const languageHint = options?.language && options.language !== "auto" ? ` Text content should be in ${options.language}.` : "";
+    return `${basePrompt}${languageHint}
+
+Extract data from the provided document and return it as a JSON object following this schema:
+
+${JSON.stringify(schema, null, 2)}
+
+Important:
+- Return ONLY valid JSON, no additional text or markdown formatting
+- Follow the schema structure exactly
+- If a field cannot be extracted, use null
+- Do not include any explanation, just the JSON object`;
+  }
+  /**
+   * Parse JSON response from AI, handling potential formatting issues
+   */
+  parseJsonResponse(response) {
+    let cleaned = response.trim();
+    if (cleaned.startsWith("```json")) {
+      cleaned = cleaned.slice(7);
+    } else if (cleaned.startsWith("```")) {
+      cleaned = cleaned.slice(3);
+    }
+    if (cleaned.endsWith("```")) {
+      cleaned = cleaned.slice(0, -3);
+    }
+    cleaned = cleaned.trim();
+    try {
+      return JSON.parse(cleaned);
+    } catch {
+      throw new Error(`Failed to parse JSON response: ${response.substring(0, 200)}...`);
+    }
+  }
+};
+var DEFAULT_MODEL = "gemini-1.5-flash";
+var GeminiProvider = class extends BaseProvider {
+  name = "gemini";
+  model;
+  client;
+  constructor(apiKey, model) {
+    super(apiKey);
+    this.model = model || DEFAULT_MODEL;
+    this.client = new generativeAi.GoogleGenerativeAI(apiKey);
+  }
+  async extractText(file, options) {
+    const generationConfig = this.buildGenerationConfig(options?.modelConfig);
+    const model = this.client.getGenerativeModel({
+      model: this.model,
+      generationConfig
+    });
+    const prompt = this.buildTextPrompt(options);
+    const content = this.buildContent(file, prompt);
+    const result = await model.generateContent(content);
+    const response = result.response;
+    const tokens = this.extractTokenUsage(response);
+    return {
+      content: response.text(),
+      tokens
+    };
+  }
+  async extractJson(file, schema, options) {
+    const generationConfig = this.buildGenerationConfig(options?.modelConfig, {
+      responseMimeType: "application/json"
+    });
+    const model = this.client.getGenerativeModel({
+      model: this.model,
+      generationConfig
+    });
+    const prompt = this.buildJsonPrompt(schema, options);
+    const content = this.buildContent(file, prompt);
+    const result = await model.generateContent(content);
+    const response = result.response;
+    const text = response.text();
+    const tokens = this.extractTokenUsage(response);
+    return {
+      content: this.parseJsonResponse(text),
+      tokens
+    };
+  }
+  buildGenerationConfig(modelConfig, defaults) {
+    const config = { ...defaults };
+    if (modelConfig?.temperature !== void 0) {
+      config.temperature = modelConfig.temperature;
+    }
+    if (modelConfig?.maxTokens !== void 0) {
+      config.maxOutputTokens = modelConfig.maxTokens;
+    }
+    if (modelConfig?.topP !== void 0) {
+      config.topP = modelConfig.topP;
+    }
+    if (modelConfig?.topK !== void 0) {
+      config.topK = modelConfig.topK;
+    }
+    if (modelConfig?.stopSequences !== void 0) {
+      config.stopSequences = modelConfig.stopSequences;
+    }
+    return config;
+  }
+  extractTokenUsage(response) {
+    const usage = response.usageMetadata;
+    if (!usage) return void 0;
+    return {
+      inputTokens: usage.promptTokenCount || 0,
+      outputTokens: usage.candidatesTokenCount || 0,
+      totalTokens: usage.totalTokenCount || 0
+    };
+  }
+  buildContent(file, prompt) {
+    if (file.type === "text") {
+      return `${prompt}
+
+Document content:
+${file.content.toString("utf-8")}`;
+    }
+    return [
+      {
+        inlineData: {
+          mimeType: file.mimeType,
+          data: file.base64 || file.content.toString("base64")
+        }
+      },
+      { text: prompt }
+    ];
+  }
+};
+var DEFAULT_MODEL2 = "gpt-4o";
+var OpenAIProvider = class extends BaseProvider {
+  name = "openai";
+  model;
+  client;
+  constructor(apiKey, model) {
+    super(apiKey);
+    this.model = model || DEFAULT_MODEL2;
+    this.client = new OpenAI__default.default({ apiKey });
+  }
+  async extractText(file, options) {
+    const prompt = this.buildTextPrompt(options);
+    const messages = this.buildMessages(file, prompt);
+    const completionOptions = this.buildCompletionOptions(options?.modelConfig);
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      messages,
+      ...completionOptions
+    });
+    const tokens = this.extractTokenUsage(response);
+    return {
+      content: response.choices[0]?.message?.content || "",
+      tokens
+    };
+  }
+  async extractJson(file, schema, options) {
+    const prompt = this.buildJsonPrompt(schema, options);
+    const messages = this.buildMessages(file, prompt);
+    const completionOptions = this.buildCompletionOptions(options?.modelConfig);
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      messages,
+      ...completionOptions,
+      response_format: { type: "json_object" }
+    });
+    const text = response.choices[0]?.message?.content || "{}";
+    const tokens = this.extractTokenUsage(response);
+    return {
+      content: this.parseJsonResponse(text),
+      tokens
+    };
+  }
+  buildCompletionOptions(modelConfig) {
+    const options = {
+      max_tokens: 16384
+    };
+    if (modelConfig?.temperature !== void 0) {
+      options.temperature = modelConfig.temperature;
+    }
+    if (modelConfig?.maxTokens !== void 0) {
+      options.max_tokens = modelConfig.maxTokens;
+    }
+    if (modelConfig?.topP !== void 0) {
+      options.top_p = modelConfig.topP;
+    }
+    if (modelConfig?.stopSequences !== void 0) {
+      options.stop = modelConfig.stopSequences;
+    }
+    return options;
+  }
+  extractTokenUsage(response) {
+    const usage = response.usage;
+    if (!usage) return void 0;
+    return {
+      inputTokens: usage.prompt_tokens,
+      outputTokens: usage.completion_tokens,
+      totalTokens: usage.total_tokens
+    };
+  }
+  buildMessages(file, prompt) {
+    if (file.type === "text") {
+      return [
+        {
+          role: "user",
+          content: `${prompt}
+
+Document content:
+${file.content.toString("utf-8")}`
+        }
+      ];
+    }
+    const base64 = file.base64 || file.content.toString("base64");
+    const imageUrl = `data:${file.mimeType};base64,${base64}`;
+    return [
+      {
+        role: "user",
+        content: [
+          {
+            type: "image_url",
+            image_url: {
+              url: imageUrl,
+              detail: "high"
+            }
+          },
+          {
+            type: "text",
+            text: prompt
+          }
+        ]
+      }
+    ];
+  }
+};
+var DEFAULT_MODEL3 = "claude-sonnet-4-20250514";
+var ClaudeProvider = class extends BaseProvider {
+  name = "claude";
+  model;
+  client;
+  constructor(apiKey, model) {
+    super(apiKey);
+    this.model = model || DEFAULT_MODEL3;
+    this.client = new Anthropic__default.default({ apiKey });
+  }
+  async extractText(file, options) {
+    const prompt = this.buildTextPrompt(options);
+    const messageOptions = this.buildMessageOptions(options?.modelConfig);
+    const response = await this.client.messages.create({
+      model: this.model,
+      messages: [
+        {
+          role: "user",
+          content: this.buildContent(file, prompt)
+        }
+      ],
+      max_tokens: messageOptions.max_tokens,
+      temperature: messageOptions.temperature,
+      top_p: messageOptions.top_p,
+      top_k: messageOptions.top_k,
+      stop_sequences: messageOptions.stop_sequences
+    });
+    const textBlock = response.content.find((block) => block.type === "text");
+    const tokens = this.extractTokenUsage(response);
+    return {
+      content: textBlock?.text || "",
+      tokens
+    };
+  }
+  async extractJson(file, schema, options) {
+    const prompt = this.buildJsonPrompt(schema, options);
+    const messageOptions = this.buildMessageOptions(options?.modelConfig);
+    const response = await this.client.messages.create({
+      model: this.model,
+      messages: [
+        {
+          role: "user",
+          content: this.buildContent(file, prompt)
+        }
+      ],
+      max_tokens: messageOptions.max_tokens,
+      temperature: messageOptions.temperature,
+      top_p: messageOptions.top_p,
+      top_k: messageOptions.top_k,
+      stop_sequences: messageOptions.stop_sequences
+    });
+    const textBlock = response.content.find((block) => block.type === "text");
+    const text = textBlock?.text || "{}";
+    const tokens = this.extractTokenUsage(response);
+    return {
+      content: this.parseJsonResponse(text),
+      tokens
+    };
+  }
+  buildMessageOptions(modelConfig) {
+    const options = {
+      max_tokens: 16384
+    };
+    if (modelConfig?.temperature !== void 0) {
+      options.temperature = modelConfig.temperature;
+    }
+    if (modelConfig?.maxTokens !== void 0) {
+      options.max_tokens = modelConfig.maxTokens;
+    }
+    if (modelConfig?.topP !== void 0) {
+      options.top_p = modelConfig.topP;
+    }
+    if (modelConfig?.topK !== void 0) {
+      options.top_k = modelConfig.topK;
+    }
+    if (modelConfig?.stopSequences !== void 0) {
+      options.stop_sequences = modelConfig.stopSequences;
+    }
+    return options;
+  }
+  supportsFileType(type) {
+    return ["pdf", "image", "text"].includes(type);
+  }
+  extractTokenUsage(response) {
+    return {
+      inputTokens: response.usage.input_tokens,
+      outputTokens: response.usage.output_tokens,
+      totalTokens: response.usage.input_tokens + response.usage.output_tokens
+    };
+  }
+  buildContent(file, prompt) {
+    if (file.type === "text") {
+      return `${prompt}
+
+Document content:
+${file.content.toString("utf-8")}`;
+    }
+    const base64 = file.base64 || file.content.toString("base64");
+    if (file.type === "pdf") {
+      return [
+        {
+          type: "document",
+          source: {
+            type: "base64",
+            media_type: "application/pdf",
+            data: base64
+          }
+        },
+        {
+          type: "text",
+          text: prompt
+        }
+      ];
+    }
+    return [
+      {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: this.getMediaType(file.mimeType),
+          data: base64
+        }
+      },
+      {
+        type: "text",
+        text: prompt
+      }
+    ];
+  }
+  getMediaType(mimeType) {
+    const supportedTypes = [
+      "image/jpeg",
+      "image/png",
+      "image/gif",
+      "image/webp"
+    ];
+    if (supportedTypes.includes(mimeType)) {
+      return mimeType;
+    }
+    return "image/jpeg";
+  }
+};
+var GROK_BASE_URL = "https://api.x.ai/v1";
+var DEFAULT_MODEL4 = "grok-2-vision-1212";
+var GrokProvider = class extends BaseProvider {
+  name = "grok";
+  model;
+  client;
+  constructor(apiKey, model) {
+    super(apiKey);
+    this.model = model || DEFAULT_MODEL4;
+    this.client = new OpenAI__default.default({
+      apiKey,
+      baseURL: GROK_BASE_URL
+    });
+  }
+  async extractText(file, options) {
+    const prompt = this.buildTextPrompt(options);
+    const messages = this.buildMessages(file, prompt);
+    const completionOptions = this.buildCompletionOptions(options?.modelConfig);
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      messages,
+      ...completionOptions
+    });
+    const tokens = this.extractTokenUsage(response);
+    return {
+      content: response.choices[0]?.message?.content || "",
+      tokens
+    };
+  }
+  async extractJson(file, schema, options) {
+    const prompt = this.buildJsonPrompt(schema, options);
+    const messages = this.buildMessages(file, prompt);
+    const completionOptions = this.buildCompletionOptions(options?.modelConfig);
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      messages,
+      ...completionOptions
+    });
+    const text = response.choices[0]?.message?.content || "{}";
+    const tokens = this.extractTokenUsage(response);
+    return {
+      content: this.parseJsonResponse(text),
+      tokens
+    };
+  }
+  buildCompletionOptions(modelConfig) {
+    const options = {
+      max_tokens: 16384
+    };
+    if (modelConfig?.temperature !== void 0) {
+      options.temperature = modelConfig.temperature;
+    }
+    if (modelConfig?.maxTokens !== void 0) {
+      options.max_tokens = modelConfig.maxTokens;
+    }
+    if (modelConfig?.topP !== void 0) {
+      options.top_p = modelConfig.topP;
+    }
+    if (modelConfig?.stopSequences !== void 0) {
+      options.stop = modelConfig.stopSequences;
+    }
+    return options;
+  }
+  extractTokenUsage(response) {
+    const usage = response.usage;
+    if (!usage) return void 0;
+    return {
+      inputTokens: usage.prompt_tokens,
+      outputTokens: usage.completion_tokens,
+      totalTokens: usage.total_tokens
+    };
+  }
+  buildMessages(file, prompt) {
+    if (file.type === "text") {
+      return [
+        {
+          role: "user",
+          content: `${prompt}
+
+Document content:
+${file.content.toString("utf-8")}`
+        }
+      ];
+    }
+    const base64 = file.base64 || file.content.toString("base64");
+    const imageUrl = `data:${file.mimeType};base64,${base64}`;
+    return [
+      {
+        role: "user",
+        content: [
+          {
+            type: "image_url",
+            image_url: {
+              url: imageUrl,
+              detail: "high"
+            }
+          },
+          {
+            type: "text",
+            text: prompt
+          }
+        ]
+      }
+    ];
+  }
+};
+var DEFAULT_MODEL5 = "gemini-2.0-flash";
+var VertexProvider = class extends BaseProvider {
+  name = "vertex";
+  model;
+  client;
+  constructor(config, model) {
+    super("vertex");
+    this.model = model || DEFAULT_MODEL5;
+    this.client = new genai.GoogleGenAI({
+      vertexai: true,
+      project: config.project,
+      location: config.location
+    });
+  }
+  async extractText(file, options) {
+    const prompt = this.buildTextPrompt(options);
+    const generationConfig = this.buildGenerationConfig(options?.modelConfig);
+    const response = await this.client.models.generateContent({
+      model: this.model,
+      contents: this.buildContents(file, prompt),
+      config: generationConfig
+    });
+    const tokens = this.extractTokenUsage(response);
+    return {
+      content: response.text || "",
+      tokens
+    };
+  }
+  async extractJson(file, schema, options) {
+    const prompt = this.buildJsonPrompt(schema, options);
+    const generationConfig = this.buildGenerationConfig(options?.modelConfig, {
+      responseMimeType: "application/json"
+    });
+    const response = await this.client.models.generateContent({
+      model: this.model,
+      contents: this.buildContents(file, prompt),
+      config: generationConfig
+    });
+    const text = response.text || "{}";
+    const tokens = this.extractTokenUsage(response);
+    return {
+      content: this.parseJsonResponse(text),
+      tokens
+    };
+  }
+  buildGenerationConfig(modelConfig, defaults) {
+    const config = { ...defaults };
+    if (modelConfig?.temperature !== void 0) {
+      config.temperature = modelConfig.temperature;
+    }
+    if (modelConfig?.maxTokens !== void 0) {
+      config.maxOutputTokens = modelConfig.maxTokens;
+    }
+    if (modelConfig?.topP !== void 0) {
+      config.topP = modelConfig.topP;
+    }
+    if (modelConfig?.topK !== void 0) {
+      config.topK = modelConfig.topK;
+    }
+    if (modelConfig?.stopSequences !== void 0) {
+      config.stopSequences = modelConfig.stopSequences;
+    }
+    return config;
+  }
+  extractTokenUsage(response) {
+    const usage = response.usageMetadata;
+    if (!usage) return void 0;
+    return {
+      inputTokens: usage.promptTokenCount || 0,
+      outputTokens: usage.candidatesTokenCount || 0,
+      totalTokens: usage.totalTokenCount || 0
+    };
+  }
+  buildContents(file, prompt) {
+    if (file.type === "text") {
+      return [
+        {
+          role: "user",
+          parts: [
+            { text: `${prompt}
+
+Document content:
+${file.content.toString("utf-8")}` }
+          ]
+        }
+      ];
+    }
+    const base64 = file.base64 || file.content.toString("base64");
+    return [
+      {
+        role: "user",
+        parts: [
+          {
+            inlineData: {
+              mimeType: file.mimeType,
+              data: base64
+            }
+          },
+          { text: prompt }
+        ]
+      }
+    ];
+  }
+};
+var MIME_TO_FILE_TYPE = {
+  "application/pdf": "pdf",
+  "image/jpeg": "image",
+  "image/png": "image",
+  "image/gif": "image",
+  "image/webp": "image",
+  "image/bmp": "image",
+  "image/tiff": "image",
+  "text/plain": "text",
+  "text/markdown": "text",
+  "text/csv": "text",
+  "application/json": "text",
+  "application/xml": "text",
+  "text/html": "text"
+};
+var MIME_TYPES = {
+  // PDF
+  ".pdf": "application/pdf",
+  // Images
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+  ".tiff": "image/tiff",
+  ".tif": "image/tiff",
+  // Text files
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".csv": "text/csv",
+  ".json": "application/json",
+  ".xml": "application/xml",
+  ".html": "text/html",
+  ".htm": "text/html"
+};
+var FILE_TYPE_CATEGORIES = {
+  ".pdf": "pdf",
+  ".jpg": "image",
+  ".jpeg": "image",
+  ".png": "image",
+  ".gif": "image",
+  ".webp": "image",
+  ".bmp": "image",
+  ".tiff": "image",
+  ".tif": "image",
+  ".txt": "text",
+  ".md": "text",
+  ".csv": "text",
+  ".json": "text",
+  ".xml": "text",
+  ".html": "text",
+  ".htm": "text"
+};
+async function loadFile(filePath) {
+  const absolutePath = path__namespace.resolve(filePath);
+  try {
+    await fs__namespace.access(absolutePath);
+  } catch {
+    throw new Error(`File not found: ${absolutePath}`);
+  }
+  const stats = await fs__namespace.stat(absolutePath);
+  if (!stats.isFile()) {
+    throw new Error(`Path is not a file: ${absolutePath}`);
+  }
+  const ext = path__namespace.extname(absolutePath).toLowerCase();
+  const fileName = path__namespace.basename(absolutePath);
+  const mimeType = MIME_TYPES[ext];
+  const fileType = FILE_TYPE_CATEGORIES[ext];
+  if (!mimeType || !fileType) {
+    throw new Error(
+      `Unsupported file type: ${ext}. Supported types: ${Object.keys(MIME_TYPES).join(", ")}`
+    );
+  }
+  const content = await fs__namespace.readFile(absolutePath);
+  const base64 = fileType !== "text" ? content.toString("base64") : void 0;
+  return {
+    path: absolutePath,
+    name: fileName,
+    type: fileType,
+    mimeType,
+    size: stats.size,
+    content,
+    base64
+  };
+}
+function loadFileFromBuffer(buffer, fileName, mimeType) {
+  const ext = path__namespace.extname(fileName).toLowerCase();
+  const detectedMimeType = mimeType || MIME_TYPES[ext];
+  const fileType = FILE_TYPE_CATEGORIES[ext];
+  if (!detectedMimeType || !fileType) {
+    throw new Error(
+      `Unsupported file type: ${ext}. Supported types: ${Object.keys(MIME_TYPES).join(", ")}`
+    );
+  }
+  const base64 = fileType !== "text" ? buffer.toString("base64") : void 0;
+  return {
+    path: "",
+    name: fileName,
+    type: fileType,
+    mimeType: detectedMimeType,
+    size: buffer.length,
+    content: buffer,
+    base64
+  };
+}
+function loadFileFromBase64(base64, fileName, mimeType) {
+  const base64Data = base64.includes(",") ? base64.split(",")[1] : base64;
+  const buffer = Buffer.from(base64Data, "base64");
+  const ext = path__namespace.extname(fileName).toLowerCase();
+  const detectedMimeType = mimeType || MIME_TYPES[ext];
+  const fileType = FILE_TYPE_CATEGORIES[ext];
+  if (!detectedMimeType || !fileType) {
+    throw new Error(
+      `Unsupported file type: ${ext}. Supported types: ${Object.keys(MIME_TYPES).join(", ")}`
+    );
+  }
+  return {
+    path: "",
+    name: fileName,
+    type: fileType,
+    mimeType: detectedMimeType,
+    size: buffer.length,
+    content: buffer,
+    base64: base64Data
+  };
+}
+async function saveToFile(filePath, content) {
+  const absolutePath = path__namespace.resolve(filePath);
+  const dir = path__namespace.dirname(absolutePath);
+  await fs__namespace.mkdir(dir, { recursive: true });
+  await fs__namespace.writeFile(absolutePath, content, typeof content === "string" ? "utf-8" : void 0);
+}
+function getSupportedExtensions() {
+  return Object.keys(MIME_TYPES);
+}
+function isExtensionSupported(ext) {
+  const normalizedExt = ext.startsWith(".") ? ext.toLowerCase() : `.${ext.toLowerCase()}`;
+  return normalizedExt in MIME_TYPES;
+}
+function isUrl(str) {
+  return str.startsWith("http://") || str.startsWith("https://");
+}
+async function loadFileFromUrl(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch URL: ${response.status} ${response.statusText}`);
+  }
+  const contentType = response.headers.get("content-type")?.split(";")[0] || "";
+  const buffer = Buffer.from(await response.arrayBuffer());
+  const contentDisposition = response.headers.get("content-disposition");
+  let fileName = "";
+  if (contentDisposition) {
+    const match = contentDisposition.match(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/);
+    if (match) {
+      fileName = match[1].replace(/['"]/g, "");
+    }
+  }
+  if (!fileName) {
+    const urlPath = new URL(url).pathname;
+    fileName = path__namespace.basename(urlPath) || "download";
+  }
+  let fileType = MIME_TO_FILE_TYPE[contentType];
+  let mimeType = contentType;
+  if (!fileType) {
+    const ext = path__namespace.extname(fileName).toLowerCase();
+    mimeType = MIME_TYPES[ext];
+    fileType = FILE_TYPE_CATEGORIES[ext];
+  }
+  if (!fileType || !mimeType) {
+    throw new Error(
+      `Unsupported file type from URL. Content-Type: ${contentType}, Filename: ${fileName}`
+    );
+  }
+  const base64 = fileType !== "text" ? buffer.toString("base64") : void 0;
+  return {
+    path: url,
+    name: fileName,
+    type: fileType,
+    mimeType,
+    size: buffer.length,
+    content: buffer,
+    base64
+  };
+}
+
+// src/extracta.ts
+var ExtractaAI = class {
+  provider;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.provider = this.createProvider(config);
+  }
+  /**
+   * Create a provider instance based on configuration
+   */
+  createProvider(config) {
+    switch (config.provider) {
+      case "gemini":
+        if (!config.apiKey) throw new Error("API key is required for Gemini provider");
+        return new GeminiProvider(config.apiKey, config.model);
+      case "openai":
+        if (!config.apiKey) throw new Error("API key is required for OpenAI provider");
+        return new OpenAIProvider(config.apiKey, config.model);
+      case "claude":
+        if (!config.apiKey) throw new Error("API key is required for Claude provider");
+        return new ClaudeProvider(config.apiKey, config.model);
+      case "grok":
+        if (!config.apiKey) throw new Error("API key is required for Grok provider");
+        return new GrokProvider(config.apiKey, config.model);
+      case "vertex":
+        if (!config.vertexConfig) throw new Error("vertexConfig is required for Vertex AI provider");
+        return new VertexProvider(config.vertexConfig, config.model);
+      default:
+        throw new Error(`Unsupported provider: ${config.provider}`);
+    }
+  }
+  /**
+   * Extract content from a file path or URL
+   */
+  async extract(source, options) {
+    const startTime = Date.now();
+    try {
+      const file = isUrl(source) ? await loadFileFromUrl(source) : await loadFile(source);
+      return this.processExtraction(file, options, startTime);
+    } catch (error) {
+      return this.createErrorResult(error);
+    }
+  }
+  /**
+   * Extract content from a Buffer
+   */
+  async extractFromBuffer(buffer, fileName, options) {
+    const startTime = Date.now();
+    try {
+      const file = loadFileFromBuffer(buffer, fileName);
+      return this.processExtraction(file, options, startTime);
+    } catch (error) {
+      return this.createErrorResult(error);
+    }
+  }
+  /**
+   * Extract content from a base64 string
+   */
+  async extractFromBase64(base64, fileName, options) {
+    const startTime = Date.now();
+    try {
+      const file = loadFileFromBase64(base64, fileName);
+      return this.processExtraction(file, options, startTime);
+    } catch (error) {
+      return this.createErrorResult(error);
+    }
+  }
+  /**
+   * Process the extraction based on format
+   */
+  async processExtraction(file, options, startTime) {
+    const format = options?.format || "text";
+    if (!this.provider.supportsFileType(file.type)) {
+      return {
+        success: false,
+        error: `Provider ${this.provider.name} does not support file type: ${file.type}`,
+        code: "UNSUPPORTED_FILE_TYPE"
+      };
+    }
+    try {
+      if (format === "json") {
+        if (!options?.schema) {
+          return {
+            success: false,
+            error: "Schema is required for JSON extraction",
+            code: "MISSING_SCHEMA"
+          };
+        }
+        const providerResult = await this.provider.extractJson(file, options.schema, options);
+        const result = {
+          success: true,
+          format: "json",
+          data: providerResult.content,
+          metadata: {
+            provider: this.provider.name,
+            model: this.provider.model,
+            fileType: file.type,
+            fileName: file.name,
+            processingTimeMs: Date.now() - startTime,
+            tokens: providerResult.tokens
+          }
+        };
+        if (options.outputPath) {
+          await saveToFile(options.outputPath, JSON.stringify(providerResult.content, null, 2));
+        }
+        return result;
+      } else {
+        const providerResult = await this.provider.extractText(file, options);
+        const result = {
+          success: true,
+          format: "text",
+          content: providerResult.content,
+          metadata: {
+            provider: this.provider.name,
+            model: this.provider.model,
+            fileType: file.type,
+            fileName: file.name,
+            processingTimeMs: Date.now() - startTime,
+            tokens: providerResult.tokens
+          }
+        };
+        if (options?.outputPath) {
+          await saveToFile(options.outputPath, providerResult.content);
+        }
+        return result;
+      }
+    } catch (error) {
+      return this.createErrorResult(error);
+    }
+  }
+  /**
+   * Create an error result
+   */
+  createErrorResult(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: message,
+      code: "EXTRACTION_ERROR"
+    };
+  }
+  /**
+   * Get current provider name
+   */
+  getProvider() {
+    return this.provider.name;
+  }
+  /**
+   * Get current model
+   */
+  getModel() {
+    return this.provider.model;
+  }
+  /**
+   * Change the AI provider
+   */
+  setProvider(provider, apiKey, model) {
+    this.config = { provider, apiKey, model };
+    this.provider = this.createProvider(this.config);
+  }
+};
+function createExtractaAI(config) {
+  return new ExtractaAI(config);
+}
+
+exports.BaseProvider = BaseProvider;
+exports.ClaudeProvider = ClaudeProvider;
+exports.ExtractaAI = ExtractaAI;
+exports.GeminiProvider = GeminiProvider;
+exports.GrokProvider = GrokProvider;
+exports.OpenAIProvider = OpenAIProvider;
+exports.VertexProvider = VertexProvider;
+exports.createExtractaAI = createExtractaAI;
+exports.getSupportedExtensions = getSupportedExtensions;
+exports.isExtensionSupported = isExtensionSupported;
+exports.isUrl = isUrl;
+exports.loadFile = loadFile;
+exports.loadFileFromBase64 = loadFileFromBase64;
+exports.loadFileFromBuffer = loadFileFromBuffer;
+exports.loadFileFromUrl = loadFileFromUrl;
+exports.saveToFile = saveToFile;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map