@kortexya/reasoninglayer 1.5.1 → 1.6.0

package/dist/index.d.cts

@@ -109,7 +109,7 @@ type JsonValue$1 = string | number | boolean | null | JsonValue$1[] | object;
  * This is the single source of truth for the version constant.
  * The `scripts/release.sh` script updates this value alongside `package.json`.
  */
-declare const SDK_VERSION = "1.5.1";
+declare const SDK_VERSION = "1.6.0";
 /**
  * Authentication mode for the SDK.
  *
@@ -3391,6 +3391,40 @@ interface ConfirmResponseDto {
 }
 /** How to resolve feature conflicts when merging */
 type ConflictResolution$1 = "keep_existing" | "use_new" | "merge";
+/**
+ * A concrete order-dependence counterexample: two rules that derive conflicting
+ * values for a feature declared functional.
+ */
+interface ConfluenceConflictDto {
+    /** The two conflicting values the rules derive for the same entity. */
+    conflicting_values: string[];
+    /** The functional feature the two rules disagree on. */
+    feature: string;
+    /** The kind of conflict (currently always `"functional-dependency-violation"`). */
+    kind: string;
+}
+/** Confluence (order-independence) half of the certificate. */
+interface ConfluenceDto {
+    /** The concrete counterexample, when the rule base is not order-independent. */
+    conflict?: null | ConfluenceConflictDto;
+    /**
+     * `true` iff forward reasoning produces the same result regardless of the
+     * order rules fire in.
+     */
+    order_independent: boolean;
+    /**
+     * Why: `"monotone-least-fixpoint"`, `"congruence-closure"`, `"monotone-chase"`,
+     * `"vacuous"`, `"branching"` (disjunctive rules explore multiple models), or
+     * `"functional-conflict"` (a counterexample was found).
+     */
+    reason: string;
+    /**
+     * Number of rule interactions found (places one rule's output can trigger
+     * another). All are order-safe when `order_independent` is `true`.
+     * @min 0
+     */
+    rule_interactions: number;
+}
 /** A single constraint check in the verification result. */
 interface ConstraintCheckDto$1 {
     /** Description of the constraint. */
@@ -9675,6 +9709,16 @@ interface IngestRdfRequest$1 {
     content: string;
     /** Format of the RDF content */
     format: RdfFormatDto$1;
+    /**
+     * Whether to materialise OWL/RDFS class & property *declarations*
+     * (`:p a owl:DatatypeProperty`, `:C a owl:Class`) as queryable identity terms.
+     *
+     * Default `false` keeps declarations as schema (out of `?s ?p ?o`), the
+     * established behaviour for ordinary ingest. Set `true` only for SPARQL OWL/RDFS
+     * entailment workloads, where `?p a owl:DatatypeProperty` and `?c rdfs:subClassOf
+     * ?d` must match declarations.
+     */
+    keep_declarations?: boolean;
     /** Whether to also parse OWL ontology from the content */
     parse_ontology?: boolean;
     /** Whether to also parse SHACL shapes from the content */
@@ -13007,6 +13051,14 @@ interface OsfqlRequest$1 {
      * ```
      */
     query: string;
+    /**
+     * Opt into **reactive (streaming) mode**: after the program runs, any
+     * suspended `AWAIT` demon whose trigger is now satisfied fires
+     * automatically — no explicit `RELEASE RESIDUATIONS` needed. Defaults to
+     * `false` (demons stay suspended until an explicit RELEASE), so existing
+     * clients are byte-identical.
+     */
+    reactive?: boolean;
 }
 /** Response from executing an OSFQL program. */
 interface OsfqlResponse$1 {
@@ -14022,7 +14074,7 @@ interface QueueMetricsResponse {
     worker_utilization_pct?: number | null;
 }
 /** RDF format DTO */
-type RdfFormatDto$1 = "turtle" | "n_triples" | "rdf_xml" | "json_ld";
+type RdfFormatDto$1 = "turtle" | "n_triples" | "rdf_xml" | "json_ld" | "trig" | "nquads";
 /** Request to re-extract entities from a document */
 interface ReExtractRequest$1 {
     /** Document ID to re-extract from */
@@ -15446,6 +15498,18 @@ interface RuleAggregatorDto {
     /** Feature name whose value is aggregated within each group. */
     target: string;
 }
+/** The full certification result returned to the caller. */
+interface RuleBaseCertificateDto {
+    /** The order-independence guarantee (or the conflicting rule pair). */
+    confluence: ConfluenceDto;
+    /**
+     * `true` iff the rule base both terminates and is order-independent — the
+     * complete "won't loop, order-independent" guarantee.
+     */
+    fully_certified: boolean;
+    /** The termination guarantee (or why it could not be established). */
+    termination: TerminationDto;
+}
 /** A rule clause (OSF clause) */
 interface RuleClauseDto$1 {
     /** Constraints on variables in this clause */
@@ -18033,6 +18097,36 @@ interface TermTranslationDto {
     copied_id: string;
     original_id: string;
 }
+/** Termination half of the certificate. */
+interface TerminationDto {
+    /**
+     * Whether any rule invents fresh values (creating new entities), present only
+     * when established via the ranking function.
+     */
+    creates_new_values?: boolean | null;
+    /**
+     * When termination could not be established and an obstruction was found, the
+     * human-readable cycle of interacting positions that can grow without bound.
+     */
+    diverging_cycle?: any[] | null;
+    /**
+     * The deepest chain of freshly-created values any reasoning step can produce
+     * (the ranking-function bound). `0` means the rules never invent new values
+     * — reasoning is bounded by the existing data. Present only when terminating
+     * via the ranking function.
+     * @format int32
+     * @min 0
+     */
+    max_recursion_depth?: number | null;
+    /**
+     * How termination was established: `"bounded-recursion"` (a ranking function
+     * bounds value creation), `"decidable-fragment:<name>"` (a recognised
+     * terminating rule class), or `"undetermined"`.
+     */
+    method: string;
+    /** `true` iff forward reasoning is guaranteed to reach a fixpoint. */
+    terminates: boolean;
+}
 /** Threshold-based weak anchor for an antecedent gate. */
 interface ThresholdAnchorDto {
     /**
@@ -38381,6 +38475,15 @@ declare class Analysis<SecurityDataType = unknown> {
      * @request POST:/api/v1/analysis/sort-discovery
      */
     analyzeSortDiscovery: (data: SortDiscoveryRequestDto, params?: RequestParams) => Promise<HttpResponse<SortDiscoveryResponseDto, void>>;
+    /**
+     * @description Returns a [`RuleBaseCertificateDto`]: whether forward reasoning is guaranteed to halt (with the ranking-function depth bound), and whether it is order-independent (with the theorem discharged, or a concrete conflicting rule pair). The analysis is read-only over the tenant's knowledge base.
+     *
+     * @tags analysis
+     * @name CertifyRuleBase
+     * @summary Certify the authenticated tenant's rule base.
+     * @request GET:/api/v1/analysis/rule-base/certify
+     */
+    certifyRuleBase: (params?: RequestParams) => Promise<HttpResponse<RuleBaseCertificateDto, any>>;
     /**
      * @description The exploration must be complete (no more questions) before calling this. Creates appropriateness sorts in the hierarchy from the Duquenne-Guigues basis.
      *
@@ -43566,6 +43669,17 @@ interface ConversationMessageResponse {
     intent: string;
     /** OSFQL that was executed (if any). */
     osfqlExecuted?: string | null;
+    /**
+     * True when {@link osfqlExecuted} is a constrained-regeneration *repair* of a query the
+     * certify-or-abstain gate first rejected as hallucinated. Lets the UI surface that the answer
+     * reflects a corrected query rather than the user's literal request.
+     */
+    repaired?: boolean;
+    /**
+     * The original, rejected OSFQL the LLM first proposed — present only when {@link repaired} is
+     * true. Pairs with {@link osfqlExecuted} so the UI can show the `original → executed` diff.
+     */
+    originalOsfql?: string | null;
     /** Query results (if OSFQL was a MATCH). Each entry maps variable names to bound values. */
     queryResults?: Record<string, OsfqlValue>[] | null;
     /** IDs of terms produced by the OSFQL execution. */

package/dist/index.d.ts

@@ -109,7 +109,7 @@ type JsonValue$1 = string | number | boolean | null | JsonValue$1[] | object;
  * This is the single source of truth for the version constant.
  * The `scripts/release.sh` script updates this value alongside `package.json`.
  */
-declare const SDK_VERSION = "1.5.1";
+declare const SDK_VERSION = "1.6.0";
 /**
  * Authentication mode for the SDK.
  *
@@ -3391,6 +3391,40 @@ interface ConfirmResponseDto {
 }
 /** How to resolve feature conflicts when merging */
 type ConflictResolution$1 = "keep_existing" | "use_new" | "merge";
+/**
+ * A concrete order-dependence counterexample: two rules that derive conflicting
+ * values for a feature declared functional.
+ */
+interface ConfluenceConflictDto {
+    /** The two conflicting values the rules derive for the same entity. */
+    conflicting_values: string[];
+    /** The functional feature the two rules disagree on. */
+    feature: string;
+    /** The kind of conflict (currently always `"functional-dependency-violation"`). */
+    kind: string;
+}
+/** Confluence (order-independence) half of the certificate. */
+interface ConfluenceDto {
+    /** The concrete counterexample, when the rule base is not order-independent. */
+    conflict?: null | ConfluenceConflictDto;
+    /**
+     * `true` iff forward reasoning produces the same result regardless of the
+     * order rules fire in.
+     */
+    order_independent: boolean;
+    /**
+     * Why: `"monotone-least-fixpoint"`, `"congruence-closure"`, `"monotone-chase"`,
+     * `"vacuous"`, `"branching"` (disjunctive rules explore multiple models), or
+     * `"functional-conflict"` (a counterexample was found).
+     */
+    reason: string;
+    /**
+     * Number of rule interactions found (places one rule's output can trigger
+     * another). All are order-safe when `order_independent` is `true`.
+     * @min 0
+     */
+    rule_interactions: number;
+}
 /** A single constraint check in the verification result. */
 interface ConstraintCheckDto$1 {
     /** Description of the constraint. */
@@ -9675,6 +9709,16 @@ interface IngestRdfRequest$1 {
     content: string;
     /** Format of the RDF content */
     format: RdfFormatDto$1;
+    /**
+     * Whether to materialise OWL/RDFS class & property *declarations*
+     * (`:p a owl:DatatypeProperty`, `:C a owl:Class`) as queryable identity terms.
+     *
+     * Default `false` keeps declarations as schema (out of `?s ?p ?o`), the
+     * established behaviour for ordinary ingest. Set `true` only for SPARQL OWL/RDFS
+     * entailment workloads, where `?p a owl:DatatypeProperty` and `?c rdfs:subClassOf
+     * ?d` must match declarations.
+     */
+    keep_declarations?: boolean;
     /** Whether to also parse OWL ontology from the content */
     parse_ontology?: boolean;
     /** Whether to also parse SHACL shapes from the content */
@@ -13007,6 +13051,14 @@ interface OsfqlRequest$1 {
      * ```
      */
     query: string;
+    /**
+     * Opt into **reactive (streaming) mode**: after the program runs, any
+     * suspended `AWAIT` demon whose trigger is now satisfied fires
+     * automatically — no explicit `RELEASE RESIDUATIONS` needed. Defaults to
+     * `false` (demons stay suspended until an explicit RELEASE), so existing
+     * clients are byte-identical.
+     */
+    reactive?: boolean;
 }
 /** Response from executing an OSFQL program. */
 interface OsfqlResponse$1 {
@@ -14022,7 +14074,7 @@ interface QueueMetricsResponse {
     worker_utilization_pct?: number | null;
 }
 /** RDF format DTO */
-type RdfFormatDto$1 = "turtle" | "n_triples" | "rdf_xml" | "json_ld";
+type RdfFormatDto$1 = "turtle" | "n_triples" | "rdf_xml" | "json_ld" | "trig" | "nquads";
 /** Request to re-extract entities from a document */
 interface ReExtractRequest$1 {
     /** Document ID to re-extract from */
@@ -15446,6 +15498,18 @@ interface RuleAggregatorDto {
     /** Feature name whose value is aggregated within each group. */
     target: string;
 }
+/** The full certification result returned to the caller. */
+interface RuleBaseCertificateDto {
+    /** The order-independence guarantee (or the conflicting rule pair). */
+    confluence: ConfluenceDto;
+    /**
+     * `true` iff the rule base both terminates and is order-independent — the
+     * complete "won't loop, order-independent" guarantee.
+     */
+    fully_certified: boolean;
+    /** The termination guarantee (or why it could not be established). */
+    termination: TerminationDto;
+}
 /** A rule clause (OSF clause) */
 interface RuleClauseDto$1 {
     /** Constraints on variables in this clause */
@@ -18033,6 +18097,36 @@ interface TermTranslationDto {
     copied_id: string;
     original_id: string;
 }
+/** Termination half of the certificate. */
+interface TerminationDto {
+    /**
+     * Whether any rule invents fresh values (creating new entities), present only
+     * when established via the ranking function.
+     */
+    creates_new_values?: boolean | null;
+    /**
+     * When termination could not be established and an obstruction was found, the
+     * human-readable cycle of interacting positions that can grow without bound.
+     */
+    diverging_cycle?: any[] | null;
+    /**
+     * The deepest chain of freshly-created values any reasoning step can produce
+     * (the ranking-function bound). `0` means the rules never invent new values
+     * — reasoning is bounded by the existing data. Present only when terminating
+     * via the ranking function.
+     * @format int32
+     * @min 0
+     */
+    max_recursion_depth?: number | null;
+    /**
+     * How termination was established: `"bounded-recursion"` (a ranking function
+     * bounds value creation), `"decidable-fragment:<name>"` (a recognised
+     * terminating rule class), or `"undetermined"`.
+     */
+    method: string;
+    /** `true` iff forward reasoning is guaranteed to reach a fixpoint. */
+    terminates: boolean;
+}
 /** Threshold-based weak anchor for an antecedent gate. */
 interface ThresholdAnchorDto {
     /**
@@ -38381,6 +38475,15 @@ declare class Analysis<SecurityDataType = unknown> {
      * @request POST:/api/v1/analysis/sort-discovery
      */
     analyzeSortDiscovery: (data: SortDiscoveryRequestDto, params?: RequestParams) => Promise<HttpResponse<SortDiscoveryResponseDto, void>>;
+    /**
+     * @description Returns a [`RuleBaseCertificateDto`]: whether forward reasoning is guaranteed to halt (with the ranking-function depth bound), and whether it is order-independent (with the theorem discharged, or a concrete conflicting rule pair). The analysis is read-only over the tenant's knowledge base.
+     *
+     * @tags analysis
+     * @name CertifyRuleBase
+     * @summary Certify the authenticated tenant's rule base.
+     * @request GET:/api/v1/analysis/rule-base/certify
+     */
+    certifyRuleBase: (params?: RequestParams) => Promise<HttpResponse<RuleBaseCertificateDto, any>>;
     /**
      * @description The exploration must be complete (no more questions) before calling this. Creates appropriateness sorts in the hierarchy from the Duquenne-Guigues basis.
      *
@@ -43566,6 +43669,17 @@ interface ConversationMessageResponse {
     intent: string;
     /** OSFQL that was executed (if any). */
     osfqlExecuted?: string | null;
+    /**
+     * True when {@link osfqlExecuted} is a constrained-regeneration *repair* of a query the
+     * certify-or-abstain gate first rejected as hallucinated. Lets the UI surface that the answer
+     * reflects a corrected query rather than the user's literal request.
+     */
+    repaired?: boolean;
+    /**
+     * The original, rejected OSFQL the LLM first proposed — present only when {@link repaired} is
+     * true. Pairs with {@link osfqlExecuted} so the UI can show the `original → executed` diff.
+     */
+    originalOsfql?: string | null;
     /** Query results (if OSFQL was a MATCH). Each entry maps variable names to bound values. */
     queryResults?: Record<string, OsfqlValue>[] | null;
     /** IDs of terms produced by the OSFQL execution. */

package/dist/index.js

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "1.5.1";
+var SDK_VERSION = "1.6.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -6967,6 +6967,20 @@ var Analysis = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Returns a [`RuleBaseCertificateDto`]: whether forward reasoning is guaranteed to halt (with the ranking-function depth bound), and whether it is order-independent (with the theorem discharged, or a concrete conflicting rule pair). The analysis is read-only over the tenant's knowledge base.
+   *
+   * @tags analysis
+   * @name CertifyRuleBase
+   * @summary Certify the authenticated tenant's rule base.
+   * @request GET:/api/v1/analysis/rule-base/certify
+   */
+  certifyRuleBase = (params = {}) => this.http.request({
+    path: `/api/v1/analysis/rule-base/certify`,
+    method: "GET",
+    format: "json",
+    ...params
+  });
   /**
    * @description The exploration must be complete (no more questions) before calling this. Creates appropriateness sorts in the hierarchy from the Duquenne-Guigues basis.
    *
@@ -22353,6 +22367,8 @@ function ConversationMessageResponseFromApiToFront(dto) {
     conversationId: dto.conversation_id,
     intent: dto.intent,
     osfqlExecuted: dto.osfql_executed ?? void 0,
+    repaired: dto.repaired ?? false,
+    originalOsfql: dto.original_osfql ?? void 0,
     queryResults: dto.query_results ?? void 0,
     producedTermIds: dto.produced_term_ids,
     uiSortId: dto.ui_sort_id ?? void 0,