@heripo/pdf-parser 0.1.23 → 0.1.25

package/dist/index.cjs

@@ -736,6 +736,32 @@ function validatePythonVersion(version, context = "system") {
 }
 
 // src/environment/python-environment.ts
+var DOCLING_SERVE_PACKAGE = "docling-serve==1.16.1";
+var DOCLING_RUNTIME_PACKAGES = [
+  "docling-jobkit==1.16.0",
+  "docling==2.88.0",
+  "docling-core==2.73.0",
+  "docling-ibm-models==3.13.0",
+  "docling-parse==5.9.0"
+];
+var DOCLING_SERVE_RUNTIME_PACKAGES = [
+  "fastapi[standard]<0.130.0",
+  "httpx~=0.28",
+  "pydantic~=2.10",
+  "pydantic-settings~=2.4",
+  "python-multipart<0.1.0,>=0.0.14",
+  "typer~=0.12",
+  "uvicorn[standard]<1.0.0,>=0.29.0",
+  "websockets<17.0,>=14.0",
+  "scalar-fastapi>=1.0.3",
+  "docling-mcp>=1.0.0",
+  "opentelemetry-api==1.36.0",
+  "opentelemetry-sdk==1.36.0",
+  "opentelemetry-exporter-otlp==1.36.0",
+  "opentelemetry-instrumentation-fastapi==0.57b0",
+  "opentelemetry-exporter-prometheus==0.57b0",
+  "prometheus-client>=0.21.0"
+];
 var PythonEnvironment = class {
   constructor(logger, venvPath) {
     this.logger = logger;
@@ -747,6 +773,8 @@ var PythonEnvironment = class {
     await this.upgradePip();
     await this.installSetuptools();
     await this.installPyArrow();
+    await this.installDoclingRuntimePackages();
+    await this.installDoclingServeRuntimePackages();
     await this.installDoclingServe();
   }
   async checkPythonVersion() {
@@ -840,12 +868,30 @@ var PythonEnvironment = class {
       throw new Error(`Failed to install pyarrow. Exit code: ${result.code}`);
     }
   }
+  async installDoclingRuntimePackages() {
+    const pipPath = (0, import_node_path2.join)(this.venvPath, "bin", "pip");
+    const result = await spawnAsync(pipPath, [
+      "install",
+      "--upgrade",
+      ...DOCLING_RUNTIME_PACKAGES
+    ]);
+    if (result.code !== 0) {
+      this.logger.error(
+        "[DoclingEnvironment] Failed to install docling runtime packages:",
+        result.stderr
+      );
+      throw new Error(
+        `Failed to install docling runtime packages. Exit code: ${result.code}`
+      );
+    }
+  }
   async installDoclingServe() {
     const pipPath = (0, import_node_path2.join)(this.venvPath, "bin", "pip");
     const result = await spawnAsync(pipPath, [
       "install",
       "--upgrade",
-      "docling-serve"
+      "--no-deps",
+      DOCLING_SERVE_PACKAGE
     ]);
     if (result.code !== 0) {
       this.logger.error(
@@ -857,6 +903,23 @@ var PythonEnvironment = class {
       );
     }
   }
+  async installDoclingServeRuntimePackages() {
+    const pipPath = (0, import_node_path2.join)(this.venvPath, "bin", "pip");
+    const result = await spawnAsync(pipPath, [
+      "install",
+      "--upgrade",
+      ...DOCLING_SERVE_RUNTIME_PACKAGES
+    ]);
+    if (result.code !== 0) {
+      this.logger.error(
+        "[DoclingEnvironment] Failed to install docling-serve runtime packages:",
+        result.stderr
+      );
+      throw new Error(
+        `Failed to install docling-serve runtime packages. Exit code: ${result.code}`
+      );
+    }
+  }
 };
 
 // src/environment/docling-environment.ts
@@ -3848,6 +3911,7 @@ var PDFParser = class {
   enableImagePdfFallback;
   client = null;
   environment;
+  recoveryPromise = null;
   constructor(options) {
     const {
       logger,
@@ -3932,15 +3996,30 @@ var PDFParser = class {
    */
   isConnectionRefusedError(error) {
     if (error instanceof Error) {
+      const errorWithMetadata = error;
       if (error.message.includes("ECONNREFUSED")) {
         return true;
       }
-      if (error.cause instanceof Error && error.cause.message.includes("ECONNREFUSED")) {
+      if (errorWithMetadata.code === "ECONNREFUSED") {
         return true;
       }
+      return this.isConnectionRefusedError(errorWithMetadata.cause);
+    }
+    if (typeof error === "object" && error !== null) {
+      const errorLike = error;
+      if (errorLike.code === "ECONNREFUSED") {
+        return true;
+      }
+      if (typeof errorLike.message === "string" && errorLike.message.includes("ECONNREFUSED")) {
+        return true;
+      }
+      return this.isConnectionRefusedError(errorLike.cause);
     }
     return false;
   }
+  canRecoverLocalServer() {
+    return !this.baseUrl && this.port !== void 0;
+  }
   /**
    * Restart the Docling server after it has crashed.
    * This kills any existing process on the port, starts a new server,
@@ -3970,6 +4049,46 @@ var PDFParser = class {
     await this.waitForServerReady();
     this.logger.info("[PDFParser] Server restarted successfully");
   }
+  async recoverServer(message) {
+    this.logger.warn(message);
+    if (!this.recoveryPromise) {
+      this.recoveryPromise = this.restartServer().finally(() => {
+        this.recoveryPromise = null;
+      });
+    } else {
+      this.logger.warn("[PDFParser] Server recovery already in progress...");
+    }
+    await this.recoveryPromise;
+  }
+  async isReady() {
+    if (!this.client) {
+      return false;
+    }
+    try {
+      await this.client.health();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async ensureReady() {
+    if (!this.client) {
+      throw new Error(
+        "PDFParser is not initialized. Call init() before checking readiness"
+      );
+    }
+    try {
+      await this.client.health();
+    } catch (error) {
+      if (this.canRecoverLocalServer()) {
+        await this.recoverServer(
+          "[PDFParser] Health check failed, attempting server recovery..."
+        );
+        return;
+      }
+      throw error;
+    }
+  }
   async waitForServerReady() {
     const maxAttempts = PDF_PARSER.MAX_HEALTH_CHECK_ATTEMPTS;
     const checkInterval = PDF_PARSER.HEALTH_CHECK_INTERVAL_MS;
@@ -4053,18 +4172,16 @@ var PDFParser = class {
    * Recovery is only attempted in local server mode (no baseUrl, port defined).
    */
   async executeWithRecovery(fn, abortSignal) {
-    const canRecover = !this.baseUrl && this.port !== void 0;
     const maxAttempts = PDF_PARSER.MAX_SERVER_RECOVERY_ATTEMPTS;
     const tryExecute = async (attempt) => {
       try {
         return await fn();
       } catch (error) {
         if (abortSignal?.aborted) throw error;
-        if (canRecover && this.isConnectionRefusedError(error) && attempt < maxAttempts) {
-          this.logger.warn(
+        if (this.canRecoverLocalServer() && this.isConnectionRefusedError(error) && attempt < maxAttempts) {
+          await this.recoverServer(
             "[PDFParser] Connection refused, attempting server recovery..."
           );
-          await this.restartServer();
           return tryExecute(attempt + 1);
         }
         throw error;