@kortexya/reasoninglayer 0.11.0 → 0.12.1

package/dist/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 // src/config.ts
-var SDK_VERSION = "0.11.0";
+var SDK_VERSION = "0.12.1";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -13401,46 +13401,269 @@ function ResumeDocumentIngestionResponseFromApiToFront(dto) {
     success: dto.success
   };
 }
+function AsyncIngestionResponseFromApiToFront(dto) {
+  return {
+    sessionId: dto.session_id,
+    documentId: dto.document_id,
+    status: dto.status,
+    statusUrl: dto.status_url
+  };
+}
+function StepLogEntryDtoFromApiToFront(dto) {
+  return {
+    message: dto.message,
+    step: dto.step,
+    timestamp: dto.timestamp
+  };
+}
+function DocumentProgressDtoFromApiToFront(dto) {
+  return {
+    chunksFailed: dto.chunks_failed,
+    chunksProcessed: dto.chunks_processed,
+    currentChunk: dto.current_chunk,
+    currentChunkPreview: dto.current_chunk_preview,
+    currentStep: dto.current_step,
+    currentStepLabel: dto.current_step_label,
+    discoveredEntityTypes: dto.discovered_entity_types,
+    discoveredRelationTypes: dto.discovered_relation_types,
+    documentId: dto.document_id,
+    domainSummary: dto.domain_summary,
+    elapsedSeconds: dto.elapsed_seconds,
+    entitiesCreated: dto.entities_created,
+    entitiesExtracted: dto.entities_extracted,
+    entitiesFiltered: dto.entities_filtered,
+    entitiesMerged: dto.entities_merged,
+    entitiesPendingReview: dto.entities_pending_review,
+    estimatedCostUsd: dto.estimated_cost_usd,
+    extractionStrategy: dto.extraction_strategy,
+    inferenceRulesApplied: dto.inference_rules_applied,
+    modelName: dto.model_name,
+    osfResiduationsCreated: dto.osf_residuations_created,
+    osfResiduationsResumed: dto.osf_residuations_resumed,
+    referencesResolved: dto.references_resolved,
+    referencesUnresolved: dto.references_unresolved,
+    relationsExtracted: dto.relations_extracted,
+    relationsFromInference: dto.relations_from_inference,
+    relationsIntegrated: dto.relations_integrated,
+    reviewsPersisted: dto.reviews_persisted,
+    sortNames: dto.sort_names,
+    sortsCreated: dto.sorts_created,
+    sortsReused: dto.sorts_reused,
+    sortsReusedGlb: dto.sorts_reused_glb,
+    sortsReusedSemantic: dto.sorts_reused_semantic,
+    startedAt: dto.started_at,
+    stepLog: dto.step_log.map(StepLogEntryDtoFromApiToFront),
+    tokensInput: dto.tokens_input,
+    tokensOutput: dto.tokens_output,
+    totalChunks: dto.total_chunks,
+    updatedAt: dto.updated_at
+  };
+}
+function SessionProgressResponseFromApiToFront(dto) {
+  return {
+    documents: dto.documents.map(DocumentProgressDtoFromApiToFront),
+    sessionId: dto.session_id
+  };
+}
+function DocumentStatsDtoFromApiToFront(dto) {
+  return {
+    chunksProcessed: dto.chunks_processed,
+    completedAt: dto.completed_at,
+    documentId: dto.document_id,
+    entitiesExtracted: dto.entities_extracted,
+    processingTimeMs: dto.processing_time_ms,
+    relationsExtracted: dto.relations_extracted,
+    sortNames: dto.sort_names,
+    termIds: dto.term_ids,
+    totalTokens: dto.total_tokens
+  };
+}
+function SessionStatsResponseFromApiToFront(dto) {
+  return {
+    documents: dto.documents.map(DocumentStatsDtoFromApiToFront),
+    sessionId: dto.session_id,
+    total: dto.total
+  };
+}
 
-// src/resources/ingestion.ts
-var IngestionClient = class {
+// src/resources/ingestion-session.ts
+var IngestionFailedError = class extends ReasoningLayerError {
+  name = "IngestionFailedError";
+  /** The session ID that failed. */
+  sessionId;
+  /** The last known session state. */
+  session;
+  constructor(session) {
+    super(`Ingestion session ${session.sessionId} failed`);
+    this.sessionId = session.sessionId;
+    this.session = session;
+  }
+};
+var IngestionSession = class {
+  /** The session ID (UUID). */
+  sessionId;
+  /** The document ID (UUID). */
+  documentId;
+  /** The initial status (always `"pending"` on creation). */
+  status;
+  /** URL path to check session status. */
+  statusUrl;
   /** @internal */
   api;
   /** @internal */
-  constructor(api) {
+  constructor(api, response) {
     this.api = api;
+    this.sessionId = response.sessionId;
+    this.documentId = response.documentId;
+    this.status = response.status;
+    this.statusUrl = response.statusUrl;
   }
   /**
-   * Ingest a single document.
+   * Get the current session details (status, document counts).
+   *
+   * @returns The session information.
    *
-   * @param request - Document ingestion request with source, config, and owner.
-   * @returns Ingestion result with stats, metadata, and parse info.
+   * @remarks
+   * Maps to `GET /api/v1/ingest/sessions/{session_id}`.
    */
-  async ingestDocument(request) {
-    const response = await this.api.ingestDocument(IngestDocumentRequestFromFrontToApi(request));
-    return IngestDocumentResponseFromApiToFront(response.data);
+  async getSession() {
+    const response = await this.api.getIngestionSession(this.sessionId);
+    return IngestionSessionResponseFromApiToFront(response.data);
   }
   /**
-   * Ingest a batch of documents.
+   * Get live pipeline progress for all documents in the session.
    *
-   * @param request - Batch ingestion request with documents, config, and owner.
-   * @returns Batch results with per-document status.
+   * @returns Progress snapshots for each document being processed.
+   *
+   * @remarks
+   * Maps to `GET /api/v1/ingest/sessions/{session_id}/progress`.
+   * Returns real-time counters, current pipeline step, and step log.
    */
-  async ingestDocumentBatch(request) {
-    const response = await this.api.ingestDocumentBatch(IngestDocumentBatchRequestFromFrontToApi(request));
-    return IngestDocumentBatchResponseFromApiToFront(response.data);
+  async getProgress() {
+    const response = await this.api.getIngestionProgress(this.sessionId);
+    return SessionProgressResponseFromApiToFront(response.data);
   }
   /**
-   * Ingest markdown content.
+   * Get stats for all completed documents in the session.
    *
-   * @param request - Markdown ingestion request with content and owner.
-   * @returns Ingestion statistics and review items.
+   * @returns Per-document stats (term IDs, sort names, token usage, etc.).
    *
    * @remarks
-   * Uses synchronous mode (sync=true) by default. The generated endpoint
-   * returns void for the response type; we use a fallback to get the typed response.
+   * Maps to `GET /api/v1/ingest/sessions/{session_id}/stats`.
+   * May be empty if no documents have completed yet.
    */
-  async ingestMarkdown(request) {
+  async getStats() {
+    const response = await this.api.getIngestionSessionStats(this.sessionId);
+    return SessionStatsResponseFromApiToFront(response.data);
+  }
+  /**
+   * Poll the session until it completes or fails, then return final stats.
+   *
+   * @param options - Polling configuration (interval, timeout, progress callback, abort signal).
+   * @returns Final session stats once all documents are complete.
+   * @throws {@link IngestionFailedError} If the session status becomes `"failed"`.
+   * @throws {@link TimeoutError} If `timeoutMs` is exceeded.
+   * @throws {@link ReasoningLayerError} If the abort signal is triggered.
+   *
+   * @example
+   * ```ts
+   * const stats = await session.waitForCompletion({
+   *   pollIntervalMs: 2000,
+   *   timeoutMs: 300_000,
+   *   onProgress: (p) => {
+   *     const doc = p.documents[0];
+   *     if (doc) console.log(`${doc.currentStepLabel} — chunk ${doc.chunksProcessed}/${doc.totalChunks}`);
+   *   },
+   * });
+   * console.log(`Created ${stats.documents[0]?.termIds.length} terms`);
+   * ```
+   *
+   * @remarks
+   * Polls `getSession()` to check status, and calls `onProgress` with live
+   * progress data between checks. Terminal states are `"complete"` and `"failed"`.
+   */
+  async waitForCompletion(options) {
+    const pollIntervalMs = options?.pollIntervalMs ?? 2e3;
+    const timeoutMs = options?.timeoutMs ?? 3e5;
+    const onProgress = options?.onProgress;
+    const signal = options?.signal;
+    const deadline = Date.now() + timeoutMs;
+    for (; ; ) {
+      if (signal?.aborted) {
+        throw new ReasoningLayerError("Ingestion polling was aborted", {
+          cause: signal.reason
+        });
+      }
+      if (Date.now() > deadline) {
+        throw new TimeoutError(timeoutMs);
+      }
+      const session = await this.getSession();
+      if (session.status === "complete") {
+        return this.getStats();
+      }
+      if (session.status === "failed") {
+        throw new IngestionFailedError(session);
+      }
+      if (onProgress) {
+        try {
+          const progress = await this.getProgress();
+          onProgress(progress);
+        } catch {
+        }
+      }
+      await this.sleep(pollIntervalMs, signal);
+    }
+  }
+  /** @internal */
+  sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+      if (signal?.aborted) {
+        reject(new ReasoningLayerError("Ingestion polling was aborted", {
+          cause: signal.reason
+        }));
+        return;
+      }
+      const timer = setTimeout(resolve, ms);
+      if (signal) {
+        const onAbort = () => {
+          clearTimeout(timer);
+          reject(new ReasoningLayerError("Ingestion polling was aborted", {
+            cause: signal.reason
+          }));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        const originalResolve = resolve;
+        resolve = () => {
+          signal.removeEventListener("abort", onAbort);
+          originalResolve();
+        };
+      }
+    });
+  }
+};
+
+// src/resources/ingestion.ts
+var IngestionClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  async ingestMarkdown(request, options) {
+    const sync = options?.sync ?? true;
+    if (!sync) {
+      const response2 = await this.api.http.request({
+        path: `/api/v1/ingest/markdown`,
+        method: "POST",
+        query: { sync: false },
+        body: IngestMarkdownRequestFromFrontToApi(request),
+        type: "application/json" /* Json */,
+        format: "json"
+      });
+      const asyncResponse = AsyncIngestionResponseFromApiToFront(response2.data);
+      return new IngestionSession(this.api, asyncResponse);
+    }
     const response = await this.api.http.request({
       path: `/api/v1/ingest/markdown`,
       method: "POST",
@@ -13470,6 +13693,40 @@ var IngestionClient = class {
     });
     return response.data;
   }
+  async ingestDocument(request, options) {
+    const sync = options?.sync ?? true;
+    if (!sync) {
+      const response2 = await this.api.http.request({
+        path: `/api/v1/ingest/document`,
+        method: "POST",
+        query: { sync: false },
+        body: IngestDocumentRequestFromFrontToApi(request),
+        type: "application/json" /* Json */,
+        format: "json"
+      });
+      const asyncResponse = AsyncIngestionResponseFromApiToFront(response2.data);
+      return new IngestionSession(this.api, asyncResponse);
+    }
+    const response = await this.api.ingestDocument(IngestDocumentRequestFromFrontToApi(request));
+    return IngestDocumentResponseFromApiToFront(response.data);
+  }
+  async ingestDocumentBatch(request, options) {
+    const sync = options?.sync ?? true;
+    if (!sync) {
+      const response2 = await this.api.http.request({
+        path: `/api/v1/ingest/document/batch`,
+        method: "POST",
+        query: { sync: false },
+        body: IngestDocumentBatchRequestFromFrontToApi(request),
+        type: "application/json" /* Json */,
+        format: "json"
+      });
+      const asyncResponse = AsyncIngestionResponseFromApiToFront(response2.data);
+      return new IngestionSession(this.api, asyncResponse);
+    }
+    const response = await this.api.ingestDocumentBatch(IngestDocumentBatchRequestFromFrontToApi(request));
+    return IngestDocumentBatchResponseFromApiToFront(response.data);
+  }
   /**
    * Ingest RDF content (Turtle, N-Triples, RDF/XML, or JSON-LD).
    *
@@ -13517,6 +13774,34 @@ var IngestionClient = class {
   async deleteSession(sessionId) {
     await this.api.deleteIngestionSession(sessionId);
   }
+  /**
+   * Get live pipeline progress for all documents in a session.
+   *
+   * @param sessionId - Session UUID.
+   * @returns Progress snapshots for each document being processed.
+   *
+   * @remarks
+   * Maps to `GET /api/v1/ingest/sessions/{session_id}/progress`.
+   * Returns real-time counters, current pipeline step, and step log.
+   */
+  async getSessionProgress(sessionId) {
+    const response = await this.api.getIngestionProgress(sessionId);
+    return SessionProgressResponseFromApiToFront(response.data);
+  }
+  /**
+   * Get stats for all completed documents in a session.
+   *
+   * @param sessionId - Session UUID.
+   * @returns Per-document stats (term IDs, sort names, token usage, etc.).
+   *
+   * @remarks
+   * Maps to `GET /api/v1/ingest/sessions/{session_id}/stats`.
+   * May be empty if no documents have completed yet.
+   */
+  async getSessionStats(sessionId) {
+    const response = await this.api.getIngestionSessionStats(sessionId);
+    return SessionStatsResponseFromApiToFront(response.data);
+  }
   /**
    * List incomplete documents in a session that can be resumed.
    *
@@ -22262,6 +22547,8 @@ exports.ILP = ilp_exports;
 exports.ImageExtraction = image_extraction_exports;
 exports.Inference = inference_exports;
 exports.Ingestion = ingestion_exports;
+exports.IngestionFailedError = IngestionFailedError;
+exports.IngestionSession = IngestionSession;
 exports.InternalServerError = InternalServerError;
 exports.LP = LP;
 exports.Namespaces = namespaces_exports;