@kortexya/reasoninglayer 1.16.0 → 1.18.0

package/dist/index.cjs

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "1.16.0";
+var SDK_VERSION = "1.18.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -587,6 +587,8 @@ var USER_DATA_FIELDS = /* @__PURE__ */ new Set([
   "per_strategy_taxonomies",
   "propsOverride",
   "props_override",
+  "referencedTerms",
+  "referenced_terms",
   "roleMinimums",
   "role_minimums",
   "scope",
@@ -594,6 +596,8 @@ var USER_DATA_FIELDS = /* @__PURE__ */ new Set([
   "scores_by_name",
   "sortNames",
   "sort_names",
+  "toolResults",
+  "tool_results",
   "topK",
   "top_k",
   "values"
@@ -996,6 +1000,22 @@ var Sorts = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags sorts
+   * @name GetFuzzySubsumption
+   * @summary Get the fuzzy subsumption degree `sub ⊑· sup` between two sorts
+   * @request POST:/api/v1/sorts/subsumption/get
+   */
+  getFuzzySubsumption = (data, params = {}) => this.http.request({
+    path: `/api/v1/sorts/subsumption/get`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description Per Definition IV.5 (Milanese & Pasi 2024): ≾̇ = ((≾̃ .− ∼) ⊍ ≤)⁺
    *
@@ -1013,16 +1033,17 @@ var Sorts = class {
     ...params
   });
   /**
-   * No description
+   * @description With `?format=osfql` the sort is returned as its commented OSFQL `DEFINE` block (`text/plain`, `ETag` = SHA-256 of the body) instead of the JSON DTO — the single-sort companion of `GET /api/v1/sorts/schema`.
    *
    * @tags sorts
    * @name GetSort
    * @summary Get a sort by ID
    * @request GET:/api/v1/sorts/{id}
    */
-  getSort = (id, params = {}) => this.http.request({
+  getSort = (id, query, params = {}) => this.http.request({
     path: `/api/v1/sorts/${id}`,
     method: "GET",
+    query,
     format: "json",
     ...params
   });
@@ -1042,6 +1063,22 @@ var Sorts = class {
     format: "json",
     ...params
   });
+  /**
+   * @description The bulk companion of `?format=osfql` on the by-id route: a single deterministic, re-parseable `text/plain` block of commented `DEFINE` statements (one per sort, ordered by name) for LLM prompt conditioning and replayable export. Supports the tenant listing's filters (`name_prefix`, `include_system`, `needs_review`, `llm_extracted`, and `offset`/`limit`, applied after the deterministic ordering so pages are stable). The `ETag` is the SHA-256 of the body, so prompt-conditioning consumers get a stable cache key for "schema unchanged".
+   *
+   * @tags sorts
+   * @name GetSortsSchema
+   * @summary Export the authenticated tenant's schema as one OSFQL DDL block
+   * @request GET:/api/v1/sorts/schema
+   * @secure
+   */
+  getSortsSchema = (query, params = {}) => this.http.request({
+    path: `/api/v1/sorts/schema`,
+    method: "GET",
+    query,
+    secure: true,
+    ...params
+  });
   /**
    * No description
    *
@@ -1148,6 +1185,22 @@ var Sorts = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Subsumption is **directional**: ⊑·(s₁, s₂) and ⊑·(s₂, s₁) are different assertions. For the symmetric relation use `/api/v1/sorts/similarity`. The degree must be in [0, 1] and the assignment must keep the relation a fuzzy partial order (max–min transitivity, antisymmetry); one that does not is rejected rather than stored.
+   *
+   * @tags sorts
+   * @name SetFuzzySubsumption
+   * @summary Set the fuzzy subsumption degree `sub ⊑· sup` between two sorts
+   * @request POST:/api/v1/sorts/subsumption
+   */
+  setFuzzySubsumption = (data, params = {}) => this.http.request({
+    path: `/api/v1/sorts/subsumption`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description Similarity is symmetric: ∼(s₁, s₂) = ∼(s₂, s₁) Degree must be in [0, 1] range.
    *
@@ -1623,11 +1676,11 @@ var Inference = class {
     ...params
   });
   /**
-   * @description # DEPRECATED This endpoint is deprecated. Use `DELETE /api/v1/terms/{term_id}` for individual terms. # TRUE HOMOICONIC API # Authorization Requires X-Tenant-Id header.
+   * @description This drops the hydrated base facts, the forward-chain `persist_derived` facts and the residuation store, then forgets the hydration flag so the next request reloads the base facts from PostgreSQL. **It does not delete durable data.** The terms are the authority; this is their cache. That makes it the retraction primitive forward chaining otherwise lacks. Chaining is monotonic — delete a `blocks` edge and the derived "A blocks B" survives every later pass, so the KB keeps asserting a relationship the user removed. Clearing and re-chaining rebuilds the closure from the terms that actually exist. # History Until 2026-07-28 this handler enumerated every term in the tenant and deleted it from PostgreSQL, while calling itself "clear facts" and reporting `"Cleared N facts/rules"`. It is reachable with an ordinary tenant credential — unlike `/api/v1/admin/clear-tenant/{tenant_id}`, which gateways block — so a caller reading the name, the path or the response body had no way to know it was a tenant wipe. It destroyed a live tenant that way. Use `DELETE /api/v1/terms/{term_id}` to delete a term, and the admin route to wipe a tenant; deleting durable data must not be something an endpoint does as a side effect of its name. # Authorization Requires X-Tenant-Id header, and the path tenant must match it.
    *
    * @tags inference
    * @name ClearFacts
-   * @summary Clear all facts and rules for a tenant
+   * @summary Clear a tenant's in-memory inference working set.
    * @request DELETE:/api/v1/inference/facts/{tenant_id}
    * @secure
    */
@@ -3043,6 +3096,21 @@ var StructuredIngestion = class {
     secure: true,
     ...params
   });
+  /**
+   * @description Refused with 409 while a registered source still references the file's path (the source's adapter would otherwise hold a dangling `file_path`). After that source is unregistered, the delete succeeds (204). A missing sidecar (no such upload id) is 404.
+   *
+   * @tags structured_ingestion
+   * @name DeleteSourceFile
+   * @summary Delete a tenant-uploaded source file (#107).
+   * @request DELETE:/api/v1/sources/files/{id}
+   * @secure
+   */
+  deleteSourceFile = (id, params = {}) => this.http.request({
+    path: `/api/v1/sources/files/${id}`,
+    method: "DELETE",
+    secure: true,
+    ...params
+  });
   /**
    * @description Performs schema introspection on the source to discover types (sorts), features (fields), and relations. This is a preview operation - no data is ingested. `type_filter` narrows the discovery to a named subset **without re-registering the source** — the escape hatch a client uses after `/tables` when the source is over the discovery cap (#66, Gap 2). It conjoins with the source config's own `include_tables`: a request narrows *within* the registration, it cannot widen past it.
    *
@@ -3095,6 +3163,22 @@ var StructuredIngestion = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Walks `{base}/{tenant_id}/*\/​.meta.json`. A missing tenant dir yields an empty list (200), not 404 — a tenant that never uploaded is not an error.
+   *
+   * @tags structured_ingestion
+   * @name ListSourceFiles
+   * @summary List the calling tenant's uploaded source files (#107).
+   * @request GET:/api/v1/sources/files
+   * @secure
+   */
+  listSourceFiles = (params = {}) => this.http.request({
+    path: `/api/v1/sources/files`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -3161,6 +3245,24 @@ var StructuredIngestion = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Multipart, one field named `file`. Streamed to disk under `{base}/{tenant_id}/{id}/{safe_name}` with a `.meta.json` sidecar. The response `path` is the engine-internal location handed to `POST /api/v1/sources` as `config.file_path` (csv/parquet) or `config.database_path` (sqlite).
+   *
+   * @tags structured_ingestion
+   * @name UploadSourceFile
+   * @summary Upload a file-based source artifact for the calling tenant (#107).
+   * @request POST:/api/v1/sources/files
+   * @secure
+   */
+  uploadSourceFile = (data, params = {}) => this.http.request({
+    path: `/api/v1/sources/files`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "multipart/form-data" /* FormData */,
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/NeuroSymbolic.ts
@@ -5864,6 +5966,22 @@ var Extraction = class {
   constructor(http) {
     this.http = http;
   }
+  /**
+   * @description Read-only with respect to the knowledge base: certification inspects the tenant's sort lattice and never writes a term. Certificates *are* written to the verification certificate store, so the batch is auditable afterwards.
+   *
+   * @tags extraction
+   * @name CertifyExtraction
+   * @summary `POST /api/v1/extraction/certify` — gate a batch of extraction candidates through the OSF well-sortedness certifier before they may become durable KB content.
+   * @request POST:/api/v1/extraction/certify
+   */
+  certifyExtraction = (data, params = {}) => this.http.request({
+    path: `/api/v1/extraction/certify`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description Uses GLiNER2 (zero-shot NER) with sort names from the tenant's knowledge base, guaranteeing that all returned entity labels are valid sort names. Label selection (when no explicit labels provided): Embed the input text and ANN-search the pre-computed sort embedding index (Qdrant) for the most semantically similar HPO sorts. This is O(log n) and typically returns 20-100 highly relevant labels from 19K+ HPO sorts. Requires: - GLiNER2 NER service (`GLINER_NER_URL`) - Qdrant vector store for semantic label selection If either is not configured, returns a 500 error.
    *
@@ -6261,7 +6379,7 @@ var Query = class {
     this.http = http;
   }
   /**
-   * @description Returns all terms with the specified sort OR any of its subtypes. This implements proper OSF polymorphic query semantics where querying a parent sort returns all instances of that sort and its descendants.
+   * @description Returns all terms with the specified sort OR any of its subtypes. This implements proper OSF polymorphic query semantics where querying a parent sort returns all instances of that sort and its descendants. ## Resolving `sort_name` A name can denote more than one id (see `sort_name_candidates`), and no cheap probe tells which of them the query can actually answer from: on the production adapter `get_sort` and `get_sort_ids_by_names` are bare reads of an in-memory cache with no persistence fallback, while the query's own `get_compatible_sorts` does fall back to Postgres. Confirming a candidate with `get_sort` would therefore 404 every tenant sort created before the last restart — a guard strictly stricter than the thing it guards. So the candidates are **tried** against the real query, in order, and the first that answers wins; only `SortNotFound` moves on to the next, every other failure is returned as-is. When the first candidate answers — the common case — the route runs exactly one term query, as it always did. A phantom id (minted into the tenant lattice by ingestion and never persisted, #138) cannot be returned: the query authority refuses it and the loop skips past it. When no candidate answers, the sort is not queryable and the honest reply is 404 naming the sort the CALLER asked for — never a 400 leaking an internal `SortId` the caller never supplied.
    *
    * @tags query
    * @name FindBySort
@@ -6655,7 +6773,7 @@ var Reasoning = class {
     this.http = http;
   }
   /**
-   * @description POST /api/v1/reasoning/disentailment Disentailment A =/=> B means: "if A holds, then B must NOT hold" Returns whether the disentailment is violated (conflict: both A and B hold)
+   * @description POST /api/v1/reasoning/disentailment Disentailment A =/=> B means: "if A holds, then B must NOT hold". Returns whether the disentailment is violated — the conflict where the facts establish A and B follows anyway. This is hierarchy-aware and graded on the same footing as the entailment route, so a conflict reachable only through the sort lattice (a `contaminated` clause held by a `lead_paint` fact that subsumes it) is detected without that clause being supplied as a fact. `A ⇏ B` is violated exactly to the degree `A ⇒ B` is established, so `degree` here reports the complement: how strongly the disentailment still holds.
    *
    * @tags reasoning
    * @name Disentailment
@@ -6671,7 +6789,7 @@ var Reasoning = class {
     ...params
   });
   /**
-   * @description POST /api/v1/reasoning/entailment Returns whether antecedent entails consequent
+   * @description POST /api/v1/reasoning/entailment Answers `facts ⊨ antecedent ⇒ consequent`, hierarchy-aware and graded. A clause holds in the fact base to the degree that some fact *witnesses* it — that is, to the degree the clause subsumes a fact — so a `sparrow` fact establishes the clause `animal` without an `animal` fact being supplied. The consequent is additionally established when it subsumes the antecedent it would follow from. See [`osfkb_domain::operations::homoiconic_entailment`] for the full semantics. `entails` is the crisp reading of `degree`; `degree`, `antecedent_degree` and `consequent_degree` are computed from the sort lattice (crisply, and through explicit fuzzy `⊑·` relations and approved sort similarity), never cast from the boolean.
    *
    * @tags reasoning
    * @name Entailment
@@ -8700,6 +8818,20 @@ var Health = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags health
+   * @name HealthCheckApi
+   * @summary `GET /api/v1/health` — the same enriched health check under the `/api/v1` prefix. The playground front proxy forwards only `/api/*` to the engine (and answers the bare `/health` itself with a static OK), so THIS is the path that makes the deployed `build_info.version` publicly readable — a stale rollout must never be indistinguishable from a fresh one.
+   * @request GET:/api/v1/health
+   */
+  healthCheckApi = (params = {}) => this.http.request({
+    path: `/api/v1/health`,
+    method: "GET",
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/Scheduling.ts
@@ -9040,6 +9172,24 @@ var Generation = class {
     format: "json",
     ...params
   });
+  /**
+   * @description POST /api/v1/text/generate
+   *
+   * @tags generation
+   * @name GenerateText
+   * @summary Run the caller's system prompt over their text.
+   * @request POST:/api/v1/text/generate
+   * @secure
+   */
+  generateText = (data, params = {}) => this.http.request({
+    path: `/api/v1/text/generate`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description Returns `503` when no in-process Gemma is loaded (server started without `OSFKB_OSFQL_GEMMA_DIR`), `400` on an empty prompt, and `422` when the tenant has no persisted lattice to constrain to (ingest a theory with `persist:true` first).
    *
@@ -9376,6 +9526,58 @@ var Compliance = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name CreateDsr
+   * @summary File a GDPR data subject request
+   * @request POST:/api/v1/dsr
+   * @secure
+   */
+  createDsr = (data, params = {}) => this.http.request({
+    path: `/api/v1/dsr`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description **Dry run by default.** An exact match on an identifying feature is the only deterministic way to resolve a person to terms, but exactness is not uniqueness — two people share a name. Erasing on a bare match would silently destroy a homonym's data, and erasure is irreversible, so the plan has to be inspectable before it runs. Pass `confirm: true` once the match has been reviewed.
+   *
+   * @tags compliance
+   * @name EraseSubject
+   * @summary Plan or execute erasure of a data subject's terms
+   * @request POST:/api/v1/dsr/{id}/erase
+   * @secure
+   */
+  eraseSubject = (id, data, params = {}) => this.http.request({
+    path: `/api/v1/dsr/${id}/erase`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name GetDsr
+   * @summary Read a data subject request
+   * @request GET:/api/v1/dsr/{id}
+   * @secure
+   */
+  getDsr = (id, params = {}) => this.http.request({
+    path: `/api/v1/dsr/${id}`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -9409,6 +9611,22 @@ var Compliance = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name ListDsr
+   * @summary List a data subject's requests
+   * @request GET:/api/v1/dsr
+   * @secure
+   */
+  listDsr = (params = {}) => this.http.request({
+    path: `/api/v1/dsr`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -9890,6 +10108,24 @@ var OntologyBridge = class {
     format: "json",
     ...params
   });
+  /**
+   * @description The gap this closes (#133): the engine could lower OSFQL to a source's native language and could execute native queries, and the two were never reachable together over HTTP. `POST /api/v1/osfql` runs against the knowledge base and never consults a binding; `POST /api/v1/ontology/transpile` emits the query text and stops. A `transpile`-mode source — which deliberately ingests nothing — therefore had no way to be queried at all, and asking about its data returned an empty result indistinguishable from a broken connector. The dialect is derived from the source's type, never taken from the caller: the binding says which source answers for the sort, and that source's type is the only dialect that could run. Letting a caller name one would let them ask for Cypher against Postgres. The emitted query is returned with the rows. Transpile mode's claim is that OSFQL becomes a native query against the operator's own database; returning only rows leaves that unverifiable.
+   *
+   * @tags ontology_bridge
+   * @name ExecuteTranspiled
+   * @summary Transpile an OSFQL MATCH and execute it on the source it is bound to.
+   * @request POST:/api/v1/ontology/query
+   * @secure
+   */
+  executeTranspiled = (data, params = {}) => this.http.request({
+    path: `/api/v1/ontology/query`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description Produces query tools, write tools, and inference tools from the current sort hierarchy and SQL bindings, along with a system prompt suitable for grounding an LLM.
    *
@@ -9959,7 +10195,7 @@ var OntologyBridge = class {
     ...params
   });
   /**
-   * @description Parses the OSFQL query, compiles it, and transpiles the first `ScanBySort` operation to SQL using the current sort-table bindings.
+   * @description Parses the OSFQL query, compiles it, and transpiles EVERY `ScanBySort` operation into one statement using the current sort-table bindings — a JOIN for the SQL dialects, a multi-pattern MATCH for Cypher. A plan operation that is not a scan is refused by name rather than dropped: `fully_transpilable` is what a caller checks to decide whether the emitted text is the whole question, and it reported `true` for a query half of which was never emitted (#134).
    *
    * @tags ontology_bridge
    * @name Transpile
@@ -10258,6 +10494,24 @@ var Speakers = class {
     format: "json",
     ...params
   });
+  /**
+   * @description POST /api/v1/speakers/identify
+   *
+   * @tags speakers
+   * @name IdentifySpeakers
+   * @summary Identify which enrolled voices speak in a piece of audio — no transcript.
+   * @request POST:/api/v1/speakers/identify
+   * @secure
+   */
+  identifySpeakers = (data, params = {}) => this.http.request({
+    path: `/api/v1/speakers/identify`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description GET /api/v1/speakers
    *
@@ -10524,6 +10778,22 @@ var Documents = class {
   constructor(http) {
     this.http = http;
   }
+  /**
+   * No description
+   *
+   * @tags documents
+   * @name EraseDocument
+   * @summary Erase a document and everything extracted from it
+   * @request DELETE:/api/v1/documents/{id}
+   * @secure
+   */
+  eraseDocument = (id, params = {}) => this.http.request({
+    path: `/api/v1/documents/${id}`,
+    method: "DELETE",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -11594,6 +11864,32 @@ var OntologyExport = class {
   });
 };
 
+// src/api-spec/generated/Embeddings.ts
+var Embeddings = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description POST /api/v1/embeddings/rank
+   *
+   * @tags embeddings
+   * @name RankEmbeddings
+   * @summary Score every candidate against the query by embedding cosine similarity.
+   * @request POST:/api/v1/embeddings/rank
+   * @secure
+   */
+  rankEmbeddings = (data, params = {}) => this.http.request({
+    path: `/api/v1/embeddings/rank`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
 // src/normalizers/sorts.ts
 function ConstraintDtoFromApiToFront(dto) {
   if (dto.type === "FuzzyPathSimilarity") {
@@ -19742,20 +20038,21 @@ var IngestionSession = class {
         }));
         return;
       }
-      const timer = setTimeout(resolve, ms);
+      let onAbort;
+      const timer = setTimeout(() => {
+        if (signal && onAbort) {
+          signal.removeEventListener("abort", onAbort);
+        }
+        resolve();
+      }, ms);
       if (signal) {
-        const onAbort = () => {
+        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();
-        };
       }
     });
   }
@@ -20540,8 +20837,10 @@ function EvidenceAssessmentRequestFromFrontToApi(model) {
   };
 }
 function EvidenceItemDtoFromApiToFront(dto) {
+  const wireDescription = dto.description;
   return {
     contribution: dto.contribution,
+    description: wireDescription ?? null,
     qualityWeight: dto.quality_weight,
     supports: dto.supports,
     termId: dto.term_id
@@ -20696,6 +20995,13 @@ var ReasoningClient = class {
   /**
    * Assess the truthfulness/validity of a subject based on related evidence.
    *
+   * @remarks
+   * Each item in the supporting/contradicting breakdown carries a
+   * `description` — the evidence term's own sentence,
+   * e.g. `"Aspirin reduces_risk_of Cancer"` — so evidence can be rendered
+   * without a second lookup by `termId`. It is `null` against a backend that
+   * predates the field.
+   *
    * @param request - Evidence assessment request.
    * @returns Assessment result with truthfulness score, label, and evidence breakdown.
    */
@@ -28750,7 +29056,15 @@ function PaperMetadataFromApiToFront(dto) {
     abstractText: dto.abstract_text ?? null,
     citationCount: dto.citation_count ?? null,
     source: dto.source,
-    fullTextUrl: dto.full_text_url ?? null
+    fullTextUrl: dto.full_text_url ?? null,
+    paperKey: dto.paper_key ?? null
+  };
+}
+function PaperRefFromApiToFront(dto) {
+  return {
+    paperKey: dto.paper_key,
+    doi: dto.doi ?? null,
+    title: dto.title
   };
 }
 function PaperSearchResultFromApiToFront(dto) {
@@ -28784,6 +29098,8 @@ function ResearchCycleResultFromApiToFront(dto) {
     papersIngested: dto.papers_ingested,
     claimsVerified: dto.claims_verified,
     contradictionsDetected: dto.contradictions_detected,
+    contradictionsResolved: dto.contradictions_resolved ?? 0,
+    claimsMerged: dto.claims_merged ?? 0,
     processingTimeMs: dto.processing_time_ms,
     searchQueries: dto.search_queries ?? []
   };
@@ -28796,6 +29112,7 @@ function ResearchSessionResponseFromApiToFront(raw) {
     status: dto.status,
     error: dto.error ?? null,
     cycles: (dto.cycles ?? []).map(ResearchCycleResultFromApiToFront),
+    papers: (dto.papers ?? []).map(PaperMetadataFromApiToFront),
     totalPapersIngested: dto.total_papers_ingested,
     totalFindings: dto.total_findings,
     totalContradictions: dto.total_contradictions,
@@ -28840,7 +29157,9 @@ function EvidenceItemSummaryFromApiToFront(dto) {
     qualityWeight: dto.quality_weight,
     supports: dto.supports,
     contribution: dto.contribution,
-    paperDoi: dto.paper_doi ?? null
+    paperDoi: dto.paper_doi ?? null,
+    paperKey: dto.paper_key ?? null,
+    paperTitle: dto.paper_title ?? null
   };
 }
 function ProvenanceStepFromApiToFront(dto) {
@@ -28851,6 +29170,13 @@ function ProvenanceStepFromApiToFront(dto) {
     timestamp: dto.timestamp ?? null
   };
 }
+function ResiduatedFeatureFromApiToFront(dto) {
+  return {
+    featureName: dto.feature_name,
+    neededSort: dto.needed_sort ?? null,
+    infoGain: dto.info_gain
+  };
+}
 function ResearchFindingFromApiToFront(dto) {
   return {
     claimId: dto.claim_id,
@@ -28861,7 +29187,9 @@ function ResearchFindingFromApiToFront(dto) {
     contradictingEvidence: (dto.contradicting_evidence ?? []).map(EvidenceItemSummaryFromApiToFront),
     provenanceChain: (dto.provenance_chain ?? []).map(ProvenanceStepFromApiToFront),
     residuated: dto.residuated,
-    residuationReason: dto.residuation_reason ?? null
+    residuationReason: dto.residuation_reason ?? null,
+    residuatedFeatures: (dto.residuated_features ?? []).map(ResiduatedFeatureFromApiToFront),
+    sources: (dto.sources ?? []).map(PaperRefFromApiToFront)
   };
 }
 function ResearchFindingsResponseFromApiToFront(raw) {
@@ -28889,6 +29217,17 @@ function ResearchGapsResponseFromApiToFront(raw) {
     total: dto.total
   };
 }
+function ContradictionResolutionFromApiToFront(dto) {
+  return {
+    preferredClaimId: dto.preferred_claim_id,
+    dismissedClaimId: dto.dismissed_claim_id,
+    preferredTruthfulness: dto.preferred_truthfulness,
+    dismissedTruthfulness: dto.dismissed_truthfulness,
+    strategy: dto.strategy,
+    confidence: dto.confidence,
+    explanation: dto.explanation
+  };
+}
 function ContradictionFromApiToFront(dto) {
   return {
     claimAId: dto.claim_a_id,
@@ -28896,7 +29235,10 @@ function ContradictionFromApiToFront(dto) {
     statementA: dto.statement_a,
     statementB: dto.statement_b,
     confidence: dto.confidence,
-    explanation: dto.explanation
+    explanation: dto.explanation,
+    resolution: dto.resolution ? ContradictionResolutionFromApiToFront(dto.resolution) : null,
+    claimASources: (dto.claim_a_sources ?? []).map(PaperRefFromApiToFront),
+    claimBSources: (dto.claim_b_sources ?? []).map(PaperRefFromApiToFront)
   };
 }
 function ResearchContradictionsResponseFromApiToFront(raw) {
@@ -28917,7 +29259,9 @@ function ResearchStatisticsFromApiToFront(dto) {
     totalContradictions: dto.total_contradictions,
     totalProcessingTimeMs: dto.total_processing_time_ms,
     gapsResolved: dto.gaps_resolved,
-    gapsRemaining: dto.gaps_remaining
+    gapsRemaining: dto.gaps_remaining,
+    claimsMerged: dto.claims_merged ?? 0,
+    contradictionsResolved: dto.contradictions_resolved ?? 0
   };
 }
 function ReportVerificationFromApiToFront(dto) {
@@ -28993,7 +29337,8 @@ function IngestPaperRequestFromFrontToApi(model) {
 function VerifyClaimRequestFromFrontToApi(model) {
   return {
     claim_term_id: model.claimTermId,
-    evidence_sort_id: model.evidenceSortId
+    evidence_sort_id: model.evidenceSortId,
+    session_id: model.sessionId
   };
 }
 
@@ -36606,6 +36951,81 @@ var ConnectorsClient = class {
   }
 };
 
+// src/normalizers/embeddings.ts
+function EmbeddingRankRequestFromFrontToApi(model) {
+  return {
+    candidates: model.candidates ?? [],
+    query: model.query
+  };
+}
+function EmbeddingRankResponseFromApiToFront(dto) {
+  return {
+    scores: dto.scores ?? []
+  };
+}
+
+// src/resources/embeddings.ts
+var EmbeddingsClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Score every candidate against the query by embedding cosine similarity.
+   *
+   * @param request - The query and the candidate texts to score against it.
+   * @returns `scores` — one cosine similarity in `[-1, 1]` per candidate,
+   *   **index-aligned with `request.candidates`** (index `i` scores
+   *   `candidates[i]`) and the same length, so the scores can be zipped straight
+   *   back onto whatever was retrieved. Higher is more similar; a candidate
+   *   whose text is blank scores `0`.
+   * @throws {BadRequestError} `400` — the query is blank, the candidate list is
+   *   over the backend's 512-candidate cap, or the query / a candidate is over
+   *   8192 characters.
+   * @throws {ApiError} `503` when the deployment has **no embedding backend
+   *   configured** (or its embedder is unreachable / misconfigured). The SDK
+   *   surfaces every 5xx as an `InternalServerError`; read its `status` to tell
+   *   `503` (no embedder) from `500` (ranking failed).
+   *
+   * @remarks
+   * Distinguish "no embedder" from "no similarity": a deployment without an
+   * embedding backend answers `503` rather than a fabricated score, precisely so
+   * a caller cannot mistake it for "everything scored 0" and silently rank by
+   * noise. The documented fallback on a `503` is to keep the source order.
+   *
+   * An empty `candidates` list is valid, not an error: it answers `200` with an
+   * empty `scores` array, so a caller that retrieved nothing still gets a
+   * well-formed, index-aligned response.
+   *
+   * A `0` score is absence of signal, not evidence of dissimilarity — it is also
+   * what an orthogonal candidate and a blank candidate both receive.
+   *
+   * @example
+   * ```typescript
+   * const retrieved = [
+   *   { id: 'doc-1', text: 'Chaperones assist protein folding in the cytosol.' },
+   *   { id: 'doc-2', text: 'Quarterly revenue rose 12% year over year.' },
+   * ];
+   *
+   * const { scores } = await client.embeddings.rank({
+   *   query: 'how proteins fold',
+   *   candidates: retrieved.map((doc) => doc.text),
+   * });
+   *
+   * // Scores are index-aligned — zip them back onto what was retrieved.
+   * const ranked = retrieved
+   *   .map((doc, i) => ({ doc, score: scores[i] }))
+   *   .sort((a, b) => b.score - a.score);
+   * ```
+   */
+  async rank(request) {
+    const response = await this.api.rankEmbeddings(EmbeddingRankRequestFromFrontToApi(request));
+    return EmbeddingRankResponseFromApiToFront(response.data);
+  }
+};
+
 // src/client.ts
 var ReasoningLayerClient = class {
   /** Sort (type hierarchy) operations. */
@@ -36792,6 +37212,8 @@ var ReasoningLayerClient = class {
   speech;
   /** External data connectors — register / list / remove / connect / disconnect + OAuth callback. */
   connectors;
+  /** Embedding-space ranking — cosine score per candidate against a query, index-aligned. */
+  embeddings;
   // ─── Group Caches ─────────────────────────────────────────────────
   _core;
   _ai;
@@ -37109,6 +37531,7 @@ var ReasoningLayerClient = class {
     this.speakers = new SpeakersClient(new Speakers(generatedHttp));
     this.speech = new SpeechClient(new Speech(generatedHttp));
     this.connectors = new ConnectorsClient(new Connectors(generatedHttp));
+    this.embeddings = new EmbeddingsClient(new Embeddings(generatedHttp));
   }
 };
 
@@ -37392,6 +37815,9 @@ var speech_exports = {};
 // src/types/connectors.ts
 var connectors_exports = {};
 
+// src/types/embeddings.ts
+var embeddings_exports = {};
+
 // src/builders/value.ts
 var Value = {
   /**
@@ -38431,6 +38857,7 @@ exports.Demo = demo_exports;
 exports.Discovery = discovery_exports;
 exports.DocumentCheck = document_check_exports;
 exports.Documents = documents_exports;
+exports.Embeddings = embeddings_exports;
 exports.Execution = execution_exports;
 exports.Extract = extract_exports;
 exports.Feasibility = feasibility_exports;