@kortexya/reasoninglayer 1.14.0 → 1.16.0

package/dist/index.cjs

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "1.14.0";
+var SDK_VERSION = "1.16.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -550,6 +550,8 @@ var USER_DATA_FIELDS = /* @__PURE__ */ new Set([
   "antecedentFeatures",
   "antecedent_features",
   "bindings",
+  "classScores",
+  "class_scores",
   "coefficients",
   "conceptValues",
   "concept_values",
@@ -1162,6 +1164,22 @@ var Sorts = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Poll this after `POST /api/v1/sorts/index` (which is fire-and-forget) to know whether the embedding pass is still `running`, has completed (`last_indexed_count`), or failed (`last_error`).
+   *
+   * @tags sorts
+   * @name SortIndexStatus
+   * @summary GET /api/v1/sorts/index/status
+   * @request GET:/api/v1/sorts/index/status
+   * @secure
+   */
+  sortIndexStatus = (params = {}) => this.http.request({
+    path: `/api/v1/sorts/index/status`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -1414,9 +1432,10 @@ var Terms = class {
    * @request GET:/api/v1/terms
    * @secure
    */
-  listTerms = (params = {}) => this.http.request({
+  listTerms = (query, params = {}) => this.http.request({
     path: `/api/v1/terms`,
     method: "GET",
+    query,
     secure: true,
     format: "json",
     ...params
@@ -1496,7 +1515,7 @@ var Inference = class {
     ...params
   });
   /**
-   * @description # TRUE HOMOICONIC API Request contains a goal term and optional constraints. Response returns solutions with term-based substitutions. ## Temporal Reasoning Use constraints to filter by temporal relations: ```json { "goal": {"sort_name": "Employment", "features": {"valid_to": {"name": "?EndTime"}}}, "constraints": [{"type": "Guard", "left": "?EndTime", "op": "lt", "right": "1583020800000"}] } ``` # Authorization Requires X-Tenant-Id header.
+   * @description # TRUE HOMOICONIC API Request contains a goal term and optional constraints. Response returns solutions with term-based substitutions. ## Temporal Reasoning Use constraints to filter by temporal relations: ```json { "goal": {"sort_name": "Employment", "features": {"valid_to": {"name": "?EndTime"}}}, "constraints": [{"type": "Guard", "left": "?EndTime", "op": "lt", "right": "1583020800000"}] } ``` # Authorization Requires X-Tenant-Id header. Traced: this is the path the zanzibar gateway hits for every permission check, so it is where an end-to-end trace either explains a slow request or does not. `skip_all` because the request body can be large and has no business in a span attribute.
    *
    * @tags inference
    * @name BackwardChain
@@ -1753,9 +1772,10 @@ var Inference = class {
    * @request GET:/api/v1/inference/facts/{tenant_id}
    * @secure
    */
-  getFacts = (tenantId, params = {}) => this.http.request({
+  getFacts = (tenantId, query, params = {}) => this.http.request({
     path: `/api/v1/inference/facts/${tenantId}`,
     method: "GET",
+    query,
     secure: true,
     format: "json",
     ...params
@@ -1950,6 +1970,21 @@ var Cognitive = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Server->client only (thinking / tool / inference / phase events). It's plain HTTP, so it traverses the zanzibar gateway — which proxies HTTP and mints `X-Tenant-Id`, but does NOT proxy WebSocket upgrades. Client->server control (ChatMessage / Abort / Redirect) is a separate POST for SSE clients. Auth and the ownership gate are identical to the WS handler. Endpoint: `GET /api/v1/cognitive/agents/{agent_id}/events` (Accept: text/event-stream)
+   *
+   * @tags cognitive
+   * @name CognitiveSseHandler
+   * @summary SSE transport for the *same* cognitive event stream as `cognitive_ws_handler`.
+   * @request GET:/api/v1/cognitive/agents/{agent_id}/events
+   * @secure
+   */
+  cognitiveSseHandler = (agentId, params = {}) => this.http.request({
+    path: `/api/v1/cognitive/agents/${agentId}/events`,
+    method: "GET",
+    secure: true,
+    ...params
+  });
   /**
    * @description ## Example ```bash curl -X POST http://localhost:3000/api/v1/cognitive/agents \ -H "Content-Type: application/json" \ -d '{"name": "reasoning_agent", "tenant_id": "..."}' ```
    *
@@ -1998,6 +2033,20 @@ var Cognitive = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Reads the persisted, tenant-scoped `ActionReviewConfig` from the registry (hydrating agents first so a restored snapshot's config is visible), or sensible defaults when none has been set. Complements the PUT so the UI's oversight editor can load what's actually stored instead of a local stand-in.
+   *
+   * @tags cognitive
+   * @name GetActionReviewConfigHandler
+   * @summary Get the tenant's current HITL action-review (oversight) configuration.
+   * @request GET:/api/v1/cognitive/agents/action-review-config
+   */
+  getActionReviewConfigHandler = (params = {}) => this.http.request({
+    path: `/api/v1/cognitive/agents/action-review-config`,
+    method: "GET",
+    format: "json",
+    ...params
+  });
   /**
    * @description Returns drives, deficits, curiosity targets, and the dominant drive. Tenant is identified by the `X-Tenant-Id` header.
    *
@@ -2014,6 +2063,22 @@ var Cognitive = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags cognitive
+   * @name GetAgentPlanHandler
+   * @summary GET /api/v1/cognitive/agents/{agent_id}/plan — inspect an agent's committed intentions: the plan/HTN step sequence, `current_step` (executed-so-far), and status. Read-only observability for the planner verification harness (§4.2).
+   * @request GET:/api/v1/cognitive/agents/{agent_id}/plan
+   * @secure
+   */
+  getAgentPlanHandler = (agentId, params = {}) => this.http.request({
+    path: `/api/v1/cognitive/agents/${agentId}/plan`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -2030,6 +2095,22 @@ var Cognitive = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags cognitive
+   * @name GetAgentWorldModelHandler
+   * @summary GET /api/v1/cognitive/agents/{agent_id}/world-model — inspect an agent's learned transition model P(s'|s,a). Read-only observability for the world-model verification harness (§4.2 of the productionization plan) and a future UI surface: returns the agent's transition rules with resolved sort names + the rule count. An agent with no learned transitions yet returns `has_world_model:false` (or an empty rule set), which is a valid state — not an error.
+   * @request GET:/api/v1/cognitive/agents/{agent_id}/world-model
+   * @secure
+   */
+  getAgentWorldModelHandler = (agentId, params = {}) => this.http.request({
+    path: `/api/v1/cognitive/agents/${agentId}/world-model`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description Returns beliefs, goals, intentions, pending perceptions, activations, recent episodes, and rule utilities. Tenant is identified by the `X-Tenant-Id` header.
    *
@@ -2094,6 +2175,22 @@ var Cognitive = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags cognitive
+   * @name PauseAgentHandler
+   * @summary POST /api/v1/cognitive/agents/{agent_id}/pause — pause an agent (persisted).
+   * @request POST:/api/v1/cognitive/agents/{agent_id}/pause
+   * @secure
+   */
+  pauseAgentHandler = (agentId, params = {}) => this.http.request({
+    path: `/api/v1/cognitive/agents/${agentId}/pause`,
+    method: "POST",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description This enables the agent to learn from user corrections and preferences. All feedback is stored as Ψ-terms for TRUE HOMOICONICITY - they are queryable, unifiable, and can be reasoned about by the agent. ## Feedback Rating - `+1`: Result was correct/helpful - increases rule utility - `0`: Neutral - no learning - `-1`: Result was wrong - decreases rule utility, triggers correction learning ## Corrections When a correction is provided: 1. A `user_correction` Ψ-term is created with the correct answer pattern 2. Rules that produced the wrong result have their utility decreased 3. A new rule may be learned from the correction ## Preferences When a preference is provided: 1. A `user_preference` Ψ-term is created (subsort of constraint) 2. Future reasoning can consider this preference
    *
@@ -2126,6 +2223,22 @@ var Cognitive = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags cognitive
+   * @name ResumeAgentHandler
+   * @summary POST /api/v1/cognitive/agents/{agent_id}/resume — resume a paused agent.
+   * @request POST:/api/v1/cognitive/agents/{agent_id}/resume
+   * @secure
+   */
+  resumeAgentHandler = (agentId, params = {}) => this.http.request({
+    path: `/api/v1/cognitive/agents/${agentId}/resume`,
+    method: "POST",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description Executes: perceive → reason → act → learn
    *
@@ -2190,6 +2303,22 @@ var Cognitive = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags cognitive
+   * @name StopAgentHandler
+   * @summary POST /api/v1/cognitive/agents/{agent_id}/stop — soft-stop an agent (persisted; distinct from DELETE, which permanently destroys the agent + its goals).
+   * @request POST:/api/v1/cognitive/agents/{agent_id}/stop
+   * @secure
+   */
+  stopAgentHandler = (agentId, params = {}) => this.http.request({
+    path: `/api/v1/cognitive/agents/${agentId}/stop`,
+    method: "POST",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description When subscribed, the agent will receive notifications about changes to the specified sorts and features, enabling reactive behavior. ## Example ```bash curl -X POST http://localhost:3000/api/v1/cognitive/agents/subscribe \ -H "Content-Type: application/json" \ -d '{"agent_id": "...", "tenant_id": "...", "watched_sorts": ["person", "event"]}' ```
    *
@@ -2645,7 +2774,7 @@ var Ingestion = class {
     ...params
   });
   /**
-   * @description POST /api/v1/ingest/document This endpoint accepts a document (as base64 or URL) and: 1. Parses it to Markdown using the document parser service (Docling) 2. Processes the Markdown through the existing ingestion pipeline 3. Returns combined statistics from both stages # Headers - `X-Tenant-Id`: Tenant ID for multi-tenancy isolation (required) # Request Body - `document`: Document source (base64 or URL) - `document_type`: Optional type hint (auto-detected if not provided) - `owner_id`: User ID who owns the ingested data - `ocr_config`: Optional OCR/parsing configuration - `ingestion_config`: Optional markdown ingestion configuration # Response - `success`: Whether ingestion completed successfully - `parse_stats`: Statistics from document parsing - `metadata`: Extracted document metadata - `ingestion_stats`: Statistics from markdown ingestion - `pending_review`: Entities that need human review
+   * @description POST /api/v1/ingest/document This endpoint accepts a document (as base64 or URL) and: 1. Parses it to Markdown using the document parser service (Docling) 2. Returns the generated Markdown to the caller 3. Unless `parse_only` is true, processes the Markdown through ingestion 4. Returns combined statistics from the completed stages # Headers - `X-Tenant-Id`: Tenant ID for multi-tenancy isolation (required) # Request Body - `document`: Document source (base64 or URL) - `document_type`: Optional type hint (auto-detected if not provided) - `owner_id`: User ID who owns the ingested data - `ocr_config`: Optional OCR/parsing configuration - `ingestion_config`: Optional markdown ingestion configuration - `parse_only`: Return Markdown without creating sessions or semantic terms # Response - `success`: Whether ingestion completed successfully - `parse_stats`: Statistics from document parsing - `metadata`: Extracted document metadata - `markdown`: Markdown generated by Docling/OCR - `ingestion_stats`: Statistics from markdown ingestion - `pending_review`: Entities that need human review
    *
    * @tags ingestion
    * @name IngestDocument
@@ -2680,6 +2809,24 @@ var Ingestion = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Two import targets, selected by [`IngestKifRequest::persist`]: * `persist == false` (default): the import runs in a fresh, **request-scoped** world (no shared tenant state is mutated), so the inference is attributable entirely to the submitted SUO-KIF. The tenant id only namespaces the ephemeral sorts. * `persist == true`: the import lands in the **tenant's persistent substrate** — the shared per-tenant `VersionedHierarchy` and `DomainTermStore` ([`AppState::inference_for_auth`]). The sorts, facts, and rules survive the request and are visible to every subsequent call on the same tenant. Caches are invalidated afterwards so the next query observes the new state. Either way, authentication is required and an optional `goal`/`query` is proved against the axioms produced by *this* import.
+   *
+   * @tags ingestion
+   * @name IngestKif
+   * @summary Import SUO-KIF and, optionally, prove a ground goal against the imported axioms.
+   * @request POST:/api/v1/ingest/kif
+   * @secure
+   */
+  ingestKif = (data, params = {}) => this.http.request({
+    path: `/api/v1/ingest/kif`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description POST /api/v1/ingest/markdown This endpoint accepts markdown content and extracts entities using: 1. Semantic chunking for large documents 2. LLM-based entity extraction 3. Sort reconciliation (optionally creating new sorts) 4. Entity deduplication against existing knowledge base # Headers - `X-Tenant-Id`: Tenant ID for multi-tenancy isolation (required) # Request Body - `content`: The markdown content to ingest - `owner_id`: User ID who owns the ingested data - `config`: Optional configuration overrides # Response - `success`: Whether ingestion completed successfully - `stats`: Statistics about the ingestion (chunks, entities, sorts) - `pending_review`: Entities that need human review for deduplication # Size Limits - Maximum content size is 100KB. For larger documents, use the document ingestion endpoint which handles chunking automatically.
    *
@@ -2980,6 +3127,22 @@ var StructuredIngestion = class {
     format: "json",
     ...params
   });
+  /**
+   * @description The pre-registration half of #71's mode-discovery surface: a client rendering a "new source" picker learns, at type-selection time, which types registration would accept and which write-path modes each would serve — without constructing a source (postgres, for example, opens a connection pool eagerly). Static per build, so no tenant state is consulted; auth is still required, as for every route under `/api/v1`.
+   *
+   * @tags structured_ingestion
+   * @name ListSourceTypesCatalog
+   * @summary List the source types this build can register, with their mode capabilities.
+   * @request GET:/api/v1/sources/types
+   * @secure
+   */
+  listSourceTypesCatalog = (params = {}) => this.http.request({
+    path: `/api/v1/sources/types`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description Creates a connector instance from the provided configuration and registers it with the structured ingestion service for subsequent schema discovery and data ingestion.
    *
@@ -3544,6 +3707,60 @@ var Communities = class {
   constructor(http) {
     this.http = http;
   }
+  /**
+   * @description `POST /api/v1/analysis/centrality` Builds the tenant's reference graph from its terms (the same read-only projection community detection uses) and computes the requested centrality measure. Centrality is a **read-only analytic** — it never asserts facts or feeds the chainer. Scores are returned sorted descending (ties broken by node id for determinism), optionally truncated to `top_k`.
+   *
+   * @tags communities
+   * @name ComputeCentrality
+   * @summary Compute a node-centrality measure over the tenant's reference graph.
+   * @request POST:/api/v1/analysis/centrality
+   * @secure
+   */
+  computeCentrality = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/centrality`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description `POST /api/v1/analysis/cohesion` Read-only: total triangle count plus the per-node local clustering coefficient (sorted descending, ties broken by node id).
+   *
+   * @tags communities
+   * @name ComputeCohesion
+   * @summary Structural-cohesion metrics over the tenant's reference graph.
+   * @request POST:/api/v1/analysis/cohesion
+   * @secure
+   */
+  computeCohesion = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/cohesion`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description `POST /api/v1/analysis/path` Read-only: BFS shortest path (`source..=target`) over the undirected reference graph, or `null` when `target` is unreachable.
+   *
+   * @tags communities
+   * @name ComputePath
+   * @summary Shortest path between two nodes (and the graph's connected-component count).
+   * @request POST:/api/v1/analysis/path
+   * @secure
+   */
+  computePath = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/path`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description POST /api/v1/communities/detect Runs Leiden community detection on terms belonging to the specified tenant. Creates Community and CommunityMembership PsiTerms in the knowledge base.
    *
@@ -3562,6 +3779,21 @@ var Communities = class {
     format: "json",
     ...params
   });
+  /**
+   * @description `GET /api/v1/graph/export?tenant_id=…&format=graphml|gexf|csv-nodes|csv-edges|dot` Read-only: returns the serialized graph as raw text with the matching content type. The graph is the same `Value::Reference` projection the analytics use, labelled by each term's `name` feature.
+   *
+   * @tags communities
+   * @name ExportGraph
+   * @summary Export the tenant's reference graph to a graph-interchange format.
+   * @request GET:/api/v1/graph/export
+   * @secure
+   */
+  exportGraph = (params = {}) => this.http.request({
+    path: `/api/v1/graph/export`,
+    method: "GET",
+    secure: true,
+    ...params
+  });
   /**
    * @description POST /api/v1/communities/memberships Returns all communities that a term belongs to, with membership degrees.
    *
@@ -3580,6 +3812,24 @@ var Communities = class {
     format: "json",
     ...params
   });
+  /**
+   * @description `POST /api/v1/analysis/link-prediction` Read-only: returns ranked candidate targets (not already adjacent) with positive score. The scores are **proposals** — a caller turning one into a KB edge must route it through the engine's `gate_arc_proposals` sort-gate; this endpoint never asserts.
+   *
+   * @tags communities
+   * @name PredictLinks
+   * @summary Score candidate links from a source node (link prediction).
+   * @request POST:/api/v1/analysis/link-prediction
+   * @secure
+   */
+  predictLinks = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/link-prediction`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description POST /api/v1/communities/search Search for communities by various criteria: - ByEntities: Find communities containing specific terms - ByImpact: Find high-impact communities - ByLevel: Find communities at a specific hierarchy level - ByKeyword: Search community reports by keyword
    *
@@ -5570,6 +5820,24 @@ var Discovery = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Validates the request, converts DTOs to domain types, calls the learner port from `AppState`, and maps the result to a response DTO. Input bounds are validated to prevent DoS: - `samples.len()` <= 10,000 - `num_restarts` <= 100 - `max_epochs` <= 50,000 - `depth` in 1..=6
+   *
+   * @tags discovery
+   * @name DiscoverEml
+   * @summary Handler for `POST /discover/eml`.
+   * @request POST:/api/v1/discover/eml
+   * @secure
+   */
+  discoverEml = (data, params = {}) => this.http.request({
+    path: `/api/v1/discover/eml`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description POST /api/v1/discovery/predict Finds similar historical patterns and predicts effects using fuzzy search with PRODUCT t-norm reweighting for better aggregation.
    *
@@ -6216,6 +6484,24 @@ var Fuzzy = class {
     format: "json",
     ...params
   });
+  /**
+   * @description POST /api/v1/fuzzy/score The complement of `/fuzzy/similar`: that one retrieves and ranks a whole sort; this grades a set the caller already chose — typically the top hits of a *semantic* search — against a preference ψ-term, so a two-stage pipeline can retrieve semantically and grade by fuzzy OSF unification, then combine the two scores upstream with a t-norm. A 65-minute course against a "≤1h" fuzzy preference scores ~0.83 (membership), not the hard 0 a boolean filter gave it.
+   *
+   * @tags fuzzy
+   * @name ScoreTerms
+   * @summary Score a GIVEN set of candidate terms against a query ψ-term.
+   * @request POST:/api/v1/fuzzy/score
+   * @secure
+   */
+  scoreTerms = (data, params = {}) => this.http.request({
+    path: `/api/v1/fuzzy/score`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/Constraints.ts
@@ -8718,6 +9004,24 @@ var Generation = class {
   constructor(http) {
     this.http = http;
   }
+  /**
+   * @description Returns 503 when no in-process Gemma is loaded (the server was not started with `OSFKB_OSFQL_GEMMA_DIR`), and 400 when `allowed` is empty.
+   *
+   * @tags generation
+   * @name ConstrainedGenerate
+   * @summary Generate an answer constrained to an OSF-feasible set via the application-tier decoder.
+   * @request POST:/api/v1/constrained/generate
+   * @secure
+   */
+  constrainedGenerate = (data, params = {}) => this.http.request({
+    path: `/api/v1/constrained/generate`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -8736,6 +9040,40 @@ var Generation = class {
     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).
+   *
+   * @tags generation
+   * @name GroundedGenerate
+   * @summary Generate grounded prose via the two-pass (constrained derivation → free realization) pipeline.
+   * @request POST:/api/v1/generate/grounded
+   * @secure
+   */
+  groundedGenerate = (data, params = {}) => this.http.request({
+    path: `/api/v1/generate/grounded`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags generation
+   * @name RawGenerate
+   * @summary Raw, ungrounded generation from the **same in-process Gemma** the grounded endpoint uses — a bare chat-prompt free decode with NO substrate, NO feasibility proof, and NO lattice mask. This is the honest "WITHOUT — Raw LLM" baseline for the demo's left panel: the identical local model, answering the identical question, with nothing from the knowledge base — so the side-by-side isolates exactly what ReasoningLayer's substrate adds. Returns `503` when no local Gemma is loaded (server started without `OSFKB_OSFQL_GEMMA_DIR`) and `400` on an empty prompt.
+   * @request POST:/api/v1/generate/raw
+   */
+  rawGenerate = (data, params = {}) => this.http.request({
+    path: `/api/v1/generate/raw`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/Rag.ts
@@ -8818,6 +9156,7 @@ var Osfql = class {
     path: `/api/v1/osfql/catalog`,
     method: "GET",
     query,
+    format: "json",
     ...params
   });
 };
@@ -9142,6 +9481,22 @@ var Operations = class {
     format: "json",
     ...params
   });
+  /**
+   * @description `POST /api/v1/operations/anti-unify/batch` One in-process left fold of the binary LGG — associative up to variable renaming, so the result equals the client-side pairwise chain while costing a single round trip. Every intermediate LGG is persisted and returned in `steps` (the generalization ladder).
+   *
+   * @tags operations
+   * @name AntiUnifyBatch
+   * @summary Anti-unify N Ψ-terms (Least General Generalisation of the whole set).
+   * @request POST:/api/v1/operations/anti-unify/batch
+   */
+  antiUnifyBatch = (data, params = {}) => this.http.request({
+    path: `/api/v1/operations/anti-unify/batch`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/Actions.ts
@@ -9638,6 +9993,531 @@ var OntologyBridge = class {
   });
 };
 
+// src/api-spec/generated/Demo.ts
+var Demo = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description Returns `404` when the SUMO files cannot be read (bad `OSFKB_SUMO_DIR`/override), `400` when the assembled source fails to import, and `200` with the tenant's sort count + form count on success.
+   *
+   * @tags demo
+   * @name DemoSeed
+   * @summary Seed the request tenant's persistent substrate with full SUMO + the demo scenario situations.
+   * @request POST:/api/v1/demo/seed
+   * @secure
+   */
+  demoSeed = (data, params = {}) => this.http.request({
+    path: `/api/v1/demo/seed`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Reward.ts
+var Reward = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * No description
+   *
+   * @tags reward
+   * @name Score
+   * @summary `POST /api/v1/reward/score` — score a candidate query execution-free for the authenticated tenant. Returns `404` if the sort name is unknown to the lattice.
+   * @request POST:/api/v1/reward/score
+   * @secure
+   */
+  score = (data, params = {}) => this.http.request({
+    path: `/api/v1/reward/score`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Translation.ts
+var Translation = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description POST /api/v1/translate
+   *
+   * @tags translation
+   * @name Translate
+   * @summary Translate text into a target language.
+   * @request POST:/api/v1/translate
+   * @secure
+   */
+  translate = (data, params = {}) => this.http.request({
+    path: `/api/v1/translate`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Streaming.ts
+var Streaming = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description Build a Count-Min sketch from `items`, then return the estimated frequency for each key in `query_keys`. Strings are hashed to `u64` before insertion.  The same hash is used for queries, so counts are consistent within a call.  The returned `estimated_count` is an over-estimate: it never falls below the true count, and with (ε, δ) accuracy parameters it exceeds the true count by at most ε · N with probability 1 − δ. No tenant context is required.
+   *
+   * @tags streaming
+   * @name Frequency
+   * @summary `POST /api/v1/streaming/frequency`
+   * @request POST:/api/v1/streaming/frequency
+   */
+  frequency = (data, params = {}) => this.http.request({
+    path: `/api/v1/streaming/frequency`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description Build a Misra-Gries sketch from the supplied batch and return the candidate heavy hitters with their lower-bound counts. The algorithm uses `O(capacity)` memory regardless of the stream cardinality.  Every item whose true frequency exceeds `N / (capacity + 1)` is guaranteed to be present in the output. No tenant context is required; the sketch is ephemeral to the call.
+   *
+   * @tags streaming
+   * @name HeavyHitters
+   * @summary `POST /api/v1/streaming/heavy-hitters`
+   * @request POST:/api/v1/streaming/heavy-hitters
+   */
+  heavyHitters = (data, params = {}) => this.http.request({
+    path: `/api/v1/streaming/heavy-hitters`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description Build a Bloom filter, insert every item in `insert_items`, then test each item in `test_items` for membership. **Zero false negatives** — every inserted item will test as present. False positives are possible at a rate that depends on `bit_count`, `hash_count`, and the number of distinct items inserted. No tenant context is required.
+   *
+   * @tags streaming
+   * @name Membership
+   * @summary `POST /api/v1/streaming/membership`
+   * @request POST:/api/v1/streaming/membership
+   */
+  membership = (data, params = {}) => this.http.request({
+    path: `/api/v1/streaming/membership`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Conformal.ts
+var Conformal = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description Compute a split-conformal non-conformity threshold from a labeled calibration set.  Returns the threshold `τ` and a coverage certificate. The returned `threshold` should be passed verbatim to `POST /api/v1/conformal/predict`.
+   *
+   * @tags conformal
+   * @name Calibrate
+   * @summary `POST /api/v1/conformal/calibrate`
+   * @request POST:/api/v1/conformal/calibrate
+   */
+  calibrate = (data, params = {}) => this.http.request({
+    path: `/api/v1/conformal/calibrate`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description Apply a pre-computed conformal threshold to unlabeled test inputs and return prediction sets with coverage certificates. A class `y` is included in an input's prediction set iff `1 − class_scores[y] ≤ threshold` (equivalently, `class_scores[y] ≥ 1 − threshold`). When no class meets this criterion the prediction set is empty and `abstains = true` is set on that input's result.
+   *
+   * @tags conformal
+   * @name Predict
+   * @summary `POST /api/v1/conformal/predict`
+   * @request POST:/api/v1/conformal/predict
+   */
+  predict = (data, params = {}) => this.http.request({
+    path: `/api/v1/conformal/predict`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Vision.ts
+var Vision = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description Requires the deployment to have a [`VJepaPerceptionService`] mounted as an Axum extension. If absent, the route should not be registered; if it is registered without the extension, this handler returns 503. Mounted at `POST /api/v1/vision/encode-clip` by the production composition root when the V-JEPA service is configured.
+   *
+   * @tags vision
+   * @name EncodeClip
+   * @summary Encode a video clip end-to-end through V-JEPA + the head + the substrate, returning per-frame Ψ-term prediction summaries.
+   * @request POST:/api/v1/vision/encode-clip
+   * @secure
+   */
+  encodeClip = (data, params = {}) => this.http.request({
+    path: `/api/v1/vision/encode-clip`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Anonymization.ts
+var Anonymization = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description Batch-anonymize a set of records using either k-anonymity or HIPAA Safe Harbor de-identification.  Returns the processed records together with a full compliance report. Accepts up to 10 000 records per call.  For larger batches partition the input and call in parallel. Returns `200 OK` with [`AnonymizeResponse`] on success.
+   *
+   * @tags anonymization
+   * @name AnonymizeRecords
+   * @summary `POST /api/v1/anonymize`
+   * @request POST:/api/v1/anonymize
+   * @secure
+   */
+  anonymizeRecords = (data, params = {}) => this.http.request({
+    path: `/api/v1/anonymize`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Speakers.ts
+var Speakers = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description DELETE /api/v1/speakers/{id}
+   *
+   * @tags speakers
+   * @name DeleteSpeaker
+   * @summary Delete a speaker profile by id.
+   * @request DELETE:/api/v1/speakers/{id}
+   * @secure
+   */
+  deleteSpeaker = (id, params = {}) => this.http.request({
+    path: `/api/v1/speakers/${id}`,
+    method: "DELETE",
+    secure: true,
+    ...params
+  });
+  /**
+   * @description POST /api/v1/speakers/enroll
+   *
+   * @tags speakers
+   * @name EnrollSpeaker
+   * @summary Enroll (or re-enroll) a speaker voiceprint.
+   * @request POST:/api/v1/speakers/enroll
+   * @secure
+   */
+  enrollSpeaker = (data, params = {}) => this.http.request({
+    path: `/api/v1/speakers/enroll`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description GET /api/v1/speakers
+   *
+   * @tags speakers
+   * @name ListSpeakers
+   * @summary List the tenant's enrolled speaker profiles (embeddings withheld).
+   * @request GET:/api/v1/speakers
+   * @secure
+   */
+  listSpeakers = (params = {}) => this.http.request({
+    path: `/api/v1/speakers`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Speech.ts
+var Speech = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description DELETE /api/v1/speech/voices/{id}
+   *
+   * @tags speech
+   * @name DeleteVoice
+   * @summary Delete a cloned voice, upstream conditioning included.
+   * @request DELETE:/api/v1/speech/voices/{id}
+   * @secure
+   */
+  deleteVoice = (id, params = {}) => this.http.request({
+    path: `/api/v1/speech/voices/${id}`,
+    method: "DELETE",
+    secure: true,
+    ...params
+  });
+  /**
+   * @description POST /api/v1/speech/voices
+   *
+   * @tags speech
+   * @name EnrollVoice
+   * @summary Enroll (or re-enroll) a cloned voice.
+   * @request POST:/api/v1/speech/voices
+   * @secure
+   */
+  enrollVoice = (data, params = {}) => this.http.request({
+    path: `/api/v1/speech/voices`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description GET /api/v1/speech/engines
+   *
+   * @tags speech
+   * @name ListEngines
+   * @summary Report per-engine availability.
+   * @request GET:/api/v1/speech/engines
+   * @secure
+   */
+  listEngines = (params = {}) => this.http.request({
+    path: `/api/v1/speech/engines`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description GET /api/v1/speech/voices
+   *
+   * @tags speech
+   * @name ListVoices
+   * @summary List the tenant's cloned voices plus available presets.
+   * @request GET:/api/v1/speech/voices
+   * @secure
+   */
+  listVoices = (params = {}) => this.http.request({
+    path: `/api/v1/speech/voices`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description POST /api/v1/speech/session
+   *
+   * @tags speech
+   * @name OpenSpeechSession
+   * @summary Open a speech-to-speech session.
+   * @request POST:/api/v1/speech/session
+   * @secure
+   */
+  openSpeechSession = (data, params = {}) => this.http.request({
+    path: `/api/v1/speech/session`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description POST /api/v1/speech/synthesize
+   *
+   * @tags speech
+   * @name SynthesizeSpeech
+   * @summary Synthesize speech.
+   * @request POST:/api/v1/speech/synthesize
+   * @secure
+   */
+  synthesizeSpeech = (data, params = {}) => this.http.request({
+    path: `/api/v1/speech/synthesize`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    ...params
+  });
+  /**
+   * @description POST /api/v1/speech/transcribe
+   *
+   * @tags speech
+   * @name TranscribeSpeech
+   * @summary Transcribe a short utterance.
+   * @request POST:/api/v1/speech/transcribe
+   * @secure
+   */
+  transcribeSpeech = (data, params = {}) => this.http.request({
+    path: `/api/v1/speech/transcribe`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Connectors.ts
+var Connectors = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description POST /api/v1/connectors/manage
+   *
+   * @tags connectors
+   * @name Add
+   * @summary Add a connector instance to the tenant.
+   * @request POST:/api/v1/connectors/manage
+   * @secure
+   */
+  add = (data, params = {}) => this.http.request({
+    path: `/api/v1/connectors/manage`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description POST /api/v1/connectors/manage/{name}/disconnect
+   *
+   * @tags connectors
+   * @name Disconnect
+   * @summary Disconnect a connector (revoke tokens, set status=disconnected).
+   * @request POST:/api/v1/connectors/manage/{name}/disconnect
+   * @secure
+   */
+  disconnect = (name, params = {}) => this.http.request({
+    path: `/api/v1/connectors/manage/${name}/disconnect`,
+    method: "POST",
+    secure: true,
+    ...params
+  });
+  /**
+   * @description GET /api/v1/connectors/manage
+   *
+   * @tags connectors
+   * @name List
+   * @summary List tenant's connectors.
+   * @request GET:/api/v1/connectors/manage
+   * @secure
+   */
+  list = (params = {}) => this.http.request({
+    path: `/api/v1/connectors/manage`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description GET /api/v1/connector-types
+   *
+   * @tags connectors
+   * @name ListTypes
+   * @summary List available connector types (global catalog).
+   * @request GET:/api/v1/connector-types
+   */
+  listTypes = (params = {}) => this.http.request({
+    path: `/api/v1/connector-types`,
+    method: "GET",
+    format: "json",
+    ...params
+  });
+  /**
+   * @description GET /api/v1/connectors/manage/{name}/oauth/callback
+   *
+   * @tags connectors
+   * @name OauthCallback
+   * @summary OAuth callback — exchanges code for tokens, returns HTML that posts message to opener.
+   * @request GET:/api/v1/connectors/manage/{name}/oauth/callback
+   */
+  oauthCallback = (name, query, params = {}) => this.http.request({
+    path: `/api/v1/connectors/manage/${name}/oauth/callback`,
+    method: "GET",
+    query,
+    ...params
+  });
+  /**
+   * @description DELETE /api/v1/connectors/manage/{name}
+   *
+   * @tags connectors
+   * @name Remove
+   * @summary Remove a connector from the tenant (cascades: deletes tokens).
+   * @request DELETE:/api/v1/connectors/manage/{name}
+   * @secure
+   */
+  remove = (name, params = {}) => this.http.request({
+    path: `/api/v1/connectors/manage/${name}`,
+    method: "DELETE",
+    secure: true,
+    ...params
+  });
+  /**
+   * @description POST /api/v1/connectors/manage/{name}/connect
+   *
+   * @tags connectors
+   * @name StartOauth
+   * @summary Start OAuth flow — returns auth URL for popup.
+   * @request POST:/api/v1/connectors/manage/{name}/connect
+   * @secure
+   */
+  startOauth = (name, params = {}) => this.http.request({
+    path: `/api/v1/connectors/manage/${name}/connect`,
+    method: "POST",
+    secure: true,
+    format: "json",
+    ...params
+  });
+};
+
 // src/api-spec/generated/Documents.ts
 var Documents = class {
   http;
@@ -11103,6 +11983,15 @@ function RejectLearnedSimilarityResponseFromApiToFront(dto) {
     message: dto.message
   };
 }
+function SortIndexStatusResponseFromApiToFront(dto) {
+  const out = {
+    running: dto.running,
+    totalSorts: dto.total_sorts
+  };
+  if (dto.last_error != null) out.lastError = dto.last_error;
+  if (dto.last_indexed_count != null) out.lastIndexedCount = dto.last_indexed_count;
+  return out;
+}
 
 // src/resources/sorts.ts
 var SortsClient = class {
@@ -11318,6 +12207,16 @@ var SortsClient = class {
   async indexSorts() {
     await this.sorts.indexSorts();
   }
+  /**
+   * Report the status of the background sort-indexing pass.
+   *
+   * @returns Whether a re-index is running, the most recent run's indexed
+   *   count and any error, plus the total data-sort denominator.
+   */
+  async sortIndexStatus() {
+    const response = await this.sorts.sortIndexStatus();
+    return SortIndexStatusResponseFromApiToFront(response.data);
+  }
   /**
    * Update the review status of a sort.
    *
@@ -14669,6 +15568,25 @@ function FindSimilarRequestFromFrontToApi(model) {
     fail_on_unknown: model.failOnUnknown
   };
 }
+function ScoreTermsRequestFromFrontToApi(model) {
+  return {
+    ...QueryTermFromFrontToApi(model),
+    fail_on_unknown: model.failOnUnknown,
+    similarity_mode: model.similarityMode,
+    term_ids: model.termIds
+  };
+}
+function ScoredTermFromApiToFront(dto) {
+  return {
+    degree: dto.degree,
+    termId: dto.term_id
+  };
+}
+function ScoreTermsResponseFromApiToFront(dto) {
+  return {
+    scores: dto.scores.map(ScoredTermFromApiToFront)
+  };
+}
 function SimilarityMatchFromApiToFront(dto) {
   return {
     confidencePercent: dto.confidence_percent,
@@ -14839,6 +15757,18 @@ var FuzzyClient = class {
     });
     return PredictEffectResponseFromApiToFront(response.data);
   }
+  /**
+   * Score a given set of candidate terms against a query ψ-term.
+   *
+   * @param request - The query ψ-term (`QueryTerm`) plus the candidate
+   *   `termIds` and optional scoring knobs.
+   * @returns The candidates with their fuzzy-unification degrees, in
+   *   input order.
+   */
+  async scoreTerms(request) {
+    const response = await this.api.scoreTerms(ScoreTermsRequestFromFrontToApi(request));
+    return ScoreTermsResponseFromApiToFront(response.data);
+  }
 };
 
 // src/normalizers/visualization.ts
@@ -18454,6 +19384,35 @@ function IngestRdfRequestFromFrontToApi(model) {
     parse_shacl: model.parseShacl
   };
 }
+function IngestKifRequestFromFrontToApi(model) {
+  const dto = { content: model.content };
+  if (model.goal !== void 0) dto.goal = model.goal;
+  if (model.persist !== void 0) dto.persist = model.persist;
+  if (model.query !== void 0) dto.query = model.query;
+  return dto;
+}
+function IngestKifResponseFromApiToFront(dto) {
+  const out = {
+    capturedNonHorn: dto.captured_non_horn,
+    constraintRules: dto.constraint_rules,
+    disjunctiveRules: dto.disjunctive_rules,
+    facts: dto.facts,
+    forms: dto.forms,
+    hornRules: dto.horn_rules,
+    instantiatedRules: dto.instantiated_rules,
+    nafRules: dto.naf_rules,
+    residueByShape: dto.residue_by_shape,
+    residueExamples: dto.residue_examples,
+    rules: dto.rules,
+    skolemized: dto.skolemized,
+    sorts: dto.sorts,
+    subclassEdges: dto.subclass_edges,
+    success: dto.success,
+    temporalDetached: dto.temporal_detached
+  };
+  if (dto.provable != null) out.provable = dto.provable;
+  return out;
+}
 function TranslateRdfRequestFromFrontToApi(model) {
   return {
     content: model.content,
@@ -18900,6 +19859,21 @@ var IngestionClient = class {
     );
     return IngestRdfResponseFromApiToFront(response.data);
   }
+  /**
+   * Import SUO-KIF and, optionally, prove a ground goal against the
+   * imported axioms.
+   *
+   * @param request - The SUO-KIF source, an optional `goal`/`query` to
+   *   prove, and a `persist` flag (import into the tenant substrate vs an
+   *   ephemeral request-scoped world).
+   * @returns Import counts (forms, facts, rules, sorts, …) plus, when a
+   *   goal/query was supplied, a `provable` verdict and the non-firing
+   *   residue breakdown.
+   */
+  async ingestKif(request) {
+    const response = await this.api.ingestKif(IngestKifRequestFromFrontToApi(request));
+    return IngestKifResponseFromApiToFront(response.data);
+  }
   /**
    * Translate RDF into the engine's term representation without writing
    * anything to the knowledge base.
@@ -21096,6 +22070,7 @@ function RegisterSourceResponseFromApiToFront(dto) {
     sourceId: dto.source_id,
     sourceType: dto.source_type,
     mode: dto.mode,
+    supportedModes: dto.supported_modes,
     message: dto.message
   };
 }
@@ -21118,7 +22093,21 @@ function SourceDetailResponseFromApiToFront(dto) {
     sourceId: dto.source_id,
     sourceType: dto.source_type,
     available: dto.available,
-    mode: dto.mode
+    mode: dto.mode,
+    supportedModes: dto.supported_modes
+  };
+}
+function SourceTypeDtoFromApiToFront(dto) {
+  return {
+    sourceType: dto.source_type,
+    aliases: dto.aliases,
+    available: dto.available,
+    supportedModes: dto.supported_modes
+  };
+}
+function ListSourceTypesResponseFromApiToFront(dto) {
+  return {
+    types: dto.types.map(SourceTypeDtoFromApiToFront)
   };
 }
 function DiscoverSchemaRequestFromFrontToApi(model) {
@@ -21235,17 +22224,21 @@ var SourcesClient = class {
    *
    * @param request - Source registration request. Set `mode` to declare the write-path
    *   intent (`'transpile'` for live SQL views, `'ingest'` to materialize rows as
-   *   Ψ-term facts); omit it to take the capability-grounded default (`transpile` for
-   *   postgres, `ingest` otherwise).
+   *   Ψ-term facts); omit it to take the default, which is `'ingest'` for every
+   *   source type (#71).
    * @returns Registration result. `mode` always carries the **resolved** write-path
-   *   mode, including when the default applied.
-   * @throws {ApiError} If registration fails, or with **422** if `mode` is not one of
-   *   `transpile` / `ingest`.
+   *   mode, including when the default applied; `supportedModes` advertises which
+   *   modes this source's adapter can serve.
+   * @throws {ApiError} If registration fails, with **422** if `mode` is not one of
+   *   `transpile` / `ingest`, or with **422** if `mode: 'transpile'` is requested
+   *   for a source whose adapter cannot execute transpiled SQL (a live view over it
+   *   could never be queried).
    *
    * @remarks
    * Registering with `mode: 'transpile'` makes {@link SourcesClient.ingest} refuse this
    * source with a **409** — materializing a transpiled source would create a second,
-   * divergent namespace over the same rows.
+   * divergent namespace over the same rows. To learn which types accept `transpile`
+   * before registering, call {@link SourcesClient.listSourceTypes}.
    *
    * @example
    * ```typescript
@@ -21257,12 +22250,44 @@ var SourcesClient = class {
    *   mode: 'ingest',
    * });
    * console.log(result.mode); // 'ingest'
+   * console.log(result.supportedModes); // ['ingest', 'transpile']
    * ```
    */
   async register(request) {
     const response = await this.api.registerSource(RegisterSourceRequestFromFrontToApi(request));
     return RegisterSourceResponseFromApiToFront(response.data);
   }
+  /**
+   * List the source types this build can register, with their mode capabilities.
+   *
+   * @returns Every registrable source type, its availability in this build, and the
+   *   write-path modes each would serve — before any source exists.
+   * @throws {ApiError} If the request fails.
+   *
+   * @remarks
+   * Sent to `GET /api/v1/sources/types`. The pre-registration half of #71's
+   * mode-discovery surface: a client rendering a "new source" picker learns, at
+   * type-selection time, which types registration would accept (`available` — a
+   * type behind an uncompiled cargo feature is `false`) and which modes each
+   * would serve (`supportedModes` — always `'ingest'`, plus `'transpile'` only
+   * for the SQL engines). Static per build, so no tenant state is consulted.
+   *
+   * Drive a mode selector from `supportedModes` rather than a hard-coded list of
+   * source types: the set is the adapter's declared capability, so it stays
+   * correct as adapters gain the ability (MySQL and SQLite did in #70).
+   *
+   * @example
+   * ```typescript
+   * const { types } = await client.sources.listSourceTypes();
+   * const postgres = types.find((t) => t.sourceType === 'postgres');
+   * console.log(postgres?.supportedModes); // ['ingest', 'transpile']
+   * console.log(postgres?.aliases); // ['postgresql']
+   * ```
+   */
+  async listSourceTypes() {
+    const response = await this.api.listSourceTypesCatalog();
+    return ListSourceTypesResponseFromApiToFront(response.data);
+  }
   /**
    * List all registered data sources.
    *
@@ -21464,6 +22489,66 @@ function SearchCommunitiesResponseFromApiToFront(dto) {
     stats: CommunitySearchStatsDtoFromApiToFront(dto.stats)
   };
 }
+function NodeScoreFromApiToFront(dto) {
+  return {
+    nodeId: dto.node_id,
+    score: dto.score
+  };
+}
+function CentralityRequestFromFrontToApi(model) {
+  const dto = {
+    measure: model.measure,
+    tenant_id: model.tenantId
+  };
+  if (model.topK !== void 0) dto.top_k = model.topK;
+  return dto;
+}
+function CentralityResponseFromApiToFront(dto) {
+  return {
+    edgeCount: dto.edge_count,
+    measure: dto.measure,
+    nodeCount: dto.node_count,
+    scores: dto.scores.map(NodeScoreFromApiToFront)
+  };
+}
+function CohesionRequestFromFrontToApi(model) {
+  return { tenant_id: model.tenantId };
+}
+function CohesionResponseFromApiToFront(dto) {
+  return {
+    clustering: dto.clustering.map(NodeScoreFromApiToFront),
+    nodeCount: dto.node_count,
+    triangleCount: dto.triangle_count
+  };
+}
+function PathRequestFromFrontToApi(model) {
+  return {
+    source: model.source,
+    target: model.target,
+    tenant_id: model.tenantId
+  };
+}
+function PathResponseFromApiToFront(dto) {
+  const out = { componentCount: dto.component_count };
+  if (dto.path !== void 0 && dto.path !== null) out.path = dto.path;
+  return out;
+}
+function LinkPredictionRequestFromFrontToApi(model) {
+  const dto = {
+    measure: model.measure,
+    source: model.source,
+    tenant_id: model.tenantId
+  };
+  if (model.topK !== void 0) dto.top_k = model.topK;
+  return dto;
+}
+function LinkPredictionResponseFromApiToFront(dto) {
+  return {
+    measure: dto.measure,
+    predictions: dto.predictions.map(NodeScoreFromApiToFront),
+    source: dto.source
+  };
+}
 
 // src/resources/communities.ts
 var CommunitiesClient = class {
@@ -21503,6 +22588,48 @@ var CommunitiesClient = class {
     const response = await this.api.searchCommunities(SearchCommunitiesRequestFromFrontToApi(request));
     return SearchCommunitiesResponseFromApiToFront(response.data);
   }
+  /**
+   * Compute a centrality measure over the tenant's term graph.
+   *
+   * @param request - The measure, tenant id, and an optional `topK` cap.
+   * @returns Node scores sorted descending, plus graph node/edge counts.
+   */
+  async computeCentrality(request) {
+    const response = await this.api.computeCentrality(CentralityRequestFromFrontToApi(request));
+    return CentralityResponseFromApiToFront(response.data);
+  }
+  /**
+   * Compute graph cohesion (local clustering coefficients + triangle count).
+   *
+   * @param request - The tenant id.
+   * @returns Per-node clustering coefficients, node count, and triangle count.
+   */
+  async computeCohesion(request) {
+    const response = await this.api.computeCohesion(CohesionRequestFromFrontToApi(request));
+    return CohesionResponseFromApiToFront(response.data);
+  }
+  /**
+   * Find the shortest path between two nodes in the tenant's term graph.
+   *
+   * @param request - Source node, target node, and tenant id.
+   * @returns The shortest path as a node sequence (when reachable) plus the
+   *   connected-component count.
+   */
+  async computePath(request) {
+    const response = await this.api.computePath(PathRequestFromFrontToApi(request));
+    return PathResponseFromApiToFront(response.data);
+  }
+  /**
+   * Predict candidate links from a source node using a graph heuristic.
+   *
+   * @param request - The heuristic, source node, tenant id, and an optional
+   *   `topK` cap.
+   * @returns Candidate targets with positive score, sorted descending.
+   */
+  async predictLinks(request) {
+    const response = await this.api.predictLinks(LinkPredictionRequestFromFrontToApi(request));
+    return LinkPredictionResponseFromApiToFront(response.data);
+  }
 };
 
 // src/normalizers/utilities.ts
@@ -22335,6 +23462,33 @@ function PredictFromDiscoveryResponseFromApiToFront(dto) {
     success: dto.success
   };
 }
+function EmlSampleFromFrontToApi(model) {
+  return {
+    inputs: model.inputs,
+    target: model.target
+  };
+}
+function DiscoverEmlRequestFromFrontToApi(model) {
+  const dto = {
+    depth: model.depth,
+    samples: model.samples.map(EmlSampleFromFrontToApi)
+  };
+  if (model.maxEpochs !== void 0) dto.max_epochs = model.maxEpochs;
+  if (model.numRestarts !== void 0) dto.num_restarts = model.numRestarts;
+  return dto;
+}
+function DiscoverEmlResponseFromApiToFront(dto) {
+  const out = {
+    epochsRun: dto.epochs_run,
+    finalLoss: dto.final_loss,
+    snapped: dto.snapped,
+    success: dto.success
+  };
+  if (dto.expression_depth != null) out.expressionDepth = dto.expression_depth;
+  if (dto.expression_leaf_count != null) out.expressionLeafCount = dto.expression_leaf_count;
+  if (dto.expression_rpn != null) out.expressionRpn = dto.expression_rpn;
+  return out;
+}
 
 // src/resources/discovery.ts
 var DiscoveryClient = class {
@@ -22364,6 +23518,19 @@ var DiscoveryClient = class {
     const response = await this.api.predictFromDiscovery(PredictFromDiscoveryRequestFromFrontToApi(request));
     return PredictFromDiscoveryResponseFromApiToFront(response.data);
   }
+  /**
+   * Discover a closed-form expression from samples via parameterised EML.
+   *
+   * @param request - Tree-depth bound, training samples, and optional
+   *   epoch/restart caps.
+   * @returns The discovered expression (RPN + depth/leaf-count when
+   *   recovered) plus the training stats (epochs, final loss, snap +
+   *   success flags).
+   */
+  async discoverEml(request) {
+    const response = await this.api.discoverEml(DiscoverEmlRequestFromFrontToApi(request));
+    return DiscoverEmlResponseFromApiToFront(response.data);
+  }
 };
 
 // src/normalizers/extract.ts
@@ -25601,6 +26768,56 @@ function GenerateDocumentResponseFromApiToFront(dto) {
     verification: dto.verification ? VerificationDtoFromApiToFront(dto.verification) : void 0
   };
 }
+function ConstrainedGenerateRequestFromFrontToApi(model) {
+  const dto = {
+    allowed: model.allowed,
+    prompt: model.prompt
+  };
+  if (model.maxTokens !== void 0) dto.max_tokens = model.maxTokens;
+  return dto;
+}
+function ConstrainedGenerateResponseFromApiToFront(dto) {
+  return {
+    allowed: dto.allowed,
+    answer: dto.answer,
+    maskedOut: dto.masked_out,
+    tokens: dto.tokens
+  };
+}
+function RawGenerateRequestFromFrontToApi(model) {
+  const dto = { prompt: model.prompt };
+  if (model.maxTokens !== void 0) dto.max_tokens = model.maxTokens;
+  return dto;
+}
+function RawGenerateResponseFromApiToFront(dto) {
+  return { prose: dto.prose };
+}
+function GroundedGenerateRequestFromFrontToApi(model) {
+  const dto = { prompt: model.prompt };
+  if (model.goalDest !== void 0) dto.goal_dest = model.goalDest;
+  if (model.goalDistance !== void 0) dto.goal_distance = model.goalDistance;
+  if (model.goalFeasible !== void 0) dto.goal_feasible = model.goalFeasible;
+  if (model.goalTarget !== void 0) dto.goal_target = model.goalTarget;
+  if (model.maxTokens !== void 0) dto.max_tokens = model.maxTokens;
+  if (model.mode !== void 0) dto.mode = model.mode;
+  if (model.prose !== void 0) dto.prose = model.prose;
+  if (model.steerMargin !== void 0) dto.steer_margin = model.steerMargin;
+  return dto;
+}
+function GroundedGenerateResponseFromApiToFront(dto) {
+  const out = {
+    admittedTerms: dto.admitted_terms,
+    derivation: dto.derivation,
+    feasibleModes: dto.feasible_modes,
+    mode: dto.mode,
+    prose: dto.prose,
+    refutedModes: dto.refuted_modes
+  };
+  if (dto.certify_outcome != null) out.certifyOutcome = dto.certify_outcome;
+  if (dto.model_pick != null) out.modelPick = dto.model_pick;
+  if (dto.recommended_mode != null) out.recommendedMode = dto.recommended_mode;
+  return out;
+}
 
 // src/resources/generation.ts
 var GenerationClient = class {
@@ -25643,6 +26860,46 @@ var GenerationClient = class {
     const response = await this.api.generateDocument(GenerateDocumentRequestFromFrontToApi(request));
     return GenerateDocumentResponseFromApiToFront(response.data);
   }
+  /**
+   * Masked-decode one answer from an OSF-feasible allowed set
+   * (`POST /api/v1/constrained/generate`).
+   *
+   * @param request - The allowed set, an optional token cap, and the prompt.
+   * @returns The decoded answer (guaranteed inside `allowed`), the masked-out
+   *   alternatives, and the per-step token deltas.
+   */
+  async constrainedGenerate(request) {
+    const response = await this.api.constrainedGenerate(
+      ConstrainedGenerateRequestFromFrontToApi(request)
+    );
+    return ConstrainedGenerateResponseFromApiToFront(response.data);
+  }
+  /**
+   * Free, ungrounded local-model decode (`POST /api/v1/generate/raw`).
+   *
+   * @param request - The prompt and an optional token cap.
+   * @returns The raw, ungrounded answer.
+   */
+  async rawGenerate(request) {
+    const response = await this.api.rawGenerate(RawGenerateRequestFromFrontToApi(request));
+    return RawGenerateResponseFromApiToFront(response.data);
+  }
+  /**
+   * Lattice-grounded anti-hallucination generation
+   * (`POST /api/v1/generate/grounded`).
+   *
+   * @param request - The prompt, an optional goal (target/destination) for
+   *   feasibility, the anti-hallucination `mode`, and decode knobs.
+   * @returns The lattice-constrained derivation, the free-prose answer, the
+   *   feasible/refuted/recommended motion modes, and (certify mode) the
+   *   certification outcome.
+   */
+  async groundedGenerate(request) {
+    const response = await this.api.groundedGenerate(
+      GroundedGenerateRequestFromFrontToApi(request)
+    );
+    return GroundedGenerateResponseFromApiToFront(response.data);
+  }
 };
 
 // src/normalizers/rag.ts
@@ -27163,6 +28420,13 @@ function ListConversationsResponseFromApiToFront(dto) {
     conversations: dto.conversations.map(ConversationSummaryDtoFromApiToFront)
   };
 }
+function CompareModelDtoFromApiToFront(dto) {
+  return {
+    id: dto.id,
+    kind: dto.kind,
+    label: dto.label
+  };
+}
 function ConversationTurnsResponseFromApiToFront(dto) {
   return {
     conversationId: dto.conversation_id,
@@ -27271,6 +28535,30 @@ var ConversationClient = class {
     });
     return ListConversationsResponseFromApiToFront(response.data);
   }
+  /**
+   * List the registered comparison models so the UI can populate a
+   * selector / compare panel.
+   *
+   * @returns The available comparison models (endpoint- or candle-backed).
+   * @throws {ApiError} If the request fails.
+   *
+   * @example
+   * ```typescript
+   * const models = await client.conversation.listModels();
+   * for (const m of models) {
+   *   console.log(`${m.id} (${m.kind}): ${m.label}`);
+   * }
+   * ```
+   */
+  async listModels() {
+    const response = await this.http.request({
+      path: "/api/v1/conversation/models",
+      method: "GET",
+      secure: true,
+      format: "json"
+    });
+    return (response.data ?? []).map(CompareModelDtoFromApiToFront);
+  }
   /**
    * Get all turns for a conversation.
    *
@@ -28790,6 +30078,14 @@ function AuditRecordFromApiToFront(dto) {
     extra: dto.extra
   };
 }
+function AuditPageFromApiToFront(dto) {
+  return {
+    records: dto.records.map(AuditRecordFromApiToFront),
+    total: dto.total,
+    limit: dto.limit ?? null,
+    offset: dto.offset
+  };
+}
 function SummaryResponseFromApiToFront(dto) {
   const out = {
     nRecords: dto.n_records,
@@ -28879,18 +30175,39 @@ var ComplianceClient = class {
     return AuditRecordFromApiToFront(response.data);
   }
   /**
-   * List audit records for this tenant, optionally filtered.
+   * List audit records for this tenant — paged, sorted, and filtered.
+   *
+   * @param options - Page / sort / filter controls. Defaults to a
+   *   bounded first page (`sort_by=timestamp`, `sort_order=desc`,
+   *   `limit=50`) — most-recent-first, matching the backend default.
+   *   Pass `all: true` to fetch the full filtered set for export.
+   * @returns A page of records plus the filtered `total`, the `limit`
+   *   applied (`null` when `all` was set), and the zero-based `offset`.
    *
-   * @param options - Limit / glob filter on `requestPath`.
+   * @remarks
+   * The backend clamps `limit` to `1..=200` and defaults it to `50`
+   * when omitted (unless `all` is set). `total` reflects the active
+   * `requestPathPattern` / `since` / `until` filter, not the raw
+   * tenant count — so `{shown} of {total}` and the rendered rows stay
+   * consistent under the same filter. Sort enums are wire-serialised
+   * `snake_case` (`timestamp` / `request_path` / `actor`) and `asc` /
+   * `desc` lowercase; the shipped {@link AuditSortField} /
+   * {@link AuditSortOrder} literals match verbatim.
    */
   async list(options = {}) {
     const query = {};
-    if (options.limit !== void 0) query.limit = options.limit;
     if (options.requestPathPattern !== void 0) {
       query.request_path_pattern = options.requestPathPattern;
     }
+    if (options.since !== void 0) query.since = options.since;
+    if (options.until !== void 0) query.until = options.until;
+    if (options.sortBy !== void 0) query.sort_by = options.sortBy;
+    if (options.sortOrder !== void 0) query.sort_order = options.sortOrder;
+    if (options.limit !== void 0) query.limit = options.limit;
+    if (options.offset !== void 0) query.offset = options.offset;
+    if (options.all !== void 0) query.all = options.all;
     const response = await this.api.list(query);
-    return response.data.map(AuditRecordFromApiToFront);
+    return AuditPageFromApiToFront(response.data);
   }
   /**
    * Top-line counts over the tenant's full ledger — useful for
@@ -28970,6 +30287,19 @@ function AntiUnifyResponseFromApiToFront(dto) {
     computationTimeMs: dto.computation_time_ms
   };
 }
+function AntiUnifyBatchRequestFromFrontToApi(model) {
+  return {
+    term_ids: model.termIds
+  };
+}
+function AntiUnifyBatchResponseFromApiToFront(dto) {
+  return {
+    computationTimeMs: dto.computation_time_ms,
+    lgg: TermDtoFromApiToFront(dto.lgg),
+    lggTermId: dto.lgg_term_id,
+    steps: dto.steps
+  };
+}
 
 // src/resources/operations.ts
 var OperationsClient = class {
@@ -28998,6 +30328,25 @@ var OperationsClient = class {
     );
     return AntiUnifyResponseFromApiToFront(response.data);
   }
+  /**
+   * Compute the anti-unification (LGG) of a batch of Ψ-terms via a left
+   * fold over 2..=64 term ids.
+   *
+   * @param request - The term ids to generalise, in fold order.
+   * @returns The final LGG term + enriched view + the intermediate LGG
+   *   ids from the fold + total timing.
+   *
+   * @remarks
+   * All ids must already be registered in the tenant's term store. The
+   * final LGG is persisted; `steps` is empty when exactly two terms are
+   * supplied.
+   */
+  async antiUnifyBatch(request) {
+    const response = await this.api.antiUnifyBatch(
+      AntiUnifyBatchRequestFromFrontToApi(request)
+    );
+    return AntiUnifyBatchResponseFromApiToFront(response.data);
+  }
 };
 
 // src/normalizers/actions.ts
@@ -34247,6 +35596,1016 @@ var OntologyExportClient = class {
   }
 };
 
+// src/normalizers/demo.ts
+function DemoSeedRequestFromFrontToApi(model) {
+  const dto = {};
+  if (model.sumoDir !== void 0) dto.sumo_dir = model.sumoDir;
+  return dto;
+}
+function DemoSeedResponseFromApiToFront(dto) {
+  return {
+    forms: dto.forms,
+    sorts: dto.sorts
+  };
+}
+
+// src/resources/demo.ts
+var DemoClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Seed the request tenant's persistent substrate with full SUMO + the
+   * demo scenario situations.
+   *
+   * @param request - Optional SUMO source-directory override.
+   * @returns The imported form count and the tenant's total sort count.
+   *
+   * @throws {ApiError} `404` if the SUMO files cannot be read, `400` if
+   *   the assembled source fails to import.
+   */
+  async seed(request = {}) {
+    const response = await this.api.demoSeed(DemoSeedRequestFromFrontToApi(request));
+    return DemoSeedResponseFromApiToFront(response.data);
+  }
+};
+
+// src/normalizers/reward.ts
+function RewardScoreRequestFromFrontToApi(model) {
+  const dto = { sort: model.sort };
+  if (model.constraints !== void 0) dto.constraints = model.constraints;
+  if (model.maxInstances !== void 0) dto.max_instances = model.maxInstances;
+  if (model.negativeIds !== void 0) dto.negative_ids = model.negativeIds;
+  if (model.objective !== void 0) dto.objective = model.objective;
+  if (model.positiveIds !== void 0) dto.positive_ids = model.positiveIds;
+  if (model.targetSort !== void 0) dto.target_sort = model.targetSort;
+  return dto;
+}
+function RewardScoreResponseFromApiToFront(dto) {
+  const out = {
+    certifiedNonEmpty: dto.certified_non_empty,
+    estimatedExtent: dto.estimated_extent,
+    reward: dto.reward
+  };
+  if (dto.covers_negative != null) out.coversNegative = dto.covers_negative;
+  if (dto.covers_positive != null) out.coversPositive = dto.covers_positive;
+  if (dto.precision != null) out.precision = dto.precision;
+  if (dto.recall != null) out.recall = dto.recall;
+  return out;
+}
+
+// src/resources/reward.ts
+var RewardClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Score a candidate query execution-free for the authenticated tenant.
+   *
+   * @param request - The query spec (sort, objective, optional
+   *   constraints / instance ids).
+   * @returns A sound reward signal plus the certificate and coverage
+   *   breakdown.
+   *
+   * @throws {ApiError} `404` if the sort name is unknown to the lattice.
+   */
+  async score(request) {
+    const response = await this.api.score(RewardScoreRequestFromFrontToApi(request));
+    return RewardScoreResponseFromApiToFront(response.data);
+  }
+};
+
+// src/normalizers/translation.ts
+function TranslateRequestFromFrontToApi(model) {
+  const dto = {
+    target_lang: model.targetLang,
+    text: model.text
+  };
+  if (model.sourceLang !== void 0) dto.source_lang = model.sourceLang;
+  return dto;
+}
+function TranslateResponseFromApiToFront(dto) {
+  const out = {
+    targetLang: dto.target_lang,
+    translatedText: dto.translated_text
+  };
+  if (dto.model !== void 0) out.model = dto.model;
+  return out;
+}
+
+// src/resources/translation.ts
+var TranslationClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Translate text into a target language.
+   *
+   * @param request - Source text, target language, and an optional
+   *   source-language hint.
+   * @returns The translated text plus the echoed target language and
+   *   the model label, when known.
+   */
+  async translate(request) {
+    const response = await this.api.translate(TranslateRequestFromFrontToApi(request));
+    return TranslateResponseFromApiToFront(response.data);
+  }
+};
+
+// src/normalizers/streaming.ts
+function SketchDimensionsFromFrontToApi(model) {
+  const dto = {};
+  if (model.delta !== void 0) dto.delta = model.delta;
+  if (model.depth !== void 0) dto.depth = model.depth;
+  if (model.epsilon !== void 0) dto.epsilon = model.epsilon;
+  if (model.width !== void 0) dto.width = model.width;
+  return dto;
+}
+function FrequencyEstimateFromApiToFront(dto) {
+  return {
+    estimatedCount: dto.estimated_count,
+    key: dto.key
+  };
+}
+function FrequencyRequestFromFrontToApi(model) {
+  return {
+    dimensions: SketchDimensionsFromFrontToApi(model.dimensions),
+    items: model.items,
+    query_keys: model.queryKeys
+  };
+}
+function FrequencyResponseFromApiToFront(dto) {
+  return {
+    depth: dto.depth,
+    estimates: dto.estimates.map(FrequencyEstimateFromApiToFront),
+    width: dto.width
+  };
+}
+function HeavyHitterItemFromApiToFront(dto) {
+  return {
+    count: dto.count,
+    item: dto.item
+  };
+}
+function HeavyHittersRequestFromFrontToApi(model) {
+  return {
+    capacity: model.capacity,
+    items: model.items
+  };
+}
+function HeavyHittersResponseFromApiToFront(dto) {
+  return {
+    capacity: dto.capacity,
+    heavyHitters: dto.heavy_hitters.map(HeavyHitterItemFromApiToFront),
+    maxUndercount: dto.max_undercount,
+    total: dto.total
+  };
+}
+function BloomFilterStatsFromApiToFront(dto) {
+  return {
+    bitCount: dto.bit_count,
+    estimatedLoad: dto.estimated_load,
+    hashCount: dto.hash_count,
+    insertions: dto.insertions,
+    setBits: dto.set_bits
+  };
+}
+function MembershipRequestFromFrontToApi(model) {
+  return {
+    bit_count: model.bitCount,
+    hash_count: model.hashCount,
+    insert_items: model.insertItems,
+    test_items: model.testItems
+  };
+}
+function MembershipResultFromApiToFront(dto) {
+  return {
+    item: dto.item,
+    member: dto.member
+  };
+}
+function MembershipResponseFromApiToFront(dto) {
+  return {
+    filterStats: BloomFilterStatsFromApiToFront(dto.filter_stats),
+    membership: dto.membership.map(MembershipResultFromApiToFront)
+  };
+}
+
+// src/resources/streaming.ts
+var StreamingClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Estimate the frequency of each query key via a Count-Min sketch.
+   *
+   * @param request - The sketch dimensions, the stream `items`, and the
+   *   `queryKeys` to estimate.
+   * @returns The sketch dimensions actually used and one estimate per
+   *   query key, in request order.
+   *
+   * @throws {ApiError} `400` if `items`/`queryKeys` exceed their limits
+   *   or the sketch dimensions are invalid.
+   */
+  async frequency(request) {
+    const response = await this.api.frequency(FrequencyRequestFromFrontToApi(request));
+    return FrequencyResponseFromApiToFront(response.data);
+  }
+  /**
+   * Find candidate heavy hitters via a Misra-Gries sketch.
+   *
+   * @param request - The counter `capacity` and the stream `items`.
+   * @returns Candidate heavy hitters sorted by count descending, plus
+   *   the worst-case under-count bound.
+   *
+   * @throws {ApiError} `400` if `capacity < 1` or `items` exceeds the limit.
+   */
+  async heavyHitters(request) {
+    const response = await this.api.heavyHitters(HeavyHittersRequestFromFrontToApi(request));
+    return HeavyHittersResponseFromApiToFront(response.data);
+  }
+  /**
+   * Test membership of items in a Bloom filter built from `insertItems`.
+   *
+   * @param request - The `bitCount`, `hashCount`, `insertItems`, and
+   *   `testItems`.
+   * @returns Filter load statistics and one membership verdict per test
+   *   item, in request order. Zero false negatives.
+   *
+   * @throws {ApiError} `400` if `bitCount`/`hashCount < 1` or the item
+   *   arrays exceed their limits.
+   */
+  async membership(request) {
+    const response = await this.api.membership(MembershipRequestFromFrontToApi(request));
+    return MembershipResponseFromApiToFront(response.data);
+  }
+};
+
+// src/normalizers/conformal.ts
+function CalibrationSampleFromFrontToApi(model) {
+  return {
+    class_scores: model.classScores,
+    input_id: model.inputId,
+    true_label: model.trueLabel
+  };
+}
+function TestInputFromFrontToApi(model) {
+  return {
+    class_scores: model.classScores,
+    input_id: model.inputId
+  };
+}
+function ConformalCalibrateRequestFromFrontToApi(model) {
+  return {
+    alpha: model.alpha,
+    samples: model.samples.map(CalibrationSampleFromFrontToApi)
+  };
+}
+function ConformalCalibrateResponseFromApiToFront(dto) {
+  return {
+    algorithm: dto.algorithm,
+    alpha: dto.alpha,
+    empiricalCoverage: dto.empirical_coverage,
+    meetsTargetCoverage: dto.meets_target_coverage,
+    nSamples: dto.n_samples,
+    quantileRank: dto.quantile_rank,
+    threshold: dto.threshold
+  };
+}
+function ConformalPredictRequestFromFrontToApi(model) {
+  return {
+    alpha: model.alpha,
+    n_calibration_samples: model.nCalibrationSamples,
+    test_inputs: model.testInputs.map(TestInputFromFrontToApi),
+    threshold: model.threshold
+  };
+}
+function CoverageCertificateFromApiToFront(dto) {
+  return {
+    algorithm: dto.algorithm,
+    alpha: dto.alpha,
+    nCalibrationSamples: dto.n_calibration_samples,
+    nominalCoverage: dto.nominal_coverage,
+    threshold: dto.threshold
+  };
+}
+function ConformalPredictionFromApiToFront(dto) {
+  return {
+    abstains: dto.abstains,
+    inputId: dto.input_id,
+    predictionSet: dto.prediction_set,
+    topClass: dto.top_class,
+    topClassNonConformity: dto.top_class_non_conformity
+  };
+}
+function ConformalPredictResponseFromApiToFront(dto) {
+  return {
+    coverageCertificate: CoverageCertificateFromApiToFront(dto.coverage_certificate),
+    predictions: dto.predictions.map(ConformalPredictionFromApiToFront)
+  };
+}
+
+// src/resources/conformal.ts
+var ConformalClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Compute a split-conformal non-conformity threshold from a labeled
+   * calibration set.
+   *
+   * @param request - The calibration set (samples + target miscoverage
+   *   `α`).
+   * @returns The computed threshold `τ` plus a coverage certificate and
+   *   sanity-check coverage stats.
+   *
+   * @throws {ApiError} `400` if `alpha` is outside `(0, 1)` or the
+   *   calibration set is empty.
+   */
+  async calibrate(request) {
+    const response = await this.api.calibrate(ConformalCalibrateRequestFromFrontToApi(request));
+    return ConformalCalibrateResponseFromApiToFront(response.data);
+  }
+  /**
+   * Apply a pre-computed conformal threshold to unlabeled test inputs
+   * and return prediction sets with coverage certificates.
+   *
+   * @param request - The threshold `τ`, calibration `α` and sample count
+   *   (from a prior `calibrate` call), and the test inputs to predict
+   *   for.
+   * @returns Per-input conformal prediction results plus a coverage
+   *   certificate, in request order.
+   *
+   * @throws {ApiError} `400` if the test-input count exceeds 10 000.
+   */
+  async predict(request) {
+    const response = await this.api.predict(ConformalPredictRequestFromFrontToApi(request));
+    return ConformalPredictResponseFromApiToFront(response.data);
+  }
+};
+
+// src/normalizers/vision.ts
+function EncoderConfigOverridesFromFrontToApi(model) {
+  const dto = {};
+  if (model.numFrames !== void 0) dto.num_frames = model.numFrames;
+  if (model.patchSize !== void 0) dto.patch_size = model.patchSize;
+  if (model.sessionId !== void 0) dto.session_id = model.sessionId;
+  if (model.targetHeight !== void 0) dto.target_height = model.targetHeight;
+  if (model.targetWidth !== void 0) dto.target_width = model.targetWidth;
+  return dto;
+}
+function FrameSummaryFromApiToFront(dto) {
+  return {
+    frameIndex: dto.frame_index,
+    numPredictedObjects: dto.num_predicted_objects,
+    numResiduatedFeatures: dto.num_residuated_features,
+    objectLabels: dto.object_labels
+  };
+}
+function EncodeClipRequestFromFrontToApi(model) {
+  const dto = {
+    clip_id: model.clipId,
+    video_b64: model.videoB64
+  };
+  if (model.configOverrides !== void 0) {
+    dto.config_overrides = model.configOverrides === null ? null : EncoderConfigOverridesFromFrontToApi(model.configOverrides);
+  }
+  if (model.fps !== void 0) dto.fps = model.fps;
+  if (model.sourceUri !== void 0) dto.source_uri = model.sourceUri;
+  return dto;
+}
+function EncodeClipResponseFromApiToFront(dto) {
+  const out = {
+    clipId: dto.clip_id,
+    embeddingDim: dto.embedding_dim,
+    encodeElapsedMs: dto.encode_elapsed_ms,
+    frames: dto.frames.map(FrameSummaryFromApiToFront),
+    modelId: dto.model_id,
+    numInputFrames: dto.num_input_frames,
+    paddedFrameIndices: dto.padded_frame_indices,
+    totalObjects: dto.total_objects,
+    totalResiduatedFeatures: dto.total_residuated_features
+  };
+  if (dto.model_version != null) out.modelVersion = dto.model_version;
+  return out;
+}
+
+// src/resources/vision.ts
+var VisionClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Encode a video clip end-to-end and return per-frame predictions.
+   *
+   * @param request - The clip spec (base64 video, clip id, optional
+   *   config overrides / fps / source uri).
+   * @returns The embedding plus per-frame Ψ-term prediction summaries.
+   *
+   * @throws {ApiError} `503` if no V-JEPA perception service is mounted.
+   */
+  async encodeClip(request) {
+    const response = await this.api.encodeClip(EncodeClipRequestFromFrontToApi(request));
+    return EncodeClipResponseFromApiToFront(response.data);
+  }
+};
+
+// src/normalizers/anonymization.ts
+function quasiIdentifierFromFrontToApi(q) {
+  switch (q.type) {
+    case "numeric":
+      return { type: "numeric", precision: q.precision };
+    case "string":
+      return { type: "string", prefix_length: q.prefixLength };
+    case "categorical":
+      return { type: "categorical" };
+    case "hierarchical":
+      return { type: "hierarchical", hierarchy: q.hierarchy };
+    case "date":
+      return { type: "date", granularity: q.granularity };
+  }
+}
+function anonymizationModeFromFrontToApi(mode) {
+  if (mode.type === "k_anonymity") {
+    const quasiIdentifiers = {};
+    for (const [field, q] of Object.entries(mode.quasiIdentifiers)) {
+      quasiIdentifiers[field] = quasiIdentifierFromFrontToApi(q);
+    }
+    return { type: "k_anonymity", k: mode.k, quasi_identifiers: quasiIdentifiers };
+  }
+  if (mode.fieldIdentifiers !== void 0) {
+    return {
+      type: "safe_harbor",
+      field_identifiers: mode.fieldIdentifiers
+    };
+  }
+  return { type: "safe_harbor" };
+}
+function AnonymizeRequestFromFrontToApi(model) {
+  const dto = {
+    records: model.records,
+    mode: anonymizationModeFromFrontToApi(model.mode)
+  };
+  if (model.enforcement !== void 0) dto.enforcement = model.enforcement;
+  return dto;
+}
+function kAnonymityViolationFromApiToFront(wire) {
+  return {
+    quasiValues: wire.quasi_values,
+    count: wire.count,
+    requiredK: wire.required_k,
+    suggestion: wire.suggestion
+  };
+}
+function equivalenceClassFromApiToFront(wire) {
+  return {
+    quasiValues: wire.quasi_values,
+    count: wire.count,
+    recordIndices: wire.record_indices
+  };
+}
+function kAnonymityResultFromApiToFront(wire) {
+  return {
+    isKAnonymous: wire.is_k_anonymous,
+    k: wire.k,
+    totalRecords: wire.total_records,
+    equivalenceClassCount: wire.equivalence_class_count,
+    violations: wire.violations.map(kAnonymityViolationFromApiToFront),
+    equivalenceClasses: wire.equivalence_classes.map(equivalenceClassFromApiToFront),
+    minClassSize: wire.min_class_size,
+    maxClassSize: wire.max_class_size,
+    avgClassSize: wire.avg_class_size,
+    checkedAt: wire.checked_at
+  };
+}
+function recordSafeHarborStatusFromApiToFront(dto) {
+  return {
+    recordIndex: dto.record_index,
+    wasCompliant: dto.was_compliant,
+    suppressedFields: dto.suppressed_fields,
+    violationCount: dto.violation_count
+  };
+}
+function safeHarborSummaryFromApiToFront(dto) {
+  return {
+    compliantCount: dto.compliant_count,
+    deIdentifiedCount: dto.de_identified_count,
+    perRecord: dto.per_record.map(recordSafeHarborStatusFromApiToFront)
+  };
+}
+function AnonymizeResponseFromApiToFront(dto) {
+  const out = {
+    outputRecords: dto.output_records,
+    suppressedIndices: dto.suppressed_indices,
+    suppressedCount: dto.suppressed_count
+  };
+  if (dto.k_anonymity_result != null) {
+    out.kAnonymityResult = kAnonymityResultFromApiToFront(
+      dto.k_anonymity_result
+    );
+  }
+  if (dto.safe_harbor_summary != null) {
+    out.safeHarborSummary = safeHarborSummaryFromApiToFront(dto.safe_harbor_summary);
+  }
+  return out;
+}
+
+// src/resources/anonymization.ts
+var AnonymizationClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Batch-anonymize a set of records using k-anonymity or HIPAA Safe Harbor.
+   *
+   * @param request - The record batch, the anonymization mode + params, and
+   *   an optional enforcement strategy (defaults to `suppress`).
+   * @returns The processed records plus a full compliance report
+   *   (k-anonymity analysis or Safe Harbor summary).
+   *
+   * @throws {ApiError} `400` on an empty batch, > 10 000 records, or an
+   *   invalid anonymization mode.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.anonymization.anonymize({
+   *   records: [{ name: 'Alice', age: '42', zip: '12345' }],
+   *   mode: {
+   *     type: 'k_anonymity',
+   *     k: 5,
+   *     quasiIdentifiers: { age: { type: 'numeric', precision: 10 } },
+   *   },
+   * });
+   * console.log(result.kAnonymityResult?.isKAnonymous);
+   * ```
+   */
+  async anonymize(request) {
+    const response = await this.api.anonymizeRecords(AnonymizeRequestFromFrontToApi(request), {
+      headers: { [RAW_BODY_HEADER]: "1" }
+    });
+    return AnonymizeResponseFromApiToFront(response.data);
+  }
+};
+
+// src/normalizers/speakers.ts
+function EnrollSpeakerRequestFromFrontToApi(model) {
+  const dto = { audio: model.audio, name: model.name };
+  if (model.audioMime !== void 0) dto.audio_mime = model.audioMime;
+  return dto;
+}
+function EnrollSpeakerResponseFromApiToFront(dto) {
+  return {
+    dim: dto.dim,
+    id: dto.id,
+    name: dto.name,
+    sampleSecs: dto.sample_secs
+  };
+}
+function SpeakerProfileFromApiToFront(dto) {
+  return {
+    createdAt: dto.created_at,
+    id: dto.id,
+    name: dto.name,
+    sampleSecs: dto.sample_secs
+  };
+}
+function ListSpeakersResponseFromApiToFront(dto) {
+  return { speakers: dto.speakers.map(SpeakerProfileFromApiToFront) };
+}
+
+// src/resources/speakers.ts
+var SpeakersClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Enroll (or re-enroll) a speaker voiceprint for the authenticated tenant.
+   *
+   * @remarks
+   * Request body uses plain JSON keys (`audio`, `audio_mime`, `name`) with no
+   * user-keyed maps and no case-sensitive enum values, so the default bridge
+   * snake_casing is correct.
+   *
+   * @param request - The base64 audio sample, optional MIME hint, and name.
+   * @returns The embedding dimensionality, stable profile id, name, and
+   *   seconds of speech embedded.
+   *
+   * @throws {ApiError} On a non-2xx response (e.g. malformed audio).
+   */
+  async enrollSpeaker(request) {
+    const response = await this.api.enrollSpeaker(EnrollSpeakerRequestFromFrontToApi(request));
+    return EnrollSpeakerResponseFromApiToFront(response.data);
+  }
+  /**
+   * List the tenant's enrolled speaker profiles (embeddings withheld).
+   *
+   * @returns The stored speaker profiles for the authenticated tenant.
+   *
+   * @throws {ApiError} On a non-2xx response.
+   */
+  async listSpeakers() {
+    const response = await this.api.listSpeakers();
+    return ListSpeakersResponseFromApiToFront(response.data);
+  }
+  /**
+   * Delete a speaker profile by id.
+   *
+   * @param request - The stable profile (term) id of the speaker to delete.
+   *
+   * @throws {ApiError} `404` if no profile exists for the given id.
+   */
+  async deleteSpeaker(request) {
+    await this.api.deleteSpeaker(request.id);
+  }
+};
+
+// src/normalizers/speech.ts
+function VoiceConsentFromFrontToApi(model) {
+  const dto = {
+    granted_by: model.grantedBy,
+    method: model.method
+  };
+  if (model.reference !== void 0) dto.reference = model.reference;
+  return dto;
+}
+function VoiceConsentFromApiToFront(dto) {
+  const out = {
+    grantedBy: dto.granted_by,
+    method: dto.method
+  };
+  if (dto.reference != null) out.reference = dto.reference;
+  return out;
+}
+function VoiceProfileFromApiToFront(dto) {
+  return {
+    consent: VoiceConsentFromApiToFront(dto.consent),
+    createdAt: dto.created_at,
+    engine: dto.engine,
+    hasIcl: dto.has_icl,
+    id: dto.id,
+    name: dto.name,
+    sampleSecs: dto.sample_secs
+  };
+}
+function SpeechEngineFromApiToFront(dto) {
+  const out = {
+    available: dto.available,
+    engine: dto.engine,
+    presetSpeakers: dto.preset_speakers,
+    supportsCloning: dto.supports_cloning
+  };
+  if (dto.reason != null) out.reason = dto.reason;
+  return out;
+}
+function EnrollVoiceRequestFromFrontToApi(model) {
+  const dto = {
+    audio: model.audio,
+    consent: VoiceConsentFromFrontToApi(model.consent),
+    name: model.name
+  };
+  if (model.audioMime !== void 0) dto.audio_mime = model.audioMime;
+  if (model.engine !== void 0) dto.engine = model.engine;
+  if (model.transcript !== void 0) dto.transcript = model.transcript;
+  return dto;
+}
+function ListEnginesResponseFromApiToFront(dto) {
+  return {
+    engines: dto.engines.map(SpeechEngineFromApiToFront)
+  };
+}
+function ListVoicesResponseFromApiToFront(dto) {
+  return {
+    presets: dto.presets,
+    voices: dto.voices.map(VoiceProfileFromApiToFront)
+  };
+}
+function OpenSpeechSessionRequestFromFrontToApi(model) {
+  const dto = {};
+  if (model.conversationId !== void 0) dto.conversation_id = model.conversationId;
+  if (model.engine !== void 0) dto.engine = model.engine;
+  if (model.language !== void 0) dto.language = model.language;
+  if (model.voiceId !== void 0) dto.voice_id = model.voiceId;
+  return dto;
+}
+function OpenSpeechSessionResponseFromApiToFront(dto) {
+  return {
+    engine: dto.engine,
+    fullDuplex: dto.full_duplex,
+    inputSampleRate: dto.input_sample_rate,
+    sessionId: dto.session_id,
+    wsUrl: dto.ws_url
+  };
+}
+function SynthesizeSpeechRequestFromFrontToApi(model) {
+  const dto = { text: model.text };
+  if (model.refAudioBase64 !== void 0) dto.ref_audio_base64 = model.refAudioBase64;
+  if (model.description !== void 0) dto.description = model.description;
+  if (model.engine !== void 0) dto.engine = model.engine;
+  if (model.format !== void 0) dto.format = model.format;
+  if (model.instruction !== void 0) dto.instruction = model.instruction;
+  if (model.language !== void 0) dto.language = model.language;
+  if (model.maxDurationS !== void 0) dto.max_duration_s = model.maxDurationS;
+  if (model.refText !== void 0) dto.ref_text = model.refText;
+  if (model.seed !== void 0) dto.seed = model.seed;
+  if (model.speaker !== void 0) dto.speaker = model.speaker;
+  if (model.voiceId !== void 0) dto.voice_id = model.voiceId;
+  return dto;
+}
+function TranscribeSpeechRequestFromFrontToApi(model) {
+  const dto = { audio_base64: model.audioBase64 };
+  if (model.audioMime !== void 0) dto.audio_mime = model.audioMime;
+  if (model.format !== void 0) dto.format = model.format;
+  if (model.language !== void 0) dto.language = model.language;
+  return dto;
+}
+function TranscribeSpeechResponseFromApiToFront(dto) {
+  const out = {
+    model: dto.model,
+    text: dto.text
+  };
+  if (dto.duration_secs != null) out.durationSecs = dto.duration_secs;
+  return out;
+}
+
+// src/resources/speech.ts
+var SpeechClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Enroll (or re-enroll) a cloned voice from a reference clip.
+   *
+   * @param request - The enrollment spec (audio, consent, name, etc.).
+   * @returns The registered voice profile.
+   *
+   * @throws {ApiError} `400` if the clip is too short or consent is missing.
+   *
+   * @remarks
+   * Wire format: the request body is a JSON object with snake_case keys
+   * (`audio`, `audio_mime`, `consent`, `engine`, `name`, `transcript`);
+   * the response is a `VoiceProfileDto` with snake_case fields, normalized
+   * to camelCase here.
+   */
+  async enrollVoice(request) {
+    const response = await this.api.enrollVoice(
+      EnrollVoiceRequestFromFrontToApi(request)
+    );
+    return VoiceProfileFromApiToFront(response.data);
+  }
+  /**
+   * Report per-engine availability and capabilities.
+   *
+   * @returns The list of speech engines and their preset speakers.
+   *
+   * @remarks
+   * Wire format: the response is a `ListEnginesResponse` with snake_case
+   * fields, normalized to camelCase here.
+   */
+  async listEngines() {
+    const response = await this.api.listEngines();
+    return ListEnginesResponseFromApiToFront(response.data);
+  }
+  /**
+   * List the tenant's cloned voices plus available presets.
+   *
+   * @returns The enrolled voices and preset speaker names per engine.
+   *
+   * @remarks
+   * Wire format: the response is a `ListVoicesResponse` with snake_case
+   * fields (the `presets` map is returned verbatim), normalized to
+   * camelCase here.
+   */
+  async listVoices() {
+    const response = await this.api.listVoices();
+    return ListVoicesResponseFromApiToFront(response.data);
+  }
+  /**
+   * Open a speech-to-speech session.
+   *
+   * @param request - The session spec (engine, language, voice id, etc.).
+   * @returns The opened session, including the WebSocket media URL.
+   *
+   * @remarks
+   * Wire format: the request body is a JSON object with snake_case keys
+   * (`conversation_id`, `engine`, `language`, `voice_id`); the response is
+   * an `OpenSpeechSessionResponse` with snake_case fields, normalized to
+   * camelCase here.
+   */
+  async openSpeechSession(request) {
+    const response = await this.api.openSpeechSession(
+      OpenSpeechSessionRequestFromFrontToApi(request)
+    );
+    return OpenSpeechSessionResponseFromApiToFront(response.data);
+  }
+  /**
+   * Synthesize speech to raw audio bytes.
+   *
+   * @param request - The synthesis spec (text, engine, voice id, etc.).
+   * @returns The raw fetch `Response`. The body is raw audio bytes
+   *   (`content-type: audio/wav` on success); read it via
+   *   `.arrayBuffer()` or `.blob()`. Check `response.ok` / `response.status`
+   *   before reading the body — a non-2xx response body is a JSON
+   *   `ApiError`, a 2xx response body is audio.
+   *
+   * @throws {ApiError} On a non-2xx response (the error body is JSON, not
+   *   audio — inspect it before consuming the stream).
+   *
+   * @remarks
+   * Wire format: the request body is a JSON object with snake_case keys
+   * (`ref_audio_base64`, `max_duration_s`, `voice_id`, etc.). The response
+   * is NOT JSON — it is a binary audio stream, so this method returns the
+   * raw `Response` unchanged rather than a normalized DTO.
+   */
+  async synthesizeSpeech(request) {
+    const response = await this.api.synthesizeSpeech(
+      SynthesizeSpeechRequestFromFrontToApi(request)
+    );
+    return response;
+  }
+  /**
+   * Transcribe a short utterance.
+   *
+   * @param request - The transcription spec (base64 audio, mime, etc.).
+   * @returns The recognized text plus the model and optional duration.
+   *
+   * @remarks
+   * Wire format: the request body is a JSON object with snake_case keys
+   * (`audio_base64`, `audio_mime`, `format`, `language`); the response is
+   * a `TranscribeSpeechResponse` with snake_case fields, normalized to
+   * camelCase here.
+   */
+  async transcribeSpeech(request) {
+    const response = await this.api.transcribeSpeech(
+      TranscribeSpeechRequestFromFrontToApi(request)
+    );
+    return TranscribeSpeechResponseFromApiToFront(response.data);
+  }
+  /**
+   * Delete a cloned voice, upstream conditioning included.
+   *
+   * @param voiceId - The voice (term) id to delete.
+   *
+   * @remarks
+   * Wire format: no body; the voice id is a path parameter. Returns no
+   * content on success.
+   */
+  async deleteVoice(voiceId) {
+    await this.api.deleteVoice(voiceId);
+  }
+};
+
+// src/normalizers/connectors.ts
+function AddConnectorRequestFromFrontToApi(model) {
+  return {
+    name: model.name,
+    type: model.type
+  };
+}
+function AddConnectorResponseFromApiToFront(dto) {
+  return {
+    id: dto.id,
+    name: dto.name,
+    status: dto.status
+  };
+}
+function ConnectorTypeFromApiToFront(dto) {
+  const out = {
+    authType: dto.auth_type,
+    displayName: dto.display_name,
+    typeName: dto.type_name
+  };
+  if (dto.icon_url !== void 0) out.iconUrl = dto.icon_url;
+  return out;
+}
+function ConnectorInstanceFromApiToFront(dto) {
+  const out = {
+    displayName: dto.display_name,
+    id: dto.id,
+    name: dto.name,
+    status: dto.status,
+    typeName: dto.type_name
+  };
+  if (dto.connected_at !== void 0) out.connectedAt = dto.connected_at;
+  if (dto.connected_by !== void 0) out.connectedBy = dto.connected_by;
+  return out;
+}
+function OAuthStartResponseFromApiToFront(dto) {
+  return {
+    authUrl: dto.auth_url
+  };
+}
+
+// src/resources/connectors.ts
+var ConnectorsClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * List the connector types this build supports.
+   *
+   * @returns Every connector type's wire name, display name, auth type,
+   *   and optional icon URL.
+   */
+  async listTypes() {
+    const response = await this.api.listTypes();
+    return (response.data ?? []).map(ConnectorTypeFromApiToFront);
+  }
+  /**
+   * List all registered connector instances.
+   *
+   * @returns The registered instances, each with its connection status.
+   */
+  async list() {
+    const response = await this.api.list();
+    return (response.data ?? []).map(ConnectorInstanceFromApiToFront);
+  }
+  /**
+   * Register a new connector instance.
+   *
+   * @param request - The instance name and the connector type to register.
+   * @returns The newly-registered instance id, name, and status.
+   */
+  async add(request) {
+    const response = await this.api.add(AddConnectorRequestFromFrontToApi(request));
+    return AddConnectorResponseFromApiToFront(response.data);
+  }
+  /**
+   * Remove a registered connector instance.
+   *
+   * @param name - The instance name.
+   */
+  async remove(name) {
+    await this.api.remove(name);
+  }
+  /**
+   * Start an OAuth flow for a connector instance.
+   *
+   * @param name - The instance name.
+   * @returns The authorization URL the caller should redirect the user to.
+   */
+  async startOauth(name) {
+    const response = await this.api.startOauth(name);
+    return OAuthStartResponseFromApiToFront(response.data);
+  }
+  /**
+   * Disconnect a connector instance (drop its stored credentials).
+   *
+   * @param name - The instance name.
+   */
+  async disconnect(name) {
+    await this.api.disconnect(name);
+  }
+  /**
+   * OAuth callback — the provider redirects here after authorization.
+   *
+   * @param name - The instance name.
+   * @param query - The OAuth callback parameters (`code` on success;
+   *   `error`/`errorDescription` on failure; the opaque `state`).
+   * @returns The raw `Response` — the backend returns an HTML page that
+   *   posts a message to the opener window. The caller usually does not
+   *   need the body; check `response.ok` for transport errors.
+   *
+   * @remarks
+   * This endpoint is normally hit by the browser (the OAuth provider's
+   * redirect target), not called directly by SDK consumers. It is exposed
+   * for completeness / server-side testing.
+   */
+  async oauthCallback(name, query = {}) {
+    const response = await this.api.oauthCallback(name, query);
+    return response;
+  }
+};
+
 // src/client.ts
 var ReasoningLayerClient = class {
   /** Sort (type hierarchy) operations. */
@@ -34413,6 +36772,26 @@ var ReasoningLayerClient = class {
   agui;
   /** Ontology export — OWL ontology and SHACL shapes projected from the sort lattice. */
   ontologyExport;
+  /** Demo substrate seeding — full SUMO + demo scenarios into the tenant substrate. */
+  demo;
+  /** Execution-free reward scoring for candidate queries (recall / precision). */
+  reward;
+  /** Language translation (text → target language, markdown preserved). */
+  translation;
+  /** Probabilistic streaming sketches (Count-Min frequency, Misra-Gries heavy hitters, Bloom membership). */
+  streaming;
+  /** Split-conformal prediction — calibrate a non-conformity threshold, then predict with coverage certificates. */
+  conformal;
+  /** Video-clip encoding (V-JEPA substrate; per-frame predicted-sort labels). */
+  vision;
+  /** GDPR/HIPAA batch anonymization (k-anonymity or Safe Harbor). */
+  anonymization;
+  /** Speaker voiceprint enrollment + listing. */
+  speakers;
+  /** Speech synthesis / transcription / voice cloning + realtime session setup. */
+  speech;
+  /** External data connectors — register / list / remove / connect / disconnect + OAuth callback. */
+  connectors;
   // ─── Group Caches ─────────────────────────────────────────────────
   _core;
   _ai;
@@ -34720,6 +37099,16 @@ var ReasoningLayerClient = class {
     this.guardrail = new GuardrailClient(generatedGuardrail);
     this.agui = new AguiClient(generatedAgui);
     this.ontologyExport = new OntologyExportClient(generatedOntologyExport);
+    this.demo = new DemoClient(new Demo(generatedHttp));
+    this.reward = new RewardClient(new Reward(generatedHttp));
+    this.translation = new TranslationClient(new Translation(generatedHttp));
+    this.streaming = new StreamingClient(new Streaming(generatedHttp));
+    this.conformal = new ConformalClient(new Conformal(generatedHttp));
+    this.vision = new VisionClient(new Vision(generatedHttp));
+    this.anonymization = new AnonymizationClient(new Anonymization(generatedHttp));
+    this.speakers = new SpeakersClient(new Speakers(generatedHttp));
+    this.speech = new SpeechClient(new Speech(generatedHttp));
+    this.connectors = new ConnectorsClient(new Connectors(generatedHttp));
   }
 };
 
@@ -34973,6 +37362,36 @@ var agui_exports = {};
 // src/types/ontology-export.ts
 var ontology_export_exports = {};
 
+// src/types/demo.ts
+var demo_exports = {};
+
+// src/types/reward.ts
+var reward_exports = {};
+
+// src/types/translation.ts
+var translation_exports = {};
+
+// src/types/streaming.ts
+var streaming_exports = {};
+
+// src/types/conformal.ts
+var conformal_exports = {};
+
+// src/types/vision.ts
+var vision_exports = {};
+
+// src/types/anonymization.ts
+var anonymization_exports = {};
+
+// src/types/speakers.ts
+var speakers_exports = {};
+
+// src/types/speech.ts
+var speech_exports = {};
+
+// src/types/connectors.ts
+var connectors_exports = {};
+
 // src/builders/value.ts
 var Value = {
   /**
@@ -35984,6 +38403,7 @@ exports.Actions = actions_exports;
 exports.Admin = admin_exports;
 exports.Agui = agui_exports;
 exports.Analysis = analysis_exports;
+exports.Anonymization = anonymization_exports;
 exports.ApiError = ApiError;
 exports.AuthenticationError = AuthenticationError;
 exports.Authz = authz_exports;
@@ -35997,7 +38417,9 @@ exports.Collections = collections_exports;
 exports.Communities = communities_exports;
 exports.Compliance = compliance_exports;
 exports.ComplianceMarkings = compliance_markings_exports;
+exports.Conformal = conformal_exports;
 exports.Conformance = conformance_exports;
+exports.Connectors = connectors_exports;
 exports.Constraint = Constraint;
 exports.ConstraintViolationError = ConstraintViolationError;
 exports.Constraints = constraints_exports;
@@ -36005,6 +38427,7 @@ exports.Control = control_exports;
 exports.Conversation = conversation_exports;
 exports.Corpus = corpus_exports;
 exports.DL = dl_exports;
+exports.Demo = demo_exports;
 exports.Discovery = discovery_exports;
 exports.DocumentCheck = document_check_exports;
 exports.Documents = documents_exports;
@@ -36058,6 +38481,7 @@ exports.ReasoningLayerClient = ReasoningLayerClient;
 exports.ReasoningLayerError = ReasoningLayerError;
 exports.Research = research_exports;
 exports.Reviews = reviews_exports;
+exports.Reward = reward_exports;
 exports.Row = row_exports;
 exports.SDK_VERSION = SDK_VERSION;
 exports.Sat = sat_exports;
@@ -36070,17 +38494,22 @@ exports.Sorts = sorts_exports;
 exports.Sources = sources_exports;
 exports.Spaces = spaces_exports;
 exports.Sparql = sparql_exports;
+exports.Speakers = speakers_exports;
+exports.Speech = speech_exports;
 exports.Statistical = statistical_exports;
+exports.Streaming = streaming_exports;
 exports.Synthetic = synthetic_exports;
 exports.Temporal = temporal_exports;
 exports.Terms = terms_exports;
 exports.TimeoutError = TimeoutError;
+exports.Translation = translation_exports;
 exports.UI = ui_exports;
 exports.Utilities = utilities_exports;
 exports.ValidationError = ValidationError;
 exports.Value = Value;
 exports.Values = values_exports;
 exports.Verification = verification_exports;
+exports.Vision = vision_exports;
 exports.Visualization = visualization_exports;
 exports.WebSocketClient = WebSocketClient;
 exports.WebSocketConnection = WebSocketConnection;