parsefy 1.0.0 → 1.0.2

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Parsefy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,403 @@
+<p align="center">
+  <img src="/assets/logo.png" alt="Parsefy Logo" width="120" />
+</p>
+
+<h1 align="center">Parsefy TypeScript / JavaScript SDK</h1>
+
+<p align="center">
+  <strong>Official TypeScript / JavaScript SDK for Parsefy - Financial Document Infrastructure for Developers</strong><br>
+  
+Turn financial PDFs (invoices, receipts, bills) into structured JSON with validation and risk signals.
+</p>
+
+---
+
+## Installation
+
+```bash
+npm install parsefy zod
+```
+
+## Quick Start
+
+```typescript
+import { Parsefy } from 'parsefy';
+import * as z from 'zod';
+
+const client = new Parsefy('pk_your_api_key');
+
+const schema = z.object({
+  // REQUIRED - triggers fallback if below confidence threshold
+  invoice_number: z.string().describe('The invoice number'),
+  total: z.number().describe('Total amount including tax'),
+
+  // OPTIONAL - won't trigger fallback if missing or low confidence
+  vendor: z.string().optional().describe('Vendor name'),
+  due_date: z.string().optional().describe('Payment due date'),
+});
+
+const { object, metadata, error } = await client.extract({
+  file: './invoice.pdf',
+  schema,
+});
+
+if (!error && object) {
+  console.log(object.invoice_number); // Fully typed!
+
+  // Access field-level confidence and evidence
+  console.log(`Overall confidence: ${metadata.confidenceScore}`);
+  metadata.fieldConfidence.forEach((fc) => {
+    console.log(`${fc.field}: ${fc.score} (${fc.reason}) - "${fc.text}"`);
+  });
+}
+```
+
+## ⚠️ Required vs Optional Fields (Important for Billing)
+
+**All fields are required by default.** This is critical to understand:
+
+| User writes (SDK) | SDK converts to (JSON Schema) | API interprets as |
+|-------------------|-------------------------------|-------------------|
+| `name: z.string()` | `required: ["name"]` | **Required** |
+| `name: z.string().optional()` | `required: []` | **Optional** |
+
+### Why This Matters
+
+If a **required** field returns `null` or falls below the `confidenceThreshold`, the API triggers the **fallback model** (Tier 2), which is more expensive.
+
+**To avoid unexpected high billing:**
+
+```typescript
+const schema = z.object({
+  // REQUIRED - Always present on invoices, keep required
+  invoice_number: z.string(),
+  total: z.number(),
+
+  // OPTIONAL - May not appear on all documents, mark optional!
+  vendor: z.string().optional(),      // Not all invoices have vendor name
+  tax_id: z.string().optional(),      // Rarely present
+  notes: z.string().optional(),       // Usually empty
+  due_date: z.string().optional(),    // Sometimes missing
+});
+```
+
+**Rule of thumb:** If a field might be missing in >20% of your documents, mark it `.optional()`.
+
+## Confidence Threshold
+
+Control when the fallback model is triggered:
+
+```typescript
+const { object, metadata } = await client.extract({
+  file: './invoice.pdf',
+  schema,
+  confidenceThreshold: 0.85, // default
+});
+```
+
+| Threshold | Behavior |
+|-----------|----------|
+| Lower (e.g., 0.70) | **Faster** – Accepts Tier 1 results more often |
+| Higher (e.g., 0.95) | **More accurate** – Triggers Tier 2 fallback more often |
+
+**Default:** `0.85`
+
+## Response Format
+
+```typescript
+interface ExtractResult<T> {
+  // Extracted data matching your schema, or null if extraction failed
+  object: T | null;
+
+  // Metadata about the extraction
+  metadata: {
+    processingTimeMs: number;     // Processing time in milliseconds
+    inputTokens: number;          // Input tokens used
+    outputTokens: number;         // Output tokens generated
+    credits: number;              // Credits consumed (1 credit = 1 page)
+    fallbackTriggered: boolean;   // Whether fallback model was used
+
+    // 🆕 Field-level confidence and evidence
+    confidenceScore: number;      // Overall confidence (0.0 to 1.0)
+    fieldConfidence: Array<{
+      field: string;              // JSON path (e.g., "$.invoice_number")
+      score: number;              // Confidence score (0.0 to 1.0)
+      reason: string;             // "Exact match", "Inferred from header", etc.
+      page: number;               // Page number where found
+      text: string;               // Source text evidence
+    }>;
+    issues: string[];             // Warnings or anomalies detected
+  };
+
+  // Error details if extraction failed
+  error: {
+    code: string;
+    message: string;
+  } | null;
+}
+```
+
+### Example Response
+
+```typescript
+const { object, metadata } = await client.extract({ file, schema });
+
+// object:
+{
+  invoice_number: "INV-2024-0042",
+  date: "2024-01-15",
+  total: 1250.00,
+  vendor: "Acme Corp"
+}
+
+// metadata.confidenceScore: 0.94
+
+// metadata.fieldConfidence:
+[
+  { field: "$.invoice_number", score: 0.98, reason: "Exact match", page: 1, text: "Invoice # INV-2024-0042" },
+  { field: "$.date", score: 0.95, reason: "Exact match", page: 1, text: "Date: 01/15/2024" },
+  { field: "$.total", score: 0.92, reason: "Formatting ambiguous", page: 1, text: "Total: $1,250.00" },
+  { field: "$.vendor", score: 0.90, reason: "Inferred from header", page: 1, text: "Acme Corp" }
+]
+
+// metadata.issues: []
+```
+
+## Configuration
+
+### API Key
+
+```typescript
+// Option 1: Pass API key directly
+const client = new Parsefy('pk_your_api_key');
+
+// Option 2: Use environment variable
+// Set PARSEFY_API_KEY in your environment
+const client = new Parsefy();
+
+// Option 3: Configuration object
+const client = new Parsefy({
+  apiKey: 'pk_your_api_key',
+  timeout: 120000, // 2 minutes
+});
+```
+
+### Configuration Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `apiKey` | `string` | `process.env.PARSEFY_API_KEY` | Your Parsefy API key |
+| `timeout` | `number` | `60000` | Request timeout in ms |
+
+### Extract Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `file` | `File \| Blob \| Buffer \| string` | required | Document to extract from |
+| `schema` | `z.ZodType` | required | Zod schema defining extraction structure |
+| `confidenceThreshold` | `number` | `0.85` | Minimum confidence before triggering fallback |
+
+## Usage
+
+### File Input Options
+
+The SDK supports multiple file input types. **Files don't need to be on disk** – you can work entirely in memory.
+
+| Input Type | Usage | Environment |
+|------------|-------|-------------|
+| `string` | File path | Node.js only |
+| `Buffer` | In-memory bytes | Node.js |
+| `File` | From file input or FormData | Browser, Node.js 20+, Edge |
+| `Blob` | Raw binary with MIME type | Universal |
+
+```typescript
+// Node.js: File path
+const result = await client.extract({
+  file: './invoice.pdf',
+  schema,
+});
+
+// Node.js: Buffer (in-memory)
+import { readFileSync } from 'fs';
+const result = await client.extract({
+  file: readFileSync('./invoice.pdf'),
+  schema,
+});
+
+// Browser: File input
+const fileInput = document.querySelector('input[type="file"]');
+const result = await client.extract({
+  file: fileInput.files[0],
+  schema,
+});
+```
+
+### Complex Schemas for Financial Documents
+
+Use `.describe()` to guide the AI extraction:
+
+```typescript
+const invoiceSchema = z.object({
+  // REQUIRED - Core financial data
+  invoice_number: z.string().describe('The invoice or receipt number'),
+  date: z.string().describe('Invoice date in YYYY-MM-DD format'),
+  total: z.number().describe('Total amount due including tax'),
+  currency: z.string().describe('3-letter currency code (USD, EUR, etc.)'),
+
+  // REQUIRED - Line items (usually present)
+  line_items: z.array(z.object({
+    description: z.string().describe('Item description'),
+    quantity: z.number().describe('Number of units'),
+    unit_price: z.number().describe('Price per unit'),
+    amount: z.number().describe('Total amount for this line'),
+  })).describe('List of items on the invoice'),
+
+  // OPTIONAL - May not appear on all invoices
+  vendor: z.object({
+    name: z.string().describe('Company name of the vendor'),
+    address: z.string().optional().describe('Full address'),
+    tax_id: z.string().optional().describe('Tax ID or VAT number'),
+  }).optional(),
+  subtotal: z.number().optional().describe('Subtotal before tax'),
+  tax: z.number().optional().describe('Tax amount'),
+  due_date: z.string().optional().describe('Payment due date'),
+  payment_terms: z.string().optional().describe('e.g., Net 30'),
+});
+```
+
+### Server-Side / API Usage
+
+**Express with Multer:**
+
+```typescript
+import express from 'express';
+import multer from 'multer';
+import { Parsefy } from 'parsefy';
+
+const upload = multer(); // Store in memory
+const client = new Parsefy();
+
+app.post('/extract', upload.single('document'), async (req, res) => {
+  const { object, metadata, error } = await client.extract({
+    file: req.file.buffer,
+    schema,
+    confidenceThreshold: 0.80, // Adjust based on your needs
+  });
+
+  res.json({
+    data: object,
+    confidence: metadata.confidenceScore,
+    fieldDetails: metadata.fieldConfidence,
+    error,
+  });
+});
+```
+
+**Hono / Cloudflare Workers:**
+
+```typescript
+import { Hono } from 'hono';
+import { Parsefy } from 'parsefy';
+
+const app = new Hono();
+const client = new Parsefy();
+
+app.post('/extract', async (c) => {
+  const formData = await c.req.formData();
+  const file = formData.get('document');
+
+  const { object, metadata, error } = await client.extract({
+    file,
+    schema,
+  });
+
+  return c.json({
+    data: object,
+    confidence: metadata.confidenceScore,
+    issues: metadata.issues,
+    error,
+  });
+});
+```
+
+### Error Handling
+
+```typescript
+import { Parsefy, APIError, ValidationError, ParsefyError } from 'parsefy';
+
+try {
+  const { object, error, metadata } = await client.extract({
+    file: './invoice.pdf',
+    schema,
+  });
+
+  // Extraction-level errors (request succeeded, but extraction failed)
+  if (error) {
+    console.error(`Extraction failed: [${error.code}] ${error.message}`);
+    console.log(`Fallback triggered: ${metadata.fallbackTriggered}`);
+    console.log(`Issues: ${metadata.issues.join(', ')}`);
+    return;
+  }
+
+  // Check for low confidence fields
+  const lowConfidence = metadata.fieldConfidence.filter((fc) => fc.score < 0.80);
+  if (lowConfidence.length > 0) {
+    console.warn('Low confidence fields:', lowConfidence);
+  }
+
+  console.log('Success:', object);
+} catch (err) {
+  // HTTP/Network errors
+  if (err instanceof APIError) {
+    console.error(`API Error ${err.statusCode}: ${err.message}`);
+  } else if (err instanceof ValidationError) {
+    console.error(`Validation Error: ${err.message}`);
+  } else if (err instanceof ParsefyError) {
+    console.error(`Parsefy Error: ${err.message}`);
+  }
+}
+```
+
+## Error Types
+
+| Error Class | Description |
+|-------------|-------------|
+| `ParsefyError` | Base error class for all Parsefy errors |
+| `APIError` | HTTP errors (4xx/5xx responses) |
+| `ExtractionError` | Extraction failed (returned in response) |
+| `ValidationError` | Client-side validation errors |
+
+## Supported File Types
+
+- **PDF** (`.pdf`) – up to 10MB
+- **DOCX** (`.docx`) – up to 10MB
+
+## Rate Limits
+
+The API allows 1 request per second. The SDK automatically retries with exponential backoff on rate limit errors (HTTP 429).
+
+## Requirements
+
+- Node.js 18+ (for native `fetch` and `FormData`)
+- Zod 3.x (peer dependency)
+
+## TypeScript Types
+
+All types are exported for your convenience:
+
+```typescript
+import type {
+  ParsefyConfig,
+  ExtractOptions,
+  ExtractResult,
+  ExtractionMetadata,
+  FieldConfidence,
+  APIErrorResponse,
+} from 'parsefy';
+
+import { DEFAULT_CONFIDENCE_THRESHOLD } from 'parsefy'; // 0.85
+```
+
+## License
+
+MIT © [Parsefy](https://parsefy.io)

package/dist/index.cjs

@@ -0,0 +1,2 @@
+'use strict';var zodToJsonSchema=require('zod-to-json-schema');var u=.85,d={".pdf":"application/pdf",".docx":"application/vnd.openxmlformats-officedocument.wordprocessingml.document"},l=10*1024*1024,h="https://api.parsefy.io",E=6e4;var i=class extends Error{constructor(e,r){super(e),this.name="ParsefyError",this.code=r,typeof Error.captureStackTrace=="function"&&Error.captureStackTrace(this,this.constructor);}},p=class extends i{constructor(e,r,o){super(e),this.name="APIError",this.statusCode=r,this.response=o;}},y=class extends i{constructor(e,r,o){super(e,r),this.name="ExtractionError",this.metadata=o;}},s=class extends i{constructor(e){super(e),this.name="ValidationError";}};function x(){return typeof process<"u"&&process.versions?.node!==void 0}function b(t){let e=zodToJsonSchema.zodToJsonSchema(t,{$refStrategy:"none",target:"jsonSchema7"});return "$schema"in e&&delete e.$schema,e}function R(t){let e=t.toLowerCase().match(/\.[^.]+$/)?.[0];return e&&d[e]||null}function w(t){if(!R(t)){let r=Object.keys(d).join(", ");throw new s(`Unsupported file type. Supported types: ${r}`)}}function f(t){if(t===0)throw new s("File is empty");if(t>l){let e=l/1048576;throw new s(`File size exceeds maximum limit of ${e}MB`)}}function F(t){return {object:t.object,metadata:{processingTimeMs:t.metadata.processing_time_ms,inputTokens:t.metadata.input_tokens,outputTokens:t.metadata.output_tokens,credits:t.metadata.credits,fallbackTriggered:t.metadata.fallback_triggered,confidenceScore:t._meta.confidence_score,fieldConfidence:t._meta.field_confidence.map(e=>({field:e.field,score:e.score,reason:e.reason,page:e.page,text:e.text})),issues:t._meta.issues},error:t.error}}function T(t,e){let r=R(e)||"application/octet-stream",o=t.buffer.slice(t.byteOffset,t.byteOffset+t.byteLength);return typeof File<"u"?new File([o],e,{type:r}):new Blob([o],{type:r})}async function k(t){if(!x())throw new s("File path strings are only supported in Node.js. Use File or Blob in the browser.");let e=await import('fs'),r=await import('path');if(!e.existsSync(t))throw new s(`File not found: ${t}`);let o=r.basename(t);w(o);let a=e.readFileSync(t);return f(a.length),{buffer:a,filename:o}}async function _(t){if(typeof t=="string"){let{buffer:e,filename:r}=await k(t);return T(e,r)}if(Buffer.isBuffer(t))return f(t.length),T(t,"document.pdf");if(t instanceof File)return w(t.name),f(t.size),t;if(t instanceof Blob)return f(t.size),t;throw new s("Invalid file input. Expected File, Blob, Buffer, or file path string.")}function P(t){return new Promise(e=>setTimeout(e,t))}function S(t,e=1e3){let r=e*Math.pow(2,t),o=Math.random()*.1*r;return Math.min(r+o,3e4)}var g=class{constructor(e){this.maxRetries=3;let r={};if(typeof e=="string"?r={apiKey:e}:e&&(r=e),this.apiKey=r.apiKey||this.getEnvApiKey(),!this.apiKey)throw new s("API key is required. Provide it in the constructor or set the PARSEFY_API_KEY environment variable.");this.baseUrl=r.baseUrl||h,this.timeout=r.timeout||E;}getEnvApiKey(){return x()&&process.env.PARSEFY_API_KEY||""}async extract(e){let{file:r,schema:o,confidenceThreshold:a}=e,n=b(o),m=await _(r),c=new FormData;return c.append("file",m),c.append("output_schema",JSON.stringify(n)),c.append("confidence_threshold",String(a??.85)),this.makeRequestWithRetry(c)}async makeRequestWithRetry(e,r=0){try{return await this.makeRequest(e)}catch(o){if(o instanceof p&&o.statusCode===429&&r<this.maxRetries){let a=S(r);return await P(a),this.makeRequestWithRetry(e,r+1)}throw o}}async makeRequest(e){let r=`${this.baseUrl}/v1/extract`,o=new AbortController,a=setTimeout(()=>o.abort(),this.timeout);try{let n=await fetch(r,{method:"POST",headers:{Authorization:`Bearer ${this.apiKey}`},body:e,signal:o.signal});if(clearTimeout(a),!n.ok){let c=await this.parseErrorResponse(n);throw new p(c.message||`API request failed with status ${n.status}`,n.status,c)}let m=await n.json();return F(m)}catch(n){throw clearTimeout(a),n instanceof Error&&n.name==="AbortError"?new i(`Request timed out after ${this.timeout}ms`,"TIMEOUT"):n instanceof i?n:n instanceof TypeError?new i("Network error: Unable to connect to the Parsefy API","NETWORK_ERROR"):new i(`Unexpected error: ${n instanceof Error?n.message:String(n)}`,"UNKNOWN_ERROR")}}async parseErrorResponse(e){try{return await e.json()}catch{try{return {message:await e.text()||e.statusText}}catch{return {message:e.statusText}}}}};
+exports.APIError=p;exports.DEFAULT_CONFIDENCE_THRESHOLD=u;exports.ExtractionError=y;exports.Parsefy=g;exports.ParsefyError=i;exports.ValidationError=s;

package/dist/index.d.cts

@@ -0,0 +1,253 @@
+import { z } from 'zod';
+
+/**
+ * Configuration options for the Parsefy client.
+ */
+interface ParsefyConfig {
+    /** API key for authentication. If not provided, reads from PARSEFY_API_KEY environment variable. */
+    apiKey?: string;
+    /** Base URL for the API. Defaults to https://api.parsefy.io */
+    baseUrl?: string;
+    /** Request timeout in milliseconds. Defaults to 60000 (60 seconds). */
+    timeout?: number;
+}
+/**
+ * Default confidence threshold for extraction.
+ * Fields below this threshold on required fields will trigger the fallback model.
+ */
+declare const DEFAULT_CONFIDENCE_THRESHOLD = 0.85;
+/**
+ * Options for the extract method.
+ */
+interface ExtractOptions<T extends z.ZodType> {
+    /** The document file to extract data from. Supports File, Blob, Buffer, or file path (Node.js only). */
+    file: File | Blob | Buffer | string;
+    /** Zod schema defining the structure of data to extract. */
+    schema: T;
+    /**
+     * Confidence threshold for extraction (0.0 to 1.0). Defaults to 0.85.
+     *
+     * If a **required** field's confidence falls below this threshold (or returns null),
+     * the fallback model is triggered for higher accuracy.
+     *
+     * **Tip**: Lower threshold = faster (accepts Tier 1 more often).
+     * Higher threshold = more accurate (triggers Tier 2 fallback more often).
+     *
+     * **Important**: Mark fields as `.optional()` in your Zod schema if they might not
+     * appear in all documents. This prevents unnecessary fallback triggers and reduces costs.
+     */
+    confidenceThreshold?: number;
+}
+/**
+ * Confidence details for a single extracted field.
+ * Provides evidence and explanation for each extraction.
+ */
+interface FieldConfidence {
+    /** JSON path to the field (e.g., "$.invoice_number"). */
+    field: string;
+    /** Confidence score for this field (0.0 to 1.0). */
+    score: number;
+    /** Explanation of how the value was extracted (e.g., "Exact match", "Inferred from header"). */
+    reason: string;
+    /** Page number where the field was found. */
+    page: number;
+    /** Source text evidence from the document. */
+    text: string;
+}
+/**
+ * Metadata about the extraction process.
+ */
+interface ExtractionMetadata {
+    /** Time taken to process the document in milliseconds. */
+    processingTimeMs: number;
+    /** Number of input tokens used. */
+    inputTokens: number;
+    /** Number of output tokens generated. */
+    outputTokens: number;
+    /** Number of credits consumed (1 credit = 1 page). */
+    credits: number;
+    /** Whether the fallback model was triggered for higher accuracy. */
+    fallbackTriggered: boolean;
+    /** Overall confidence score for the extraction (0.0 to 1.0). */
+    confidenceScore: number;
+    /** Per-field confidence details with evidence and explanations. */
+    fieldConfidence: FieldConfidence[];
+    /** List of issues or warnings encountered during extraction. */
+    issues: string[];
+}
+/**
+ * Error response from the API.
+ */
+interface APIErrorResponse {
+    /** Error code identifying the type of error. */
+    code: string;
+    /** Human-readable error message. */
+    message: string;
+}
+/**
+ * Result of an extraction operation.
+ */
+interface ExtractResult<T> {
+    /** Extracted data matching the schema, or null if extraction failed. */
+    object: T | null;
+    /** Metadata about the extraction process. */
+    metadata: ExtractionMetadata;
+    /** Error details if extraction failed, or null on success. */
+    error: APIErrorResponse | null;
+}
+
+/**
+ * Parsefy client for extracting structured data from financial documents.
+ *
+ * **Important**: All fields are **required by default**. Use `.optional()` for fields
+ * that may not appear in all documents to avoid triggering expensive fallback models.
+ *
+ * @example
+ * ```ts
+ * import { Parsefy } from 'parsefy';
+ * import * as z from 'zod';
+ *
+ * const client = new Parsefy('pk_your_api_key');
+ *
+ * const schema = z.object({
+ *   // REQUIRED - fallback triggered if below confidence threshold
+ *   invoice_number: z.string(),
+ *   total: z.number(),
+ *
+ *   // OPTIONAL - won't trigger fallback if missing
+ *   vendor: z.string().optional(),
+ *   notes: z.string().optional(),
+ * });
+ *
+ * const { object, metadata, error } = await client.extract({
+ *   file: './invoice.pdf',
+ *   schema,
+ *   confidenceThreshold: 0.85, // default
+ * });
+ *
+ * // Check per-field confidence and evidence
+ * metadata.fieldConfidence.forEach((fc) => {
+ *   console.log(`${fc.field}: ${fc.score} - "${fc.text}"`);
+ * });
+ * ```
+ */
+declare class Parsefy {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly maxRetries;
+    /**
+     * Creates a new Parsefy client.
+     *
+     * @param configOrApiKey - API key string or configuration object.
+     *   If not provided, reads from PARSEFY_API_KEY environment variable.
+     *
+     * @example
+     * ```ts
+     * // Using API key directly
+     * const client = new Parsefy('pk_your_api_key');
+     *
+     * // Using configuration object
+     * const client = new Parsefy({
+     *   apiKey: 'pk_your_api_key',
+     *   timeout: 120000,
+     * });
+     *
+     * // Using environment variable
+     * const client = new Parsefy();
+     * ```
+     */
+    constructor(configOrApiKey?: string | ParsefyConfig);
+    /**
+     * Gets the API key from environment variable.
+     */
+    private getEnvApiKey;
+    /**
+     * Extracts structured data from a financial document using the provided Zod schema.
+     *
+     * ** Billing Warning**: All fields are **required by default**. If a required field
+     * returns `null` or falls below the `confidenceThreshold`, the fallback model is triggered,
+     * which is more expensive. Use `.optional()` for fields that may not appear in all documents.
+     *
+     * @param options - Extraction options including file, schema, and confidence threshold.
+     * @returns Promise resolving to the extraction result with typed data and field-level confidence.
+     *
+     * @example
+     * ```ts
+     * const schema = z.object({
+     *   // REQUIRED - triggers fallback if confidence < threshold
+     *   invoice_number: z.string().describe('The invoice number'),
+     *   total: z.number().describe('Total amount including tax'),
+     *
+     *   // OPTIONAL - won't trigger fallback if missing or low confidence
+     *   vendor: z.string().optional().describe('Vendor/supplier name'),
+     *   due_date: z.string().optional().describe('Payment due date'),
+     * });
+     *
+     * const { object, metadata, error } = await client.extract({
+     *   file: './invoice.pdf',
+     *   schema,
+     *   confidenceThreshold: 0.85, // Lower = faster, Higher = more accurate
+     * });
+     *
+     * if (!error && object) {
+     *   console.log(object.invoice_number); // Fully typed!
+     *
+     *   // Access field-level confidence and evidence
+     *   console.log(`Overall confidence: ${metadata.confidenceScore}`);
+     *   metadata.fieldConfidence.forEach((fc) => {
+     *     console.log(`${fc.field}: ${fc.score} (${fc.reason}) - "${fc.text}"`);
+     *   });
+     * }
+     * ```
+     */
+    extract<T extends z.ZodType>(options: ExtractOptions<T>): Promise<ExtractResult<z.infer<T>>>;
+    /**
+     * Makes a request with retry logic for rate limiting.
+     */
+    private makeRequestWithRetry;
+    /**
+     * Makes the actual HTTP request to the API.
+     */
+    private makeRequest;
+    /**
+     * Parses error response body safely.
+     */
+    private parseErrorResponse;
+}
+
+/**
+ * Base error class for all Parsefy errors.
+ */
+declare class ParsefyError extends Error {
+    /** Error code, if applicable. */
+    readonly code?: string;
+    constructor(message: string, code?: string);
+}
+/**
+ * Error thrown when the API returns an HTTP error (4xx/5xx).
+ */
+declare class APIError extends ParsefyError {
+    /** HTTP status code of the response. */
+    readonly statusCode: number;
+    /** Raw response body, if available. */
+    readonly response?: unknown;
+    constructor(message: string, statusCode: number, response?: unknown);
+}
+/**
+ * Error thrown when document extraction fails (returned in response.error).
+ * This is not an HTTP error - the request succeeded but extraction failed.
+ */
+declare class ExtractionError extends ParsefyError {
+    /** Metadata about the extraction attempt. */
+    readonly metadata: ExtractionMetadata;
+    constructor(message: string, code: string, metadata: ExtractionMetadata);
+}
+/**
+ * Error thrown for client-side validation failures.
+ */
+declare class ValidationError extends ParsefyError {
+    constructor(message: string);
+}
+
+export { APIError, type APIErrorResponse, DEFAULT_CONFIDENCE_THRESHOLD, type ExtractOptions, type ExtractResult, ExtractionError, type ExtractionMetadata, type FieldConfidence, Parsefy, type ParsefyConfig, ParsefyError, ValidationError };

package/dist/index.d.mts

@@ -0,0 +1,253 @@
+import { z } from 'zod';
+
+/**
+ * Configuration options for the Parsefy client.
+ */
+interface ParsefyConfig {
+    /** API key for authentication. If not provided, reads from PARSEFY_API_KEY environment variable. */
+    apiKey?: string;
+    /** Base URL for the API. Defaults to https://api.parsefy.io */
+    baseUrl?: string;
+    /** Request timeout in milliseconds. Defaults to 60000 (60 seconds). */
+    timeout?: number;
+}
+/**
+ * Default confidence threshold for extraction.
+ * Fields below this threshold on required fields will trigger the fallback model.
+ */
+declare const DEFAULT_CONFIDENCE_THRESHOLD = 0.85;
+/**
+ * Options for the extract method.
+ */
+interface ExtractOptions<T extends z.ZodType> {
+    /** The document file to extract data from. Supports File, Blob, Buffer, or file path (Node.js only). */
+    file: File | Blob | Buffer | string;
+    /** Zod schema defining the structure of data to extract. */
+    schema: T;
+    /**
+     * Confidence threshold for extraction (0.0 to 1.0). Defaults to 0.85.
+     *
+     * If a **required** field's confidence falls below this threshold (or returns null),
+     * the fallback model is triggered for higher accuracy.
+     *
+     * **Tip**: Lower threshold = faster (accepts Tier 1 more often).
+     * Higher threshold = more accurate (triggers Tier 2 fallback more often).
+     *
+     * **Important**: Mark fields as `.optional()` in your Zod schema if they might not
+     * appear in all documents. This prevents unnecessary fallback triggers and reduces costs.
+     */
+    confidenceThreshold?: number;
+}
+/**
+ * Confidence details for a single extracted field.
+ * Provides evidence and explanation for each extraction.
+ */
+interface FieldConfidence {
+    /** JSON path to the field (e.g., "$.invoice_number"). */
+    field: string;
+    /** Confidence score for this field (0.0 to 1.0). */
+    score: number;
+    /** Explanation of how the value was extracted (e.g., "Exact match", "Inferred from header"). */
+    reason: string;
+    /** Page number where the field was found. */
+    page: number;
+    /** Source text evidence from the document. */
+    text: string;
+}
+/**
+ * Metadata about the extraction process.
+ */
+interface ExtractionMetadata {
+    /** Time taken to process the document in milliseconds. */
+    processingTimeMs: number;
+    /** Number of input tokens used. */
+    inputTokens: number;
+    /** Number of output tokens generated. */
+    outputTokens: number;
+    /** Number of credits consumed (1 credit = 1 page). */
+    credits: number;
+    /** Whether the fallback model was triggered for higher accuracy. */
+    fallbackTriggered: boolean;
+    /** Overall confidence score for the extraction (0.0 to 1.0). */
+    confidenceScore: number;
+    /** Per-field confidence details with evidence and explanations. */
+    fieldConfidence: FieldConfidence[];
+    /** List of issues or warnings encountered during extraction. */
+    issues: string[];
+}
+/**
+ * Error response from the API.
+ */
+interface APIErrorResponse {
+    /** Error code identifying the type of error. */
+    code: string;
+    /** Human-readable error message. */
+    message: string;
+}
+/**
+ * Result of an extraction operation.
+ */
+interface ExtractResult<T> {
+    /** Extracted data matching the schema, or null if extraction failed. */
+    object: T | null;
+    /** Metadata about the extraction process. */
+    metadata: ExtractionMetadata;
+    /** Error details if extraction failed, or null on success. */
+    error: APIErrorResponse | null;
+}
+
+/**
+ * Parsefy client for extracting structured data from financial documents.
+ *
+ * **Important**: All fields are **required by default**. Use `.optional()` for fields
+ * that may not appear in all documents to avoid triggering expensive fallback models.
+ *
+ * @example
+ * ```ts
+ * import { Parsefy } from 'parsefy';
+ * import * as z from 'zod';
+ *
+ * const client = new Parsefy('pk_your_api_key');
+ *
+ * const schema = z.object({
+ *   // REQUIRED - fallback triggered if below confidence threshold
+ *   invoice_number: z.string(),
+ *   total: z.number(),
+ *
+ *   // OPTIONAL - won't trigger fallback if missing
+ *   vendor: z.string().optional(),
+ *   notes: z.string().optional(),
+ * });
+ *
+ * const { object, metadata, error } = await client.extract({
+ *   file: './invoice.pdf',
+ *   schema,
+ *   confidenceThreshold: 0.85, // default
+ * });
+ *
+ * // Check per-field confidence and evidence
+ * metadata.fieldConfidence.forEach((fc) => {
+ *   console.log(`${fc.field}: ${fc.score} - "${fc.text}"`);
+ * });
+ * ```
+ */
+declare class Parsefy {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly maxRetries;
+    /**
+     * Creates a new Parsefy client.
+     *
+     * @param configOrApiKey - API key string or configuration object.
+     *   If not provided, reads from PARSEFY_API_KEY environment variable.
+     *
+     * @example
+     * ```ts
+     * // Using API key directly
+     * const client = new Parsefy('pk_your_api_key');
+     *
+     * // Using configuration object
+     * const client = new Parsefy({
+     *   apiKey: 'pk_your_api_key',
+     *   timeout: 120000,
+     * });
+     *
+     * // Using environment variable
+     * const client = new Parsefy();
+     * ```
+     */
+    constructor(configOrApiKey?: string | ParsefyConfig);
+    /**
+     * Gets the API key from environment variable.
+     */
+    private getEnvApiKey;
+    /**
+     * Extracts structured data from a financial document using the provided Zod schema.
+     *
+     * ** Billing Warning**: All fields are **required by default**. If a required field
+     * returns `null` or falls below the `confidenceThreshold`, the fallback model is triggered,
+     * which is more expensive. Use `.optional()` for fields that may not appear in all documents.
+     *
+     * @param options - Extraction options including file, schema, and confidence threshold.
+     * @returns Promise resolving to the extraction result with typed data and field-level confidence.
+     *
+     * @example
+     * ```ts
+     * const schema = z.object({
+     *   // REQUIRED - triggers fallback if confidence < threshold
+     *   invoice_number: z.string().describe('The invoice number'),
+     *   total: z.number().describe('Total amount including tax'),
+     *
+     *   // OPTIONAL - won't trigger fallback if missing or low confidence
+     *   vendor: z.string().optional().describe('Vendor/supplier name'),
+     *   due_date: z.string().optional().describe('Payment due date'),
+     * });
+     *
+     * const { object, metadata, error } = await client.extract({
+     *   file: './invoice.pdf',
+     *   schema,
+     *   confidenceThreshold: 0.85, // Lower = faster, Higher = more accurate
+     * });
+     *
+     * if (!error && object) {
+     *   console.log(object.invoice_number); // Fully typed!
+     *
+     *   // Access field-level confidence and evidence
+     *   console.log(`Overall confidence: ${metadata.confidenceScore}`);
+     *   metadata.fieldConfidence.forEach((fc) => {
+     *     console.log(`${fc.field}: ${fc.score} (${fc.reason}) - "${fc.text}"`);
+     *   });
+     * }
+     * ```
+     */
+    extract<T extends z.ZodType>(options: ExtractOptions<T>): Promise<ExtractResult<z.infer<T>>>;
+    /**
+     * Makes a request with retry logic for rate limiting.
+     */
+    private makeRequestWithRetry;
+    /**
+     * Makes the actual HTTP request to the API.
+     */
+    private makeRequest;
+    /**
+     * Parses error response body safely.
+     */
+    private parseErrorResponse;
+}
+
+/**
+ * Base error class for all Parsefy errors.
+ */
+declare class ParsefyError extends Error {
+    /** Error code, if applicable. */
+    readonly code?: string;
+    constructor(message: string, code?: string);
+}
+/**
+ * Error thrown when the API returns an HTTP error (4xx/5xx).
+ */
+declare class APIError extends ParsefyError {
+    /** HTTP status code of the response. */
+    readonly statusCode: number;
+    /** Raw response body, if available. */
+    readonly response?: unknown;
+    constructor(message: string, statusCode: number, response?: unknown);
+}
+/**
+ * Error thrown when document extraction fails (returned in response.error).
+ * This is not an HTTP error - the request succeeded but extraction failed.
+ */
+declare class ExtractionError extends ParsefyError {
+    /** Metadata about the extraction attempt. */
+    readonly metadata: ExtractionMetadata;
+    constructor(message: string, code: string, metadata: ExtractionMetadata);
+}
+/**
+ * Error thrown for client-side validation failures.
+ */
+declare class ValidationError extends ParsefyError {
+    constructor(message: string);
+}
+
+export { APIError, type APIErrorResponse, DEFAULT_CONFIDENCE_THRESHOLD, type ExtractOptions, type ExtractResult, ExtractionError, type ExtractionMetadata, type FieldConfidence, Parsefy, type ParsefyConfig, ParsefyError, ValidationError };

package/dist/index.d.ts

@@ -0,0 +1,253 @@
+import { z } from 'zod';
+
+/**
+ * Configuration options for the Parsefy client.
+ */
+interface ParsefyConfig {
+    /** API key for authentication. If not provided, reads from PARSEFY_API_KEY environment variable. */
+    apiKey?: string;
+    /** Base URL for the API. Defaults to https://api.parsefy.io */
+    baseUrl?: string;
+    /** Request timeout in milliseconds. Defaults to 60000 (60 seconds). */
+    timeout?: number;
+}
+/**
+ * Default confidence threshold for extraction.
+ * Fields below this threshold on required fields will trigger the fallback model.
+ */
+declare const DEFAULT_CONFIDENCE_THRESHOLD = 0.85;
+/**
+ * Options for the extract method.
+ */
+interface ExtractOptions<T extends z.ZodType> {
+    /** The document file to extract data from. Supports File, Blob, Buffer, or file path (Node.js only). */
+    file: File | Blob | Buffer | string;
+    /** Zod schema defining the structure of data to extract. */
+    schema: T;
+    /**
+     * Confidence threshold for extraction (0.0 to 1.0). Defaults to 0.85.
+     *
+     * If a **required** field's confidence falls below this threshold (or returns null),
+     * the fallback model is triggered for higher accuracy.
+     *
+     * **Tip**: Lower threshold = faster (accepts Tier 1 more often).
+     * Higher threshold = more accurate (triggers Tier 2 fallback more often).
+     *
+     * **Important**: Mark fields as `.optional()` in your Zod schema if they might not
+     * appear in all documents. This prevents unnecessary fallback triggers and reduces costs.
+     */
+    confidenceThreshold?: number;
+}
+/**
+ * Confidence details for a single extracted field.
+ * Provides evidence and explanation for each extraction.
+ */
+interface FieldConfidence {
+    /** JSON path to the field (e.g., "$.invoice_number"). */
+    field: string;
+    /** Confidence score for this field (0.0 to 1.0). */
+    score: number;
+    /** Explanation of how the value was extracted (e.g., "Exact match", "Inferred from header"). */
+    reason: string;
+    /** Page number where the field was found. */
+    page: number;
+    /** Source text evidence from the document. */
+    text: string;
+}
+/**
+ * Metadata about the extraction process.
+ */
+interface ExtractionMetadata {
+    /** Time taken to process the document in milliseconds. */
+    processingTimeMs: number;
+    /** Number of input tokens used. */
+    inputTokens: number;
+    /** Number of output tokens generated. */
+    outputTokens: number;
+    /** Number of credits consumed (1 credit = 1 page). */
+    credits: number;
+    /** Whether the fallback model was triggered for higher accuracy. */
+    fallbackTriggered: boolean;
+    /** Overall confidence score for the extraction (0.0 to 1.0). */
+    confidenceScore: number;
+    /** Per-field confidence details with evidence and explanations. */
+    fieldConfidence: FieldConfidence[];
+    /** List of issues or warnings encountered during extraction. */
+    issues: string[];
+}
+/**
+ * Error response from the API.
+ */
+interface APIErrorResponse {
+    /** Error code identifying the type of error. */
+    code: string;
+    /** Human-readable error message. */
+    message: string;
+}
+/**
+ * Result of an extraction operation.
+ */
+interface ExtractResult<T> {
+    /** Extracted data matching the schema, or null if extraction failed. */
+    object: T | null;
+    /** Metadata about the extraction process. */
+    metadata: ExtractionMetadata;
+    /** Error details if extraction failed, or null on success. */
+    error: APIErrorResponse | null;
+}
+
+/**
+ * Parsefy client for extracting structured data from financial documents.
+ *
+ * **Important**: All fields are **required by default**. Use `.optional()` for fields
+ * that may not appear in all documents to avoid triggering expensive fallback models.
+ *
+ * @example
+ * ```ts
+ * import { Parsefy } from 'parsefy';
+ * import * as z from 'zod';
+ *
+ * const client = new Parsefy('pk_your_api_key');
+ *
+ * const schema = z.object({
+ *   // REQUIRED - fallback triggered if below confidence threshold
+ *   invoice_number: z.string(),
+ *   total: z.number(),
+ *
+ *   // OPTIONAL - won't trigger fallback if missing
+ *   vendor: z.string().optional(),
+ *   notes: z.string().optional(),
+ * });
+ *
+ * const { object, metadata, error } = await client.extract({
+ *   file: './invoice.pdf',
+ *   schema,
+ *   confidenceThreshold: 0.85, // default
+ * });
+ *
+ * // Check per-field confidence and evidence
+ * metadata.fieldConfidence.forEach((fc) => {
+ *   console.log(`${fc.field}: ${fc.score} - "${fc.text}"`);
+ * });
+ * ```
+ */
+declare class Parsefy {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly maxRetries;
+    /**
+     * Creates a new Parsefy client.
+     *
+     * @param configOrApiKey - API key string or configuration object.
+     *   If not provided, reads from PARSEFY_API_KEY environment variable.
+     *
+     * @example
+     * ```ts
+     * // Using API key directly
+     * const client = new Parsefy('pk_your_api_key');
+     *
+     * // Using configuration object
+     * const client = new Parsefy({
+     *   apiKey: 'pk_your_api_key',
+     *   timeout: 120000,
+     * });
+     *
+     * // Using environment variable
+     * const client = new Parsefy();
+     * ```
+     */
+    constructor(configOrApiKey?: string | ParsefyConfig);
+    /**
+     * Gets the API key from environment variable.
+     */
+    private getEnvApiKey;
+    /**
+     * Extracts structured data from a financial document using the provided Zod schema.
+     *
+     * ** Billing Warning**: All fields are **required by default**. If a required field
+     * returns `null` or falls below the `confidenceThreshold`, the fallback model is triggered,
+     * which is more expensive. Use `.optional()` for fields that may not appear in all documents.
+     *
+     * @param options - Extraction options including file, schema, and confidence threshold.
+     * @returns Promise resolving to the extraction result with typed data and field-level confidence.
+     *
+     * @example
+     * ```ts
+     * const schema = z.object({
+     *   // REQUIRED - triggers fallback if confidence < threshold
+     *   invoice_number: z.string().describe('The invoice number'),
+     *   total: z.number().describe('Total amount including tax'),
+     *
+     *   // OPTIONAL - won't trigger fallback if missing or low confidence
+     *   vendor: z.string().optional().describe('Vendor/supplier name'),
+     *   due_date: z.string().optional().describe('Payment due date'),
+     * });
+     *
+     * const { object, metadata, error } = await client.extract({
+     *   file: './invoice.pdf',
+     *   schema,
+     *   confidenceThreshold: 0.85, // Lower = faster, Higher = more accurate
+     * });
+     *
+     * if (!error && object) {
+     *   console.log(object.invoice_number); // Fully typed!
+     *
+     *   // Access field-level confidence and evidence
+     *   console.log(`Overall confidence: ${metadata.confidenceScore}`);
+     *   metadata.fieldConfidence.forEach((fc) => {
+     *     console.log(`${fc.field}: ${fc.score} (${fc.reason}) - "${fc.text}"`);
+     *   });
+     * }
+     * ```
+     */
+    extract<T extends z.ZodType>(options: ExtractOptions<T>): Promise<ExtractResult<z.infer<T>>>;
+    /**
+     * Makes a request with retry logic for rate limiting.
+     */
+    private makeRequestWithRetry;
+    /**
+     * Makes the actual HTTP request to the API.
+     */
+    private makeRequest;
+    /**
+     * Parses error response body safely.
+     */
+    private parseErrorResponse;
+}
+
+/**
+ * Base error class for all Parsefy errors.
+ */
+declare class ParsefyError extends Error {
+    /** Error code, if applicable. */
+    readonly code?: string;
+    constructor(message: string, code?: string);
+}
+/**
+ * Error thrown when the API returns an HTTP error (4xx/5xx).
+ */
+declare class APIError extends ParsefyError {
+    /** HTTP status code of the response. */
+    readonly statusCode: number;
+    /** Raw response body, if available. */
+    readonly response?: unknown;
+    constructor(message: string, statusCode: number, response?: unknown);
+}
+/**
+ * Error thrown when document extraction fails (returned in response.error).
+ * This is not an HTTP error - the request succeeded but extraction failed.
+ */
+declare class ExtractionError extends ParsefyError {
+    /** Metadata about the extraction attempt. */
+    readonly metadata: ExtractionMetadata;
+    constructor(message: string, code: string, metadata: ExtractionMetadata);
+}
+/**
+ * Error thrown for client-side validation failures.
+ */
+declare class ValidationError extends ParsefyError {
+    constructor(message: string);
+}
+
+export { APIError, type APIErrorResponse, DEFAULT_CONFIDENCE_THRESHOLD, type ExtractOptions, type ExtractResult, ExtractionError, type ExtractionMetadata, type FieldConfidence, Parsefy, type ParsefyConfig, ParsefyError, ValidationError };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import {zodToJsonSchema}from'zod-to-json-schema';var u=.85,d={".pdf":"application/pdf",".docx":"application/vnd.openxmlformats-officedocument.wordprocessingml.document"},l=10*1024*1024,h="https://api.parsefy.io",E=6e4;var i=class extends Error{constructor(e,r){super(e),this.name="ParsefyError",this.code=r,typeof Error.captureStackTrace=="function"&&Error.captureStackTrace(this,this.constructor);}},p=class extends i{constructor(e,r,o){super(e),this.name="APIError",this.statusCode=r,this.response=o;}},y=class extends i{constructor(e,r,o){super(e,r),this.name="ExtractionError",this.metadata=o;}},s=class extends i{constructor(e){super(e),this.name="ValidationError";}};function x(){return typeof process<"u"&&process.versions?.node!==void 0}function b(t){let e=zodToJsonSchema(t,{$refStrategy:"none",target:"jsonSchema7"});return "$schema"in e&&delete e.$schema,e}function R(t){let e=t.toLowerCase().match(/\.[^.]+$/)?.[0];return e&&d[e]||null}function w(t){if(!R(t)){let r=Object.keys(d).join(", ");throw new s(`Unsupported file type. Supported types: ${r}`)}}function f(t){if(t===0)throw new s("File is empty");if(t>l){let e=l/1048576;throw new s(`File size exceeds maximum limit of ${e}MB`)}}function F(t){return {object:t.object,metadata:{processingTimeMs:t.metadata.processing_time_ms,inputTokens:t.metadata.input_tokens,outputTokens:t.metadata.output_tokens,credits:t.metadata.credits,fallbackTriggered:t.metadata.fallback_triggered,confidenceScore:t._meta.confidence_score,fieldConfidence:t._meta.field_confidence.map(e=>({field:e.field,score:e.score,reason:e.reason,page:e.page,text:e.text})),issues:t._meta.issues},error:t.error}}function T(t,e){let r=R(e)||"application/octet-stream",o=t.buffer.slice(t.byteOffset,t.byteOffset+t.byteLength);return typeof File<"u"?new File([o],e,{type:r}):new Blob([o],{type:r})}async function k(t){if(!x())throw new s("File path strings are only supported in Node.js. Use File or Blob in the browser.");let e=await import('fs'),r=await import('path');if(!e.existsSync(t))throw new s(`File not found: ${t}`);let o=r.basename(t);w(o);let a=e.readFileSync(t);return f(a.length),{buffer:a,filename:o}}async function _(t){if(typeof t=="string"){let{buffer:e,filename:r}=await k(t);return T(e,r)}if(Buffer.isBuffer(t))return f(t.length),T(t,"document.pdf");if(t instanceof File)return w(t.name),f(t.size),t;if(t instanceof Blob)return f(t.size),t;throw new s("Invalid file input. Expected File, Blob, Buffer, or file path string.")}function P(t){return new Promise(e=>setTimeout(e,t))}function S(t,e=1e3){let r=e*Math.pow(2,t),o=Math.random()*.1*r;return Math.min(r+o,3e4)}var g=class{constructor(e){this.maxRetries=3;let r={};if(typeof e=="string"?r={apiKey:e}:e&&(r=e),this.apiKey=r.apiKey||this.getEnvApiKey(),!this.apiKey)throw new s("API key is required. Provide it in the constructor or set the PARSEFY_API_KEY environment variable.");this.baseUrl=r.baseUrl||h,this.timeout=r.timeout||E;}getEnvApiKey(){return x()&&process.env.PARSEFY_API_KEY||""}async extract(e){let{file:r,schema:o,confidenceThreshold:a}=e,n=b(o),m=await _(r),c=new FormData;return c.append("file",m),c.append("output_schema",JSON.stringify(n)),c.append("confidence_threshold",String(a??.85)),this.makeRequestWithRetry(c)}async makeRequestWithRetry(e,r=0){try{return await this.makeRequest(e)}catch(o){if(o instanceof p&&o.statusCode===429&&r<this.maxRetries){let a=S(r);return await P(a),this.makeRequestWithRetry(e,r+1)}throw o}}async makeRequest(e){let r=`${this.baseUrl}/v1/extract`,o=new AbortController,a=setTimeout(()=>o.abort(),this.timeout);try{let n=await fetch(r,{method:"POST",headers:{Authorization:`Bearer ${this.apiKey}`},body:e,signal:o.signal});if(clearTimeout(a),!n.ok){let c=await this.parseErrorResponse(n);throw new p(c.message||`API request failed with status ${n.status}`,n.status,c)}let m=await n.json();return F(m)}catch(n){throw clearTimeout(a),n instanceof Error&&n.name==="AbortError"?new i(`Request timed out after ${this.timeout}ms`,"TIMEOUT"):n instanceof i?n:n instanceof TypeError?new i("Network error: Unable to connect to the Parsefy API","NETWORK_ERROR"):new i(`Unexpected error: ${n instanceof Error?n.message:String(n)}`,"UNKNOWN_ERROR")}}async parseErrorResponse(e){try{return await e.json()}catch{try{return {message:await e.text()||e.statusText}}catch{return {message:e.statusText}}}}};
+export{p as APIError,u as DEFAULT_CONFIDENCE_THRESHOLD,y as ExtractionError,g as Parsefy,i as ParsefyError,s as ValidationError};

package/package.json

@@ -1,12 +1,57 @@
 {
   "name": "parsefy",
-  "version": "1.0.0",
-  "description": "High-accuracy document data extraction powered by AI",
-  "license": "ISC",
-  "author": "marceloakalopes",
-  "type": "commonjs",
-  "main": "index.js",
+  "version": "1.0.2",
+  "description": "Official TypeScript SDK for Parsefy - Financial Document Infrastructure for Developers",
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/parsefy/parsefy-js.git"
+  },
+  "homepage": "https://parsefy.io",
+  "bugs": {
+    "url": "https://github.com/parsefy/parsefy-js/issues"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsup && cp dist/index.d.ts dist/index.d.cts",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "zod": "^3.0.0"
+  },
+  "dependencies": {
+    "zod-to-json-schema": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.0.0",
+    "zod": "^3.22.0"
+  },
+  "engines": {
+    "node": ">=18"
   }
 }

package/index.js

@@ -1 +0,0 @@
-console.log("Parsefy SDK");