@agentionai/agents 0.11.0 → 0.12.0-beta

package/dist/parsers/LlamaIndexParser.d.ts

@@ -0,0 +1,58 @@
+import { DocumentParser } from "./DocumentParser";
+import { ParsedDocument, ParseOptions } from "./types";
+/**
+ * A LlamaIndex reader instance.
+ * Matches the `BaseReader` interface from `llamaindex` and `@llamaindex/readers`.
+ */
+export interface LlamaIndexReader {
+    loadData(filePath: string, ...args: unknown[]): Promise<Array<{
+        text: string;
+        metadata?: Record<string, unknown>;
+    }>>;
+}
+/**
+ * Document parser that delegates to any **LlamaIndex reader**.
+ *
+ * Pass any reader from `llamaindex` or `@llamaindex/readers` — e.g.
+ * `PDFReader`, `DocxReader`, `HTMLReader`, `LlamaParseReader`, etc. — and
+ * this class normalises the output into a {@link ParsedDocument}.
+ *
+ * **Peer dependency:** `llamaindex` and/or `@llamaindex/readers`
+ *
+ * @example
+ * ```typescript
+ * import { PDFReader } from "@llamaindex/readers/pdf";
+ * import { LlamaIndexParser } from "@agentionai/agents/parsers";
+ *
+ * const parser = new LlamaIndexParser(new PDFReader());
+ * const doc = await parser.parse("/path/to/report.pdf");
+ * await pipeline.ingestFile("/path/to/report.pdf", parser);
+ * ```
+ *
+ * @example Using LlamaParse (cloud OCR / layout AI)
+ * ```typescript
+ * import { LlamaParseReader } from "llamaindex";
+ *
+ * const parser = new LlamaIndexParser(
+ *   new LlamaParseReader({ resultType: "markdown" })
+ * );
+ * ```
+ */
+export declare class LlamaIndexParser extends DocumentParser {
+    private readonly reader;
+    readonly name: string;
+    /**
+     * @param reader      - Any LlamaIndex reader instance
+     * @param readerName  - Optional label used in {@link name}; defaults to the
+     *                      reader's constructor name
+     */
+    constructor(reader: LlamaIndexReader, readerName?: string);
+    /**
+     * Parse a file using the configured LlamaIndex reader.
+     *
+     * @param filePath - Path to the document file
+     * @param options  - Currently unused; kept for interface compatibility
+     */
+    parse(filePath: string, _options?: ParseOptions): Promise<ParsedDocument>;
+}
+//# sourceMappingURL=LlamaIndexParser.d.ts.map

package/dist/parsers/LlamaIndexParser.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LlamaIndexParser = void 0;
+const DocumentParser_1 = require("./DocumentParser");
+/**
+ * Document parser that delegates to any **LlamaIndex reader**.
+ *
+ * Pass any reader from `llamaindex` or `@llamaindex/readers` — e.g.
+ * `PDFReader`, `DocxReader`, `HTMLReader`, `LlamaParseReader`, etc. — and
+ * this class normalises the output into a {@link ParsedDocument}.
+ *
+ * **Peer dependency:** `llamaindex` and/or `@llamaindex/readers`
+ *
+ * @example
+ * ```typescript
+ * import { PDFReader } from "@llamaindex/readers/pdf";
+ * import { LlamaIndexParser } from "@agentionai/agents/parsers";
+ *
+ * const parser = new LlamaIndexParser(new PDFReader());
+ * const doc = await parser.parse("/path/to/report.pdf");
+ * await pipeline.ingestFile("/path/to/report.pdf", parser);
+ * ```
+ *
+ * @example Using LlamaParse (cloud OCR / layout AI)
+ * ```typescript
+ * import { LlamaParseReader } from "llamaindex";
+ *
+ * const parser = new LlamaIndexParser(
+ *   new LlamaParseReader({ resultType: "markdown" })
+ * );
+ * ```
+ */
+class LlamaIndexParser extends DocumentParser_1.DocumentParser {
+    /**
+     * @param reader      - Any LlamaIndex reader instance
+     * @param readerName  - Optional label used in {@link name}; defaults to the
+     *                      reader's constructor name
+     */
+    constructor(reader, readerName) {
+        super();
+        this.reader = reader;
+        this.name = `llamaindex:${readerName ?? reader.constructor?.name ?? "reader"}`;
+    }
+    /**
+     * Parse a file using the configured LlamaIndex reader.
+     *
+     * @param filePath - Path to the document file
+     * @param options  - Currently unused; kept for interface compatibility
+     */
+    async parse(filePath, _options) {
+        let docs;
+        try {
+            docs = await this.reader.loadData(filePath);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`LlamaIndexParser (${this.name}) failed to load "${filePath}": ${msg}`);
+        }
+        const elements = docs.map((doc, i) => ({
+            type: "Document",
+            text: doc.text ?? "",
+            metadata: { ...doc.metadata, doc_index: i },
+        }));
+        return {
+            text: this.elementsToText(elements),
+            elements,
+        };
+    }
+}
+exports.LlamaIndexParser = LlamaIndexParser;
+//# sourceMappingURL=LlamaIndexParser.js.map

package/dist/parsers/OllamaOCRParser.d.ts

@@ -0,0 +1,98 @@
+import { DocumentParser } from "./DocumentParser";
+import { ParsedDocument, ParseOptions } from "./types";
+/**
+ * Configuration for {@link OllamaOCRParser}.
+ */
+export interface OllamaOCRParserConfig {
+    /**
+     * Ollama model to use for OCR.
+     * @default "glm-ocr"
+     */
+    model?: string;
+    /**
+     * Base URL of the local Ollama server.
+     * @default "http://localhost:11434"
+     */
+    baseUrl?: string;
+    /**
+     * Prompt sent alongside each image.
+     * @default "Extract and transcribe all text from this image. Preserve the original structure, headings, and formatting as much as possible. Output only the extracted text."
+     */
+    prompt?: string;
+    /**
+     * Scale factor for rendering PDF pages to images.
+     * 1.0 = 72 DPI, 2.0 = 144 DPI. Lower is faster; higher improves OCR accuracy.
+     * @default 2.0
+     */
+    pdfScale?: number;
+    /**
+     * Number of pages to OCR in parallel.
+     * Higher values are faster but use more memory and GPU.
+     * @default 3
+     */
+    concurrency?: number;
+    /**
+     * Called after each PDF page is OCR'd.
+     * With concurrency > 1 pages may complete out of order,
+     * but the final document is always in the correct page order.
+     */
+    onProgress?: (completed: number, total: number) => void;
+}
+/**
+ * Document parser that uses a locally-running **Ollama** vision model (e.g. `glm-ocr`)
+ * to perform OCR on image files and PDF documents.
+ *
+ * **Supported file types:**
+ * - Images: `.jpg`, `.jpeg`, `.png`, `.gif`, `.webp`, `.bmp` — no extra dependencies
+ * - PDF: requires the optional peer dependency `pdf-to-img` (`npm install pdf-to-img`)
+ *
+ * **Ollama must be running** with the model pulled:
+ * ```bash
+ * ollama pull glm-ocr
+ * ollama serve   # if not already running
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { OllamaOCRParser } from "@agentionai/agents/parsers/ollama-ocr";
+ *
+ * const parser = new OllamaOCRParser({
+ *   model: "glm-ocr",
+ *   pdfScale: 1.5,
+ *   onProgress: (page, total) => console.log(`OCR page ${page}/${total}...`),
+ * });
+ *
+ * // Parse an image
+ * const doc = await parser.parse("/path/to/scan.png");
+ *
+ * // Parse a PDF (requires: npm install pdf-to-img)
+ * const pdf = await parser.parse("/path/to/report.pdf");
+ *
+ * // Use with IngestionPipeline
+ * await pipeline.ingestFile("/path/to/scan.png", parser);
+ * ```
+ */
+export declare class OllamaOCRParser extends DocumentParser {
+    readonly name = "ollama-ocr";
+    private readonly model;
+    private readonly baseUrl;
+    private readonly prompt;
+    private readonly pdfScale;
+    private readonly concurrency;
+    private readonly onProgress?;
+    constructor(config?: OllamaOCRParserConfig);
+    /**
+     * Parse a document file using Ollama OCR.
+     *
+     * @param filePath - Path to the image or PDF file
+     * @param options  - Optional hints (unused by this parser; provided for interface compatibility)
+     */
+    parse(filePath: string, _options?: ParseOptions): Promise<ParsedDocument>;
+    private parseImageFile;
+    private parsePdf;
+    /**
+     * Send a base64-encoded image to the Ollama chat API and return the extracted text.
+     */
+    private runOCR;
+}
+//# sourceMappingURL=OllamaOCRParser.d.ts.map

package/dist/parsers/OllamaOCRParser.js

@@ -0,0 +1,203 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaOCRParser = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const DocumentParser_1 = require("./DocumentParser");
+/** Supported image extensions for direct OCR (no conversion needed). */
+const IMAGE_EXTS = new Set([".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"]);
+/**
+ * Document parser that uses a locally-running **Ollama** vision model (e.g. `glm-ocr`)
+ * to perform OCR on image files and PDF documents.
+ *
+ * **Supported file types:**
+ * - Images: `.jpg`, `.jpeg`, `.png`, `.gif`, `.webp`, `.bmp` — no extra dependencies
+ * - PDF: requires the optional peer dependency `pdf-to-img` (`npm install pdf-to-img`)
+ *
+ * **Ollama must be running** with the model pulled:
+ * ```bash
+ * ollama pull glm-ocr
+ * ollama serve   # if not already running
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { OllamaOCRParser } from "@agentionai/agents/parsers/ollama-ocr";
+ *
+ * const parser = new OllamaOCRParser({
+ *   model: "glm-ocr",
+ *   pdfScale: 1.5,
+ *   onProgress: (page, total) => console.log(`OCR page ${page}/${total}...`),
+ * });
+ *
+ * // Parse an image
+ * const doc = await parser.parse("/path/to/scan.png");
+ *
+ * // Parse a PDF (requires: npm install pdf-to-img)
+ * const pdf = await parser.parse("/path/to/report.pdf");
+ *
+ * // Use with IngestionPipeline
+ * await pipeline.ingestFile("/path/to/scan.png", parser);
+ * ```
+ */
+class OllamaOCRParser extends DocumentParser_1.DocumentParser {
+    constructor(config = {}) {
+        super();
+        this.name = "ollama-ocr";
+        this.model = config.model ?? "glm-ocr";
+        this.baseUrl = (config.baseUrl ?? "http://localhost:11434").replace(/\/$/, "");
+        this.prompt =
+            config.prompt ??
+                "Extract and transcribe all text from this image. Preserve the original structure, headings, and formatting as much as possible. Output only the extracted text.";
+        this.pdfScale = config.pdfScale ?? 2.0;
+        this.concurrency = config.concurrency ?? 3;
+        this.onProgress = config.onProgress;
+    }
+    /**
+     * Parse a document file using Ollama OCR.
+     *
+     * @param filePath - Path to the image or PDF file
+     * @param options  - Optional hints (unused by this parser; provided for interface compatibility)
+     */
+    async parse(filePath, _options) {
+        const ext = path.extname(filePath).toLowerCase();
+        if (IMAGE_EXTS.has(ext)) {
+            return this.parseImageFile(filePath);
+        }
+        if (ext === ".pdf") {
+            return this.parsePdf(filePath);
+        }
+        throw new Error(`OllamaOCRParser: unsupported file type "${ext}". ` +
+            `Supported: ${[...IMAGE_EXTS].join(", ")}, .pdf`);
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    async parseImageFile(filePath) {
+        const base64 = fs.readFileSync(filePath).toString("base64");
+        const text = await this.runOCR(base64);
+        const element = {
+            type: "NarrativeText",
+            text,
+            metadata: { source: filePath },
+        };
+        return { text, elements: [element], metadata: { filePath, pages: 1 } };
+    }
+    async parsePdf(filePath) {
+        // Dynamically load pdf-to-img — optional peer dep, no system deps required
+        let pdfFn;
+        try {
+            // Resolve the module from process.cwd() so that peer deps installed in
+            // the consuming project (not this library's own node_modules) are found.
+            const { createRequire } = await Promise.resolve().then(() => __importStar(require("module")));
+            const { pathToFileURL } = await Promise.resolve().then(() => __importStar(require("url")));
+            const requireFromCwd = createRequire(path.resolve(process.cwd(), "__placeholder__.js"));
+            const resolved = requireFromCwd.resolve("pdf-to-img");
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ({ pdf: pdfFn } = await Promise.resolve(`${pathToFileURL(resolved).href}`).then(s => __importStar(require(s))));
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (message.includes("Cannot find module") ||
+                message.includes("MODULE_NOT_FOUND") ||
+                message.includes("ERR_MODULE_NOT_FOUND")) {
+                throw new Error("OllamaOCRParser: PDF parsing requires 'pdf-to-img'. " +
+                    "Install it with: npm install pdf-to-img");
+            }
+            throw err;
+        }
+        const doc = await pdfFn(filePath, { scale: this.pdfScale });
+        const total = doc.length;
+        // Step 1: render all pages to buffers (fast — pure JS, no network)
+        const pageBuffers = [];
+        for await (const buf of doc) {
+            pageBuffers.push(buf);
+        }
+        // Step 2: OCR pages in parallel using a worker-pool with concurrency limit
+        const elements = new Array(total);
+        let completed = 0;
+        const queue = pageBuffers.map((buf, i) => async () => {
+            const text = await this.runOCR(buf.toString("base64"));
+            elements[i] = {
+                type: "NarrativeText",
+                text,
+                metadata: { page_number: i + 1, source: filePath },
+            };
+            this.onProgress?.(++completed, total);
+        });
+        const workers = Array.from({ length: Math.min(this.concurrency, total) }, async () => {
+            while (queue.length > 0) {
+                await queue.shift()();
+            }
+        });
+        await Promise.all(workers);
+        return {
+            text: this.elementsToText(elements),
+            elements,
+            metadata: { filePath, pages: total },
+        };
+    }
+    /**
+     * Send a base64-encoded image to the Ollama chat API and return the extracted text.
+     */
+    async runOCR(base64Image) {
+        const url = `${this.baseUrl}/api/chat`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                model: this.model,
+                messages: [
+                    {
+                        role: "user",
+                        content: this.prompt,
+                        images: [base64Image],
+                    },
+                ],
+                stream: false,
+            }),
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => "");
+            throw new Error(`OllamaOCRParser: Ollama API error ${response.status} ${response.statusText}` +
+                (body ? `\n${body}` : ""));
+        }
+        const data = (await response.json());
+        return data.message?.content?.trim() ?? "";
+    }
+}
+exports.OllamaOCRParser = OllamaOCRParser;
+//# sourceMappingURL=OllamaOCRParser.js.map

package/dist/parsers/UnstructuredAPIParser.d.ts

@@ -0,0 +1,57 @@
+import { DocumentParser } from "./DocumentParser";
+import { ParsedDocument, ParseOptions } from "./types";
+/**
+ * Configuration for {@link UnstructuredAPIParser}.
+ */
+export interface UnstructuredAPIParserConfig {
+    /**
+     * API key for the Unstructured hosted service.
+     * Not required when `serverUrl` points to a self-hosted instance
+     * that does not enforce authentication.
+     */
+    apiKey?: string;
+    /**
+     * Base URL of the Unstructured API.
+     * Defaults to the official hosted endpoint when an `apiKey` is provided.
+     * Set to your own host when running the open-source API server locally:
+     * ```
+     * docker run -p 8000:8000 downloads.unstructured.io/unstructured-io/unstructured-api:latest
+     * serverUrl: "http://localhost:8000"
+     * ```
+     */
+    serverUrl?: string;
+}
+/**
+ * Document parser backed by the **Unstructured REST API** — either the
+ * official hosted service or a self-hosted open-source API server.
+ *
+ * Uses the official `unstructured-client` npm package under the hood.
+ *
+ * **Peer dependency:** `unstructured-client`
+ *
+ * @example
+ * ```typescript
+ * // Hosted service
+ * const parser = new UnstructuredAPIParser({ apiKey: process.env.UNSTRUCTURED_API_KEY });
+ *
+ * // Self-hosted (no auth required)
+ * const parser = new UnstructuredAPIParser({ serverUrl: "http://localhost:8000" });
+ *
+ * const doc = await parser.parse("/path/to/report.pdf", { strategy: "hi_res" });
+ * await pipeline.ingestFile("/path/to/report.pdf", parser);
+ * ```
+ */
+export declare class UnstructuredAPIParser extends DocumentParser {
+    private readonly config;
+    readonly name = "unstructured-api";
+    constructor(config?: UnstructuredAPIParserConfig);
+    /**
+     * Parse a file via the Unstructured API.
+     *
+     * @param filePath - Path to the document to parse (read from disk)
+     * @param options  - Strategy, languages, and any other partition parameters
+     */
+    parse(filePath: string, options?: ParseOptions): Promise<ParsedDocument>;
+    private mapRawElements;
+}
+//# sourceMappingURL=UnstructuredAPIParser.d.ts.map

package/dist/parsers/UnstructuredAPIParser.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnstructuredAPIParser = void 0;
+const DocumentParser_1 = require("./DocumentParser");
+const STRATEGY_MAP = {
+    auto: "auto",
+    fast: "fast",
+    hi_res: "hi_res",
+    ocr_only: "ocr_only",
+};
+/**
+ * Document parser backed by the **Unstructured REST API** — either the
+ * official hosted service or a self-hosted open-source API server.
+ *
+ * Uses the official `unstructured-client` npm package under the hood.
+ *
+ * **Peer dependency:** `unstructured-client`
+ *
+ * @example
+ * ```typescript
+ * // Hosted service
+ * const parser = new UnstructuredAPIParser({ apiKey: process.env.UNSTRUCTURED_API_KEY });
+ *
+ * // Self-hosted (no auth required)
+ * const parser = new UnstructuredAPIParser({ serverUrl: "http://localhost:8000" });
+ *
+ * const doc = await parser.parse("/path/to/report.pdf", { strategy: "hi_res" });
+ * await pipeline.ingestFile("/path/to/report.pdf", parser);
+ * ```
+ */
+class UnstructuredAPIParser extends DocumentParser_1.DocumentParser {
+    constructor(config = {}) {
+        super();
+        this.config = config;
+        this.name = "unstructured-api";
+    }
+    /**
+     * Parse a file via the Unstructured API.
+     *
+     * @param filePath - Path to the document to parse (read from disk)
+     * @param options  - Strategy, languages, and any other partition parameters
+     */
+    async parse(filePath, options) {
+        const pkg = "unstructured-client";
+        let UnstructuredClient;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ({ UnstructuredClient } = await Promise.resolve(`${pkg}`).then(s => __importStar(require(s))));
+        }
+        catch {
+            throw new Error("UnstructuredAPIParser requires 'unstructured-client'. " +
+                "Install it with: npm install unstructured-client");
+        }
+        const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+        const path = await Promise.resolve().then(() => __importStar(require("path")));
+        const clientConfig = {};
+        if (this.config.apiKey) {
+            clientConfig["security"] = { apiKeyAuth: this.config.apiKey };
+        }
+        if (this.config.serverUrl) {
+            clientConfig["serverURL"] = this.config.serverUrl;
+        }
+        const client = new UnstructuredClient(clientConfig);
+        const fileContent = fs.readFileSync(filePath);
+        const fileName = path.basename(filePath);
+        const { strategy, languages, ...rest } = options ?? {};
+        const res = await client.general.partition({
+            partitionParameters: {
+                files: { content: fileContent, fileName },
+                strategy: STRATEGY_MAP[strategy ?? "auto"] ?? "auto",
+                ...(languages ? { languages } : {}),
+                ...rest,
+            },
+        });
+        const rawElements = res.elements ?? [];
+        const elements = this.mapRawElements(rawElements);
+        return {
+            text: this.elementsToText(elements),
+            elements,
+        };
+    }
+    mapRawElements(raw) {
+        return raw.map((el) => {
+            const e = el;
+            return {
+                type: typeof e["type"] === "string" ? e["type"] : "unknown",
+                text: typeof e["text"] === "string" ? e["text"] : "",
+                metadata: e["metadata"] != null &&
+                    typeof e["metadata"] === "object" &&
+                    !Array.isArray(e["metadata"])
+                    ? e["metadata"]
+                    : undefined,
+            };
+        });
+    }
+}
+exports.UnstructuredAPIParser = UnstructuredAPIParser;
+//# sourceMappingURL=UnstructuredAPIParser.js.map

package/dist/parsers/UnstructuredLocalParser.d.ts

@@ -0,0 +1,42 @@
+import { DocumentParser } from "./DocumentParser";
+import { ParsedDocument, ParseOptions } from "./types";
+/**
+ * Document parser that uses the **local** (open-source Python) version of
+ * Unstructured via the `@epilogo/unstructured-io-node` npm bridge.
+ *
+ * The bridge spawns a Python virtual environment and calls the Python
+ * `unstructured` library directly — no API key required, but Python 3.8+
+ * and system dependencies (poppler, tesseract, etc.) must be available.
+ *
+ * **Peer dependency:** `@epilogo/unstructured-io-node`
+ *
+ * @example
+ * ```typescript
+ * import { UnstructuredLocalParser } from "@agentionai/agents/parsers";
+ *
+ * const parser = new UnstructuredLocalParser();
+ * const doc = await parser.parse("/path/to/report.pdf", {
+ *   strategy: "hi_res",
+ *   languages: ["eng"],
+ * });
+ * console.log(doc.elements?.length, "elements");
+ *
+ * // Use with IngestionPipeline
+ * await pipeline.ingestFile("/path/to/report.pdf", parser);
+ * ```
+ */
+export declare class UnstructuredLocalParser extends DocumentParser {
+    readonly name = "unstructured-local";
+    /**
+     * Parse a file using the local Python Unstructured library.
+     *
+     * On first call, `ensureEnvironmentSetup()` is invoked to download the
+     * Python venv if it does not already exist (one-time, slow operation).
+     *
+     * @param filePath - Path to the document to parse
+     * @param options  - Strategy, languages, and any other unstructured kwargs
+     */
+    parse(filePath: string, options?: ParseOptions): Promise<ParsedDocument>;
+    private mapRawElements;
+}
+//# sourceMappingURL=UnstructuredLocalParser.d.ts.map