@doclo/providers-llm 0.1.7 → 0.1.9

package/dist/index.js

@@ -1,3 +1,16 @@
+import {
+  buildBlockClassificationPrompt,
+  buildConfidencePrompt,
+  buildLLMDerivedFeaturesPrompt,
+  buildLanguageHintsPrompt,
+  buildOutputFormatPrompt,
+  buildSchemaPromptSection,
+  buildSourcesPrompt,
+  combineSchemaAndUserPrompt,
+  combineSchemaUserAndDerivedPrompts,
+  formatSchemaForPrompt
+} from "./chunk-7YPJIWRM.js";
+
 // src/schema-translator.ts
 import { zodToJsonSchema } from "@alcyone-labs/zod-to-json-schema";
 var SchemaTranslator = class {
@@ -165,119 +178,72 @@ var SchemaTranslator = class {
   }
 };
 
-// src/schema-prompt-formatter.ts
-function formatSchemaForPrompt(schema, indent = 0) {
-  if (!schema || typeof schema !== "object") {
-    return "";
-  }
-  const indentStr = "  ".repeat(indent);
-  let result = "";
-  if (schema.type === "object" && schema.properties) {
-    const properties = schema.properties;
-    const required = schema.required || [];
-    for (const [fieldName, fieldSchema] of Object.entries(properties)) {
-      const isRequired = required.includes(fieldName);
-      const requiredMarker = isRequired ? " (REQUIRED)" : " (optional)";
-      result += `${indentStr}- \`${fieldName}\`${requiredMarker}`;
-      const type = getTypeDescription(fieldSchema);
-      if (type) {
-        result += `: ${type}`;
-      }
-      if (fieldSchema.description) {
-        result += `
-${indentStr}  ${fieldSchema.description}`;
-      }
-      if (fieldSchema.enum) {
-        result += `
-${indentStr}  Allowed values: ${fieldSchema.enum.map((v) => JSON.stringify(v)).join(", ")}`;
-      }
-      result += "\n";
-      if (fieldSchema.type === "object" && fieldSchema.properties) {
-        result += formatSchemaForPrompt(fieldSchema, indent + 1);
-      }
-      if (fieldSchema.type === "array" && fieldSchema.items) {
-        result += `${indentStr}  Array items:
-`;
-        const itemSchema = Array.isArray(fieldSchema.items) ? fieldSchema.items[0] : fieldSchema.items;
-        if (itemSchema && itemSchema.type === "object" && itemSchema.properties) {
-          result += formatSchemaForPrompt(itemSchema, indent + 2);
-        } else if (itemSchema) {
-          const itemType = getTypeDescription(itemSchema);
-          result += `${indentStr}    ${itemType}
-`;
-        }
-      }
+// src/metadata-extractor.ts
+var METADATA_FIELDS = [
+  "_confidence",
+  "_sources",
+  "_blockTypes",
+  "_headers",
+  "_footers"
+];
+function extractMetadataFromResponse(json) {
+  if (!json || typeof json !== "object") {
+    return { json };
+  }
+  const rawJson = json;
+  const metadata = {};
+  let hasMetadata = false;
+  if ("_confidence" in rawJson && rawJson._confidence) {
+    const confidence = rawJson._confidence;
+    if (typeof confidence === "object" && !Array.isArray(confidence)) {
+      metadata.confidence = confidence;
+      hasMetadata = true;
     }
   }
-  return result;
-}
-function getTypeDescription(schema) {
-  if (!schema) return "any";
-  if (schema.type) {
-    const typeStr = Array.isArray(schema.type) ? schema.type.join(" | ") : schema.type;
-    if (typeStr === "array" || Array.isArray(schema.type) && schema.type.includes("array")) {
-      if (schema.items && !Array.isArray(schema.items) && schema.items.type) {
-        const itemType = Array.isArray(schema.items.type) ? schema.items.type.join(" | ") : schema.items.type;
-        return `array of ${itemType}`;
-      }
-      return "array";
-    }
-    if ((typeStr === "string" || Array.isArray(schema.type) && schema.type.includes("string")) && schema.format) {
-      const formatHints = {
-        "date": "YYYY-MM-DD",
-        "time": "HH:MM or HH:MM:SS",
-        "date-time": "YYYY-MM-DDTHH:MM:SS (ISO 8601)"
-      };
-      const hint = formatHints[schema.format];
-      if (hint) {
-        return `string (format: ${schema.format}, use ${hint})`;
-      }
-      return `string (format: ${schema.format})`;
+  if ("_sources" in rawJson && Array.isArray(rawJson._sources)) {
+    metadata.sources = rawJson._sources.map((source) => ({
+      field: source.field || source.fieldPath || "",
+      text: source.text || source.sourceText || "",
+      bbox: source.bbox || source.box_2d,
+      page: source.page
+    }));
+    hasMetadata = true;
+  }
+  if ("_blockTypes" in rawJson && rawJson._blockTypes) {
+    const blockTypes = rawJson._blockTypes;
+    if (typeof blockTypes === "object" && !Array.isArray(blockTypes)) {
+      metadata.blockTypes = blockTypes;
+      hasMetadata = true;
     }
-    return typeStr;
   }
-  if (schema.anyOf) {
-    return schema.anyOf.map((s) => getTypeDescription(s)).join(" OR ");
+  if ("_headers" in rawJson && Array.isArray(rawJson._headers)) {
+    metadata.headers = rawJson._headers.map((header) => ({
+      text: header.text || "",
+      pages: Array.isArray(header.pages) ? header.pages : []
+    }));
+    hasMetadata = true;
   }
-  if (schema.oneOf) {
-    return schema.oneOf.map((s) => getTypeDescription(s)).join(" OR ");
+  if ("_footers" in rawJson && Array.isArray(rawJson._footers)) {
+    metadata.footers = rawJson._footers.map((footer) => ({
+      text: footer.text || "",
+      pages: Array.isArray(footer.pages) ? footer.pages : []
+    }));
+    hasMetadata = true;
   }
-  return "any";
-}
-function buildSchemaPromptSection(schema) {
-  const schemaFields = formatSchemaForPrompt(schema);
-  return `
-==================================================
-CRITICAL: OUTPUT STRUCTURE REQUIREMENTS
-==================================================
-
-YOU MUST RETURN JSON MATCHING THIS EXACT STRUCTURE:
-
-${schemaFields}
-
-CRITICAL FIELD NAME REQUIREMENTS:
-\u2713 Use EXACTLY the field names shown above (character-for-character match)
-\u2713 Preserve the exact casing (e.g., "fullName", not "full_name" or "FullName")
-\u2713 Do NOT abbreviate field names (e.g., "dob" instead of "dateOfBirth")
-\u2713 Do NOT invent alternative names (e.g., "directorName" instead of "fullName")
-\u2713 Do NOT use snake_case if the schema uses camelCase
-\u2713 Do NOT flatten nested structures or rename nested fields
-\u2713 The schema above is the SINGLE SOURCE OF TRUTH for field naming
-
-MISSING DATA:
-- If a required field has no data in the document, use null
-- If an optional field has no data, you may omit it or use null
-- Do NOT invent data that isn't in the document
-
-==================================================
-`.trim();
-}
-function combineSchemaAndUserPrompt(schema, userPrompt) {
-  const schemaSection = buildSchemaPromptSection(schema);
-  if (!userPrompt || userPrompt.trim() === "") {
-    return schemaSection + "\n\nTASK: Extract structured data from the provided document.";
+  const cleanJson = {};
+  for (const [key, value] of Object.entries(rawJson)) {
+    if (!METADATA_FIELDS.includes(key)) {
+      cleanJson[key] = value;
+    }
   }
-  return schemaSection + "\n\n" + userPrompt;
+  return {
+    json: cleanJson,
+    metadata: hasMetadata ? metadata : void 0
+  };
+}
+function shouldExtractMetadata(derivedOptions) {
+  if (!derivedOptions) return false;
+  return !!(derivedOptions.includeConfidence || derivedOptions.includeSources || derivedOptions.includeBlockTypes || derivedOptions.extractHeaders || derivedOptions.extractFooters);
 }
 
 // src/provider-registry.ts
@@ -377,22 +343,41 @@ var OpenAIProvider = class {
   }
   async completeJson(params) {
     const startTime = Date.now();
+    const rawInput = params.input ?? params.prompt;
+    if (!rawInput) {
+      throw new Error("Either input or prompt must be provided");
+    }
+    const normalizedInput = typeof rawInput === "string" ? { text: rawInput } : rawInput;
     const mode = params.mode || (params.schema ? "strict" : "relaxed");
     if (mode === "strict" && !params.schema) {
       throw new Error('schema is required when mode is "strict"');
     }
+    const extractMetadata = shouldExtractMetadata(params.derivedOptions);
     const shouldEmbedSchema = params.embedSchemaInPrompt !== false && params.schema;
-    let enhancedInput = params.input;
+    let enhancedInput = normalizedInput;
     if (shouldEmbedSchema) {
       const jsonSchema = this.translator.convertZodIfNeeded(params.schema);
-      const enhancedText = combineSchemaAndUserPrompt(
+      const enhancedText = params.derivedOptions ? combineSchemaUserAndDerivedPrompts(
         jsonSchema,
-        params.input.text || ""
+        normalizedInput.text || "",
+        params.derivedOptions
+      ) : combineSchemaAndUserPrompt(
+        jsonSchema,
+        normalizedInput.text || ""
       );
       enhancedInput = {
-        ...params.input,
+        ...normalizedInput,
         text: enhancedText
       };
+    } else if (params.derivedOptions) {
+      const { buildLLMDerivedFeaturesPrompt: buildLLMDerivedFeaturesPrompt2 } = await import("./schema-prompt-formatter-AIORLWUF.js");
+      const derivedPrompt = buildLLMDerivedFeaturesPrompt2(params.derivedOptions);
+      if (derivedPrompt) {
+        enhancedInput = {
+          ...normalizedInput,
+          text: (normalizedInput.text || "") + "\n\n" + derivedPrompt
+        };
+      }
     }
     const messages = this.buildMessages(enhancedInput);
     const requestBody = {
@@ -473,7 +458,8 @@ var OpenAIProvider = class {
     const data = await response.json();
     const latencyMs = Date.now() - startTime;
     const content = data.choices?.[0]?.message?.content ?? "{}";
-    const parsed = safeJsonParse(content);
+    const rawParsed = safeJsonParse(content);
+    const { json: parsed, metadata } = extractMetadata ? extractMetadataFromResponse(rawParsed) : { json: rawParsed, metadata: void 0 };
     const message = data.choices?.[0]?.message;
     const reasoning = message?.reasoning;
     const reasoning_details = message?.reasoning_details;
@@ -498,7 +484,8 @@ var OpenAIProvider = class {
         model: this.config.model
       },
       reasoning,
-      reasoning_details
+      reasoning_details,
+      metadata
     };
   }
   buildReasoningConfig(reasoning) {
@@ -614,22 +601,41 @@ var AnthropicProvider = class {
   }
   async completeJson(params) {
     const startTime = Date.now();
+    const rawInput = params.input ?? params.prompt;
+    if (!rawInput) {
+      throw new Error("Either input or prompt must be provided");
+    }
+    const normalizedInput = typeof rawInput === "string" ? { text: rawInput } : rawInput;
     const mode = params.mode || (params.schema ? "strict" : "relaxed");
     if (mode === "strict" && !params.schema) {
       throw new Error('schema is required when mode is "strict"');
     }
+    const extractMetadata = shouldExtractMetadata(params.derivedOptions);
     const shouldEmbedSchema = params.embedSchemaInPrompt !== false && params.schema;
-    let enhancedInput = params.input;
+    let enhancedInput = normalizedInput;
     if (shouldEmbedSchema) {
       const jsonSchema = this.translator.convertZodIfNeeded(params.schema);
-      const enhancedText = combineSchemaAndUserPrompt(
+      const enhancedText = params.derivedOptions ? combineSchemaUserAndDerivedPrompts(
         jsonSchema,
-        params.input.text || ""
+        normalizedInput.text || "",
+        params.derivedOptions
+      ) : combineSchemaAndUserPrompt(
+        jsonSchema,
+        normalizedInput.text || ""
       );
       enhancedInput = {
-        ...params.input,
+        ...normalizedInput,
         text: enhancedText
       };
+    } else if (params.derivedOptions) {
+      const { buildLLMDerivedFeaturesPrompt: buildLLMDerivedFeaturesPrompt2 } = await import("./schema-prompt-formatter-AIORLWUF.js");
+      const derivedPrompt = buildLLMDerivedFeaturesPrompt2(params.derivedOptions);
+      if (derivedPrompt) {
+        enhancedInput = {
+          ...normalizedInput,
+          text: (normalizedInput.text || "") + "\n\n" + derivedPrompt
+        };
+      }
     }
     const messages = await this.buildMessages(enhancedInput);
     const useNewStructuredOutputs = this.supportsNewStructuredOutputs();
@@ -703,10 +709,7 @@ var AnthropicProvider = class {
       }
       const data = await response.json();
       const message = data.choices?.[0]?.message;
-      let content = message?.content ?? (useNewStructuredOutputs2 ? "{}" : "}");
-      if (!useNewStructuredOutputs2) {
-        content = "{" + content;
-      }
+      let content = message?.content ?? "{}";
       const reasoning = message?.reasoning;
       const reasoning_details = message?.reasoning_details;
       content = content.replace(/^```json\s*\n?/, "").replace(/\n?```\s*$/, "").trim();
@@ -747,9 +750,10 @@ var AnthropicProvider = class {
       }
       const latencyMs = Date.now() - startTime;
       const baseProvider = extractProviderFromModel2(this.config.model, "anthropic");
+      const { json: cleanJson, metadata } = extractMetadata ? extractMetadataFromResponse(parsed) : { json: parsed, metadata: void 0 };
       return {
-        json: parsed,
-        rawText: JSON.stringify(parsed),
+        json: cleanJson,
+        rawText: JSON.stringify(cleanJson),
         metrics: {
           costUSD,
           inputTokens,
@@ -763,7 +767,8 @@ var AnthropicProvider = class {
           cacheReadInputTokens
         },
         reasoning,
-        reasoning_details
+        reasoning_details,
+        metadata
       };
     } else {
       const endpoint = this.config.baseUrl || "https://api.anthropic.com/v1";
@@ -828,9 +833,10 @@ var AnthropicProvider = class {
       const reasoning = thinkingBlock?.thinking;
       const latencyMs = Date.now() - startTime;
       const baseProvider = extractProviderFromModel2(this.config.model, "anthropic");
+      const { json: cleanJson, metadata } = extractMetadata ? extractMetadataFromResponse(parsed) : { json: parsed, metadata: void 0 };
       return {
-        json: parsed,
-        rawText: JSON.stringify(parsed),
+        json: cleanJson,
+        rawText: JSON.stringify(cleanJson),
         metrics: {
           costUSD,
           inputTokens,
@@ -848,7 +854,8 @@ var AnthropicProvider = class {
           signature: null,
           id: "thinking-1",
           format: "anthropic-claude-v1"
-        }] : void 0
+        }] : void 0,
+        metadata
       };
     }
   }
@@ -885,19 +892,13 @@ var AnthropicProvider = class {
       requestBody.response_format = {
         type: "json_object"
       };
-    } else {
+    } else if (useNewStructuredOutputs) {
       const openRouterSchema = this.translator.toClaudeOpenRouterSchema(schema);
       const fixedSchema = this.fixSchemaForStrictMode(openRouterSchema);
       if (process.env.DEBUG_PROVIDERS) {
-        console.log("[AnthropicProvider] Original schema:", JSON.stringify(openRouterSchema, null, 2));
+        console.log("[AnthropicProvider] Using json_schema (native support)");
         console.log("[AnthropicProvider] Fixed schema:", JSON.stringify(fixedSchema, null, 2));
       }
-      if (!useNewStructuredOutputs) {
-        messageArray.push({
-          role: "assistant",
-          content: "{"
-        });
-      }
       requestBody.response_format = {
         type: "json_schema",
         json_schema: {
@@ -906,6 +907,13 @@ var AnthropicProvider = class {
           schema: fixedSchema
         }
       };
+    } else {
+      if (process.env.DEBUG_PROVIDERS) {
+        console.log("[AnthropicProvider] Using json_object (legacy mode, schema in prompt)");
+      }
+      requestBody.response_format = {
+        type: "json_object"
+      };
     }
     if (reasoning) {
       requestBody.reasoning = this.buildReasoningConfig(reasoning, max_tokens);
@@ -1248,11 +1256,16 @@ var GoogleProvider = class {
     if (mode === "strict" && !params.schema) {
       throw new Error('schema is required when mode is "strict"');
     }
+    const extractMetadata = shouldExtractMetadata(params.derivedOptions);
     const shouldEmbedSchema = params.embedSchemaInPrompt !== false && params.schema;
     let enhancedInput = normalizedInput;
     if (shouldEmbedSchema) {
       const jsonSchema = this.translator.convertZodIfNeeded(params.schema);
-      const enhancedText = combineSchemaAndUserPrompt(
+      const enhancedText = params.derivedOptions ? combineSchemaUserAndDerivedPrompts(
+        jsonSchema,
+        normalizedInput.text || "",
+        params.derivedOptions
+      ) : combineSchemaAndUserPrompt(
         jsonSchema,
         normalizedInput.text || ""
       );
@@ -1260,6 +1273,15 @@ var GoogleProvider = class {
         ...normalizedInput,
         text: enhancedText
       };
+    } else if (params.derivedOptions) {
+      const { buildLLMDerivedFeaturesPrompt: buildLLMDerivedFeaturesPrompt2 } = await import("./schema-prompt-formatter-AIORLWUF.js");
+      const derivedPrompt = buildLLMDerivedFeaturesPrompt2(params.derivedOptions);
+      if (derivedPrompt) {
+        enhancedInput = {
+          ...normalizedInput,
+          text: (normalizedInput.text || "") + "\n\n" + derivedPrompt
+        };
+      }
     }
     const contents = await this.buildContents(enhancedInput);
     const requestBody = {
@@ -1328,7 +1350,8 @@ var GoogleProvider = class {
       const reasoning = message?.reasoning;
       const reasoning_details = message?.reasoning_details;
       content = content.replace(/^```json\s*\n?/, "").replace(/\n?```\s*$/, "").trim();
-      const parsed = safeJsonParse3(content);
+      const rawParsed = safeJsonParse3(content);
+      const { json: parsed, metadata } = extractMetadata ? extractMetadataFromResponse(rawParsed) : { json: rawParsed, metadata: void 0 };
       const baseProvider = extractProviderFromModel3(this.config.model, "google");
       return {
         json: parsed,
@@ -1344,7 +1367,8 @@ var GoogleProvider = class {
           model: this.config.model
         },
         reasoning,
-        reasoning_details
+        reasoning_details,
+        metadata
       };
     } else {
       const candidate = data.candidates?.[0];
@@ -1354,7 +1378,8 @@ var GoogleProvider = class {
       costUSD = this.calculateCost(data.usageMetadata);
       const thinkingPart = candidate?.content?.parts?.find((part) => part.thought === true);
       const reasoning = thinkingPart?.text;
-      const parsed = safeJsonParse3(content);
+      const rawParsed = safeJsonParse3(content);
+      const { json: parsed, metadata } = extractMetadata ? extractMetadataFromResponse(rawParsed) : { json: rawParsed, metadata: void 0 };
       const baseProvider = extractProviderFromModel3(this.config.model, "google");
       return {
         json: parsed,
@@ -1376,7 +1401,8 @@ var GoogleProvider = class {
           signature: null,
           id: "thinking-1",
           format: "google-gemini-v1"
-        }] : void 0
+        }] : void 0,
+        metadata
       };
     }
   }
@@ -1580,22 +1606,41 @@ var XAIProvider = class {
   }
   async completeJson(params) {
     const startTime = Date.now();
+    const rawInput = params.input ?? params.prompt;
+    if (!rawInput) {
+      throw new Error("Either input or prompt must be provided");
+    }
+    const normalizedInput = typeof rawInput === "string" ? { text: rawInput } : rawInput;
     const mode = params.mode || (params.schema ? "strict" : "relaxed");
     if (mode === "strict" && !params.schema) {
       throw new Error('schema is required when mode is "strict"');
     }
+    const extractMetadata = shouldExtractMetadata(params.derivedOptions);
     const shouldEmbedSchema = params.embedSchemaInPrompt !== false && params.schema;
-    let enhancedInput = params.input;
+    let enhancedInput = normalizedInput;
     if (shouldEmbedSchema) {
       const jsonSchema = this.translator.convertZodIfNeeded(params.schema);
-      const enhancedText = combineSchemaAndUserPrompt(
+      const enhancedText = params.derivedOptions ? combineSchemaUserAndDerivedPrompts(
         jsonSchema,
-        params.input.text || ""
+        normalizedInput.text || "",
+        params.derivedOptions
+      ) : combineSchemaAndUserPrompt(
+        jsonSchema,
+        normalizedInput.text || ""
       );
       enhancedInput = {
-        ...params.input,
+        ...normalizedInput,
         text: enhancedText
       };
+    } else if (params.derivedOptions) {
+      const { buildLLMDerivedFeaturesPrompt: buildLLMDerivedFeaturesPrompt2 } = await import("./schema-prompt-formatter-AIORLWUF.js");
+      const derivedPrompt = buildLLMDerivedFeaturesPrompt2(params.derivedOptions);
+      if (derivedPrompt) {
+        enhancedInput = {
+          ...normalizedInput,
+          text: (normalizedInput.text || "") + "\n\n" + derivedPrompt
+        };
+      }
     }
     const messages = await this.buildMessages(enhancedInput);
     const requestBody = {
@@ -1676,7 +1721,8 @@ var XAIProvider = class {
     const latencyMs = Date.now() - startTime;
     const message = data.choices?.[0]?.message;
     const content = message?.content ?? "{}";
-    const parsed = safeJsonParse4(content);
+    const rawParsed = safeJsonParse4(content);
+    const { json: parsed, metadata } = extractMetadata ? extractMetadataFromResponse(rawParsed) : { json: rawParsed, metadata: void 0 };
     const reasoning = message?.reasoning;
     const reasoning_details = message?.reasoning_details;
     let costUSD;
@@ -1700,7 +1746,8 @@ var XAIProvider = class {
         model: this.config.model
       },
       reasoning,
-      reasoning_details
+      reasoning_details,
+      metadata
     };
   }
   buildReasoningConfig(reasoning) {
@@ -2032,6 +2079,115 @@ function adaptToCoreLLMProvider(provider) {
   };
 }
 
+// src/gemini-bbox-schema.ts
+var BLOCK_TYPES = [
+  "title",
+  // Main document title or section headers
+  "paragraph",
+  // Body text paragraphs
+  "table",
+  // Tabular data
+  "list",
+  // Bulleted or numbered lists
+  "header",
+  // Page headers (repeated at top of pages)
+  "footer",
+  // Page footers (repeated at bottom of pages)
+  "caption",
+  // Image or figure captions
+  "code",
+  // Code blocks or preformatted text
+  "image",
+  // Image/figure placeholder
+  "form",
+  // Form fields
+  "signature",
+  // Signatures
+  "handwriting"
+  // Handwritten text
+];
+var geminiBoundingBoxSchema = {
+  type: "array",
+  items: {
+    type: "object",
+    properties: {
+      box_2d: {
+        type: "array",
+        items: { type: "number" },
+        minItems: 4,
+        maxItems: 4,
+        description: "Bounding box coordinates [y_min, x_min, y_max, x_max] normalized 0-1000"
+      },
+      text: {
+        type: "string",
+        description: "Text content within the bounding box"
+      },
+      type: {
+        type: "string",
+        enum: [...BLOCK_TYPES],
+        description: "Block type classification"
+      },
+      confidence: {
+        type: "string",
+        enum: ["high", "medium", "low"],
+        nullable: true,
+        description: "Confidence level of extraction"
+      },
+      page: {
+        type: "integer",
+        nullable: true,
+        description: "Page number (0-indexed)"
+      }
+    },
+    required: ["box_2d", "text", "type"],
+    additionalProperties: false
+  }
+};
+var GEMINI_BBOX_EXTRACTION_PROMPT = `Analyze this document and extract all text with precise bounding box locations.
+
+For each text block, provide:
+- box_2d: Bounding box as [y_min, x_min, y_max, x_max] normalized to 0-1000
+- text: The exact text content
+- type: Block classification (title, paragraph, table, list, header, footer, caption, code, image, form, signature, handwriting)
+- confidence: Your confidence level (high, medium, low)
+- page: Page number (0-indexed) for multi-page documents
+
+IMPORTANT coordinate format:
+- Use [y_min, x_min, y_max, x_max] order (Y coordinate first, then X)
+- Normalize all values to 0-1000 range (top-left is [0, 0], bottom-right is [1000, 1000])
+
+Return ONLY a valid JSON array, no other text.`;
+function normalizeGeminiBBox(geminiBBox) {
+  const [yMin, xMin, yMax, xMax] = geminiBBox;
+  return {
+    x: xMin / 1e3,
+    y: yMin / 1e3,
+    width: (xMax - xMin) / 1e3,
+    height: (yMax - yMin) / 1e3
+  };
+}
+function toGeminiBBox(bbox) {
+  return [
+    Math.round(bbox.y * 1e3),
+    // y_min
+    Math.round(bbox.x * 1e3),
+    // x_min
+    Math.round((bbox.y + bbox.height) * 1e3),
+    // y_max
+    Math.round((bbox.x + bbox.width) * 1e3)
+    // x_max
+  ];
+}
+function convertGeminiBlocksToDocumentBlocks(geminiBlocks) {
+  return geminiBlocks.map((block) => ({
+    text: block.text,
+    bbox: normalizeGeminiBBox(block.box_2d),
+    type: block.type,
+    confidence: block.confidence === "high" ? 0.9 : block.confidence === "medium" ? 0.7 : block.confidence === "low" ? 0.5 : void 0,
+    page: block.page
+  }));
+}
+
 // src/metadata.ts
 var SUPPORTED_IMAGE_TYPES = {
   COMMON: ["image/png", "image/jpeg", "image/webp", "image/gif"],
@@ -2703,7 +2859,9 @@ function buildLLMProvider(config) {
 }
 export {
   AnthropicProvider,
+  BLOCK_TYPES,
   FallbackManager,
+  GEMINI_BBOX_EXTRACTION_PROMPT,
   GoogleProvider,
   OpenAIProvider,
   PROVIDER_METADATA,
@@ -2711,20 +2869,33 @@ export {
   SchemaTranslator,
   XAIProvider,
   adaptToCoreLLMProvider,
+  buildBlockClassificationPrompt,
+  buildConfidencePrompt,
+  buildLLMDerivedFeaturesPrompt,
   buildLLMProvider,
+  buildLanguageHintsPrompt,
+  buildOutputFormatPrompt,
   buildSchemaPromptSection,
+  buildSourcesPrompt,
   combineSchemaAndUserPrompt,
+  combineSchemaUserAndDerivedPrompts,
   compareNativeVsOpenRouter,
+  convertGeminiBlocksToDocumentBlocks,
   createProviderFromRegistry,
   createVLMProvider,
   estimateCost,
+  extractMetadataFromResponse,
   formatSchemaForPrompt,
+  geminiBoundingBoxSchema,
   getCheapestProvider,
   getProvidersForNode,
   isImageTypeSupported,
   isProviderCompatibleWithNode,
+  normalizeGeminiBBox,
   providerRegistry,
   registerProvider,
-  supportsPDFsInline
+  shouldExtractMetadata,
+  supportsPDFsInline,
+  toGeminiBBox
 };
 //# sourceMappingURL=index.js.map