@kortexya/reasoninglayer 6.0.0 → 6.2.0

package/dist/index.js

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "6.0.0";
+var SDK_VERSION = "6.2.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -9781,6 +9781,22 @@ var Analysis = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Computes the concepts of the population's schema-presence context under the declared bounds and, when asked, its observed implication basis; the export carries the incidence, the bounds and each result's completeness so an importer can replay all of it.
+   *
+   * @tags analysis
+   * @name ExportFca
+   * @summary Export the FCA of an explicit population.
+   * @request POST:/api/v1/analysis/fca-exports
+   */
+  exportFca = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/fca-exports`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -10030,6 +10046,22 @@ var Analysis = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Replays the export natively: decodes its context, recomputes a graded incidence from its degrees and cut, recomputes its concepts and basis under its declared bounds, and requires each claim, completeness included, to equal its recomputation; every object must name a source term of the caller's tenant. A refusal accepts nothing and names its reason.
+   *
+   * @tags analysis
+   * @name VerifyFcaExport
+   * @summary Verify an FCA export for import into the caller's tenant.
+   * @request POST:/api/v1/analysis/fca-exports/verify
+   */
+  verifyFcaExport = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/fca-exports/verify`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/Functions.ts
@@ -20705,6 +20737,7 @@ var RESPONSE_COMPONENTS = {
       document_id: [1, 0],
       entities_extracted: [1, 0],
       entities_refused: [1, { array: "RefusedEntityDto" }],
+      fca_discovery: [2, "FcaIngestionReportDto"],
       processing_time_ms: [1, 0],
       relations_extracted: [1, 0],
       relations_integrated: [1, 0],
@@ -21295,6 +21328,50 @@ var RESPONSE_COMPONENTS = {
     }
   },
   FailedReviewDto: { object: { reason: [1, 0], review_id: [1, 0] } },
+  FcaBasisClaimDto: {
+    object: {
+      complete: [1, 0],
+      implications: [1, { array: "FcaImplicationRecordDto" }],
+      max_candidates: [1, 0],
+      max_work: [1, 0]
+    }
+  },
+  FcaConceptClaimDto: {
+    object: {
+      complete: [1, 0],
+      concepts: [1, { array: "FcaConceptRecordDto" }],
+      max_concepts: [1, 0],
+      max_visited_concepts: [1, 0],
+      max_work: [1, 0],
+      min_extent_size: [1, 0],
+      min_intent_size: [1, 0]
+    }
+  },
+  FcaConceptRecordDto: { object: { extent: [1, { array: 0 }], intent: [1, { array: 0 }] } },
+  FcaContextDto: {
+    object: {
+      attributes: [1, { array: 0 }],
+      incidence: [1, { array: { array: 0 } }],
+      objects: [1, { array: 0 }],
+      version: [1, 0]
+    }
+  },
+  FcaExportDto: {
+    object: {
+      basis: [2, "FcaBasisClaimDto"],
+      concepts: [1, "FcaConceptClaimDto"],
+      context: [1, "FcaContextDto"],
+      graded: [2, "FcaGradedIncidenceDto"],
+      version: [1, 0]
+    }
+  },
+  FcaGradedDegreeDto: { object: { attribute: [1, 0], degree: [1, 0] } },
+  FcaGradedIncidenceDto: {
+    object: { alpha: [1, 0], degrees: [1, { array: { array: "FcaGradedDegreeDto" } }] }
+  },
+  FcaImplicationRecordDto: {
+    object: { conclusion: [1, { array: 0 }], premise: [1, { array: 0 }] }
+  },
   FcaIngestionRecommendationDto: {
     object: {
       confidence: [1, 0],
@@ -26310,6 +26387,9 @@ var RESPONSE_COMPONENTS = {
     }
   },
   VerificationStepDto: { object: { description: [1, 0], name: [1, 0], passed: [1, 0] } },
+  VerifiedFcaImportDto: {
+    object: { concepts: [1, 0], concepts_complete: [1, 0], sources: [1, { array: 0 }] }
+  },
   VerifyClaimResponse: {
     object: {
       contradicting_count: [1, 0],
@@ -27860,6 +27940,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/dsr/{id}/export",
     responses: { 200: "DsrExportResponse" }
   },
+  exportFca: {
+    method: "POST",
+    path: "/api/v1/analysis/fca-exports",
+    responses: { 200: "FcaExportDto" }
+  },
   exportJsonl: {
     method: "POST",
     path: "/api/v1/synthetic/export-jsonl",
@@ -30633,6 +30718,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/synthetic/verify-faithfulness",
     responses: { 200: "VerifyFaithfulnessResponse" }
   },
+  verifyFcaExport: {
+    method: "POST",
+    path: "/api/v1/analysis/fca-exports/verify",
+    responses: { 200: "VerifiedFcaImportDto" }
+  },
   verifyIntegrity: {
     method: "POST",
     path: "/api/v1/audit/verify-integrity",
@@ -41353,7 +41443,8 @@ function DocumentStatsDtoFromApiToFront(dto) {
     relationsIntegrated: dto.relations_integrated,
     sortNames: dto.sort_names,
     termIds: dto.term_ids,
-    totalTokens: dto.total_tokens
+    totalTokens: dto.total_tokens,
+    fcaDiscovery: dto.fca_discovery ? FcaIngestionReportFromApiToFront(dto.fca_discovery) : void 0
   };
 }
 function SessionStatsResponseFromApiToFront(dto) {
@@ -49702,6 +49793,7 @@ function StartExplorationRequestFromFrontToApi(model) {
     min_intent_size: model.minIntentSize,
     max_terms: model.maxTerms,
     ...model.sortNames !== void 0 ? { sort_names: model.sortNames } : {},
+    ...model.semantics !== void 0 ? { semantics: DiscoverySemanticsFromFrontToApi(model.semantics) } : {},
     ...explorationSearchBoundsFromFrontToApi(model)
   };
 }
@@ -49736,6 +49828,7 @@ function RefuteRequestFromFrontToApi(model) {
     question_id: model.questionId,
     label: model.label,
     features: model.features,
+    ...model.values !== void 0 ? { values: featuresFromFrontToApi(model.values) } : {},
     ...explorationSearchBoundsFromFrontToApi(model)
   };
 }
@@ -49778,6 +49871,28 @@ function SortLicenceResponseFromApiToFront(dto) {
     installedRules: dto.installed_rules
   };
 }
+function FcaExportRequestFromFrontToApi(model) {
+  return {
+    term_ids: model.termIds,
+    max_concepts: model.maxConcepts,
+    min_extent_size: model.minExtentSize,
+    min_intent_size: model.minIntentSize,
+    max_work: model.maxWork,
+    max_visited_concepts: model.maxVisitedConcepts,
+    include_basis: model.includeBasis,
+    basis_max_work: model.basisMaxWork,
+    basis_max_candidates: model.basisMaxCandidates
+  };
+}
+function VerifiedFcaImportFromApiToFront(dto) {
+  return {
+    sources: dto.sources,
+    concepts: dto.concepts,
+    conceptsComplete: dto.concepts_complete,
+    implications: dto.implications ?? null,
+    basisComplete: dto.basis_complete ?? null
+  };
+}
 function ConfluenceConflictDtoFromApiToFront(dto) {
   return {
     kind: dto.kind,
@@ -49846,13 +49961,39 @@ var AnalysisClient = class {
   /**
    * Start an interactive attribute exploration session.
    *
-   * @param request - Exploration parameters.
-   * @returns Session ID and first question.
+   * @param request - Exploration parameters: the sort scope (`sortNames`),
+   *   the attribute `semantics`, and the search bounds.
+   * @param requestOptions - Per-call request options.
+   * @returns Session ID, the formal context's attribute and object counts,
+   *   the first question, and the search report.
+   * @throws {ForbiddenError} 403 with code `exploration_actor_required` when
+   *   the request carries no gateway human actor (`authenticatedUser`).
+   * @throws {BadRequestError} 400 for an unknown sort name, a refused
+   *   population bound (`exploration_population_limit`), native-predicate
+   *   semantics, or a scaled interpretation that is not complete.
+   *
+   * @remarks
+   * The converted body is sent verbatim (no further key conversion): the
+   * feature names that key a `scaled` semantics' `schemes` reach the engine
+   * exactly as written. A missing `question` does not mean the basis is
+   * complete: read `search.stop`.
+   *
+   * @example
+   * ```typescript
+   * const started = await client.analysis.startExploration({
+   *   sortNames: ['member'],
+   *   semantics: {
+   *     kind: 'scaled',
+   *     schemes: { age: { kind: 'interordinal', thresholds: [65] } },
+   *   },
+   * });
+   * console.log(started.attributeCount, started.objectCount, started.search.stop);
+   * ```
    */
   async startExploration(request, requestOptions) {
     const response = await this.api.startExploration(
       StartExplorationRequestFromFrontToApi(request),
-      toRequestParams(requestOptions)
+      mergeRequestParams({ headers: { [RAW_BODY_HEADER]: "1" } }, requestOptions)
     );
     return decodeResponse(response, StartExplorationResponseFromApiToFront);
   }
@@ -49921,7 +50062,13 @@ var AnalysisClient = class {
    * @throws {NotFoundError} 404 when the session does not exist.
    *
    * @remarks
-   * Body `{ question_id, label, features }`; `questionId` is required.
+   * Body `{ question_id, label, features, values? }`; `questionId` is
+   * required. A presence session takes the counterexample's feature names in
+   * `features`. A scaled session takes `features: []` and the counterexample
+   * as a record of tagged values in `values`, which the session's scales
+   * project into attributes; the engine refuses a label list or an
+   * unreadable value there with `400`, and refuses `values` in a presence
+   * session.
    *
    * The exploration continues after an answered question and poses one
    * question for each pseudo-intent, so a session asks every implication of
@@ -49934,6 +50081,13 @@ var AnalysisClient = class {
    *   label: 'penguin',
    *   features: ['bird'],
    * });
+   * // In a scaled session:
+   * await client.analysis.refuteImplication(sessionId, {
+   *   questionId: question.questionId,
+   *   label: 'young cardholder',
+   *   features: [],
+   *   values: toTaggedFeatures({ age: 30, senior_card: true }),
+   * });
    * ```
    */
   async refuteImplication(sessionId, request, requestOptions) {
@@ -50054,6 +50208,59 @@ var AnalysisClient = class {
     );
     return decodeResponse(response, SortLicenceResponseFromApiToFront);
   }
+  /**
+   * Export the native FCA of an explicit population.
+   *
+   * @param request - The population and the enumeration (and basis) bounds.
+   * @param requestOptions - Per-call request options.
+   * @returns The replayable export, in its wire form.
+   * @throws {BadRequestError} 400 for an invalid population or budgets beyond
+   *   the supported limits.
+   *
+   * @remarks
+   * The engine computes the concepts of the population's schema-presence
+   * context under the declared bounds and, when asked, its observed
+   * implication basis; the export carries the incidence, the bounds and each
+   * result's completeness so an importer can replay all of it with
+   * {@link verifyFcaExport}.
+   *
+   * @example
+   * ```typescript
+   * const exported = await client.analysis.exportFca({ termIds, includeBasis: true });
+   * const verified = await client.analysis.verifyFcaExport(exported);
+   * console.log(verified.concepts, verified.conceptsComplete);
+   * ```
+   */
+  async exportFca(request, requestOptions) {
+    const response = await this.api.exportFca(
+      FcaExportRequestFromFrontToApi(request),
+      toRequestParams(requestOptions)
+    );
+    return decodeResponse(response, (dto) => dto);
+  }
+  /**
+   * Verify an FCA export for import into the caller's tenant.
+   *
+   * @param fcaExport - The export, exactly as {@link exportFca} returned it.
+   * @param requestOptions - Per-call request options.
+   * @returns What native replay reproduced.
+   * @throws {BadRequestError} 400 when the declared bounds or universe exceed
+   *   the supported limits.
+   * @throws {ApiError} 422 (`status` 422, `errorCode` `fca_export_refused`) when
+   *   a claim, the incidence or the scope does not survive native replay;
+   *   nothing is accepted.
+   *
+   * @remarks
+   * The engine decodes the export's context, recomputes a graded incidence
+   * from its degrees and cut, recomputes its concepts and basis under its
+   * declared bounds, and requires each claim, completeness included, to equal
+   * its recomputation; every object must name a source term of the caller's
+   * tenant.
+   */
+  async verifyFcaExport(fcaExport, requestOptions) {
+    const response = await this.api.verifyFcaExport(fcaExport, toRequestParams(requestOptions));
+    return decodeResponse(response, VerifiedFcaImportFromApiToFront);
+  }
   /**
    * Invite a gateway human user to an exploration session.
    *