@kortexya/reasoninglayer 0.1.3 → 0.1.4

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 // src/config.ts
+var SDK_VERSION = "0.1.4";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -171,14 +172,18 @@ function createApiError(status, body, headers) {
   }
 }
 function isErrorBody(body) {
-  return typeof body === "object" && body !== null && "error" in body && typeof body.error === "string" && "message" in body && typeof body.message === "string";
+  if (typeof body !== "object" || body === null) return false;
+  const obj = body;
+  return typeof obj.error === "string" && typeof obj.message === "string";
 }
 function isConstraintViolationBody(body) {
-  return isErrorBody(body) && "details" in body && typeof body.details === "object" && body.details !== null;
+  if (!isErrorBody(body)) return false;
+  if (!("details" in body)) return false;
+  const obj = body;
+  return typeof obj.details === "object" && obj.details !== null;
 }
 
 // src/http.ts
-var SDK_VERSION = "0.1.0";
 var HttpClient = class {
   config;
   constructor(config) {
@@ -299,6 +304,7 @@ var HttpClient = class {
         if (response.ok) {
           if (response.status === 204) {
             return {
+              // Accepted: 204 No Content has no body; caller must handle undefined for void endpoints
               data: void 0,
               status: response.status,
               headers: response.headers,
@@ -630,8 +636,11 @@ var SortsClient = class {
   /** @internal */
   http;
   /** @internal */
-  constructor(http) {
+  tenantId;
+  /** @internal */
+  constructor(http, tenantId) {
     this.http = http;
+    this.tenantId = tenantId;
   }
   /**
    * Create a new sort.
@@ -671,7 +680,10 @@ var SortsClient = class {
    * @returns Array of sorts.
    */
   async listSorts(options) {
-    const response = await this.http.get(BASE, options);
+    const response = await this.http.get(
+      `${BASE}/tenant/${this.tenantId}`,
+      options
+    );
     return response.sorts;
   }
   /**
@@ -809,7 +821,55 @@ var SortsClient = class {
    * @param options - Per-call request options.
    */
   async updateReviewStatus(sortId, request, options) {
-    await this.http.put(`${BASE}/${sortId}/review`, request, options);
+    await this.http.post(`${BASE}/${sortId}/review`, request, options);
+  }
+  // --- Sort Similarity Learning ---
+  /**
+   * Learn sort similarities from effect features.
+   *
+   * @param request - Learning parameters.
+   * @param options - Per-call request options.
+   * @returns Learning result with count of similarities found.
+   */
+  async learnSimilarities(request, options) {
+    return this.http.post(`${BASE}/learn-similarities`, request, options);
+  }
+  /**
+   * Get all learned similarities.
+   *
+   * @param options - Per-call request options.
+   * @returns List of learned similarities with status counts.
+   */
+  async getLearnedSimilarities(options) {
+    return this.http.get(`${BASE}/learned-similarities`, options);
+  }
+  /**
+   * Approve a learned similarity.
+   *
+   * @param request - Sort pair to approve.
+   * @param options - Per-call request options.
+   * @returns Approval result.
+   */
+  async approveSimilarity(request, options) {
+    return this.http.post(
+      `${BASE}/learned-similarities/approve`,
+      request,
+      options
+    );
+  }
+  /**
+   * Reject a learned similarity.
+   *
+   * @param request - Sort pair to reject with reason.
+   * @param options - Per-call request options.
+   * @returns Rejection result.
+   */
+  async rejectSimilarity(request, options) {
+    return this.http.post(
+      `${BASE}/learned-similarities/reject`,
+      request,
+      options
+    );
   }
   /**
    * Return a metadata-aware variant of this client.
@@ -820,14 +880,16 @@ var SortsClient = class {
    * @returns A new client instance whose methods return `Promise<ApiResponse<T>>`.
    */
   withMetadata() {
-    return new SortsClientWithMetadata(this.http);
+    return new SortsClientWithMetadata(this.http, this.tenantId);
   }
 };
 var SortsClientWithMetadata = class {
   http;
+  tenantId;
   /** @internal */
-  constructor(http) {
+  constructor(http, tenantId) {
     this.http = http;
+    this.tenantId = tenantId;
   }
   async createSort(request, options) {
     const result = await this.http.requestWithMetadata("POST", BASE, {
@@ -846,7 +908,11 @@ var SortsClientWithMetadata = class {
     return this.http.requestWithMetadata("DELETE", `${BASE}/${sortId}`, { options });
   }
   async listSorts(options) {
-    const result = await this.http.requestWithMetadata("GET", BASE, { options });
+    const result = await this.http.requestWithMetadata(
+      "GET",
+      `${BASE}/tenant/${this.tenantId}`,
+      { options }
+    );
     return { ...result, data: result.data.sorts };
   }
   async bulkCreateSorts(request, options) {
@@ -919,11 +985,39 @@ var SortsClientWithMetadata = class {
     });
   }
   async updateReviewStatus(sortId, request, options) {
-    return this.http.requestWithMetadata("PUT", `${BASE}/${sortId}/review`, {
+    return this.http.requestWithMetadata("POST", `${BASE}/${sortId}/review`, {
       body: request,
       options
     });
   }
+  async learnSimilarities(request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE}/learn-similarities`,
+      { body: request, options }
+    );
+  }
+  async getLearnedSimilarities(options) {
+    return this.http.requestWithMetadata(
+      "GET",
+      `${BASE}/learned-similarities`,
+      { options }
+    );
+  }
+  async approveSimilarity(request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE}/learned-similarities/approve`,
+      { body: request, options }
+    );
+  }
+  async rejectSimilarity(request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE}/learned-similarities/reject`,
+      { body: request, options }
+    );
+  }
 };
 
 // src/resources/terms.ts
@@ -1103,22 +1197,24 @@ var InferenceClient = class {
     return this.http.post(`${BASE3}/facts/bulk`, request, options);
   }
   /**
-   * Get all stored facts.
+   * Get all stored facts for a tenant.
    *
+   * @param tenantId - Tenant UUID.
    * @param options - Per-call request options.
-   * @returns Array of facts as PsiTerms.
+   * @returns Facts with count.
    */
-  async getFacts(options) {
-    return this.http.get(`${BASE3}/facts`, options);
+  async getFacts(tenantId, options) {
+    return this.http.get(`${BASE3}/facts/${tenantId}`, options);
   }
   /**
-   * Clear all stored facts.
+   * Clear all stored facts for a tenant.
    *
+   * @param tenantId - Tenant UUID.
    * @param options - Per-call request options.
    * @returns Clear result with facts_cleared count.
    */
-  async clearFacts(options) {
-    return this.http.delete(`${BASE3}/facts`, options);
+  async clearFacts(tenantId, options) {
+    return this.http.delete(`${BASE3}/facts/${tenantId}`, options);
   }
   /**
    * Run backward chaining inference (goal-directed proof search).
@@ -1282,11 +1378,11 @@ var InferenceClientWithMetadata = class {
       options
     });
   }
-  async getFacts(options) {
-    return this.http.requestWithMetadata("GET", `${BASE3}/facts`, { options });
+  async getFacts(tenantId, options) {
+    return this.http.requestWithMetadata("GET", `${BASE3}/facts/${tenantId}`, { options });
   }
-  async clearFacts(options) {
-    return this.http.requestWithMetadata("DELETE", `${BASE3}/facts`, {
+  async clearFacts(tenantId, options) {
+    return this.http.requestWithMetadata("DELETE", `${BASE3}/facts/${tenantId}`, {
       options
     });
   }
@@ -1372,7 +1468,12 @@ var QueryClient = class {
    * @returns Array of matching terms (tagged ValueDto format).
    */
   async findUnifiable(request, options) {
-    return this.http.post(`${BASE4}/unifiable`, request, options);
+    const response = await this.http.post(
+      `${BASE4}/unifiable`,
+      request,
+      options
+    );
+    return response.results;
   }
   /**
    * Find terms by sort.
@@ -1382,7 +1483,12 @@ var QueryClient = class {
    * @returns Array of matching terms (tagged ValueDto format).
    */
   async findBySort(request, options) {
-    return this.http.post(`${BASE4}/by-sort`, request, options);
+    const response = await this.http.post(
+      `${BASE4}/by-sort`,
+      request,
+      options
+    );
+    return response.terms;
   }
   /**
    * Execute an Order-Sorted Feature search.
@@ -1426,7 +1532,7 @@ var QueryClient = class {
    * @returns Interpreted query and results.
    */
   async nlQuery(request, options) {
-    return this.http.post(`${BASE4}/nl`, request, options);
+    return this.http.post("/api/v1/nl/query", request, options);
   }
   /**
    * Return a metadata-aware variant of this client.
@@ -1444,16 +1550,20 @@ var QueryClientWithMetadata = class {
     this.http = http;
   }
   async findUnifiable(request, options) {
-    return this.http.requestWithMetadata("POST", `${BASE4}/unifiable`, {
-      body: request,
-      options
-    });
+    const result = await this.http.requestWithMetadata(
+      "POST",
+      `${BASE4}/unifiable`,
+      { body: request, options }
+    );
+    return { ...result, data: result.data.results };
   }
   async findBySort(request, options) {
-    return this.http.requestWithMetadata("POST", `${BASE4}/by-sort`, {
-      body: request,
-      options
-    });
+    const result = await this.http.requestWithMetadata(
+      "POST",
+      `${BASE4}/by-sort`,
+      { body: request, options }
+    );
+    return { ...result, data: result.data.terms };
   }
   async osfSearch(request, options) {
     return this.http.requestWithMetadata("POST", `${BASE4}/osf-search`, {
@@ -1475,7 +1585,7 @@ var QueryClientWithMetadata = class {
     );
   }
   async nlQuery(request, options) {
-    return this.http.requestWithMetadata("POST", `${BASE4}/nl`, {
+    return this.http.requestWithMetadata("POST", "/api/v1/nl/query", {
       body: request,
       options
     });
@@ -1668,7 +1778,44 @@ var CognitiveClient = class {
    * @returns The feedback result.
    */
   async provideFeedback(request, options) {
-    return this.http.post(`${BASE5}/feedback`, request, options);
+    return this.http.post("/api/v1/cognitive/feedback", request, options);
+  }
+  // --- Integrated Cycle ---
+  /**
+   * Run a full integrated cognitive cycle (all 9 modules).
+   *
+   * @param request - Integrated cycle request with agent and tenant IDs.
+   * @param options - Per-call request options.
+   * @returns The integrated cycle outcome with duration.
+   */
+  async integratedCycle(request, options) {
+    return this.http.post(
+      `${BASE5}/integrated-cycle`,
+      request,
+      options
+    );
+  }
+  // --- KB Subscription ---
+  /**
+   * Subscribe an agent to knowledge base changes (HTTP-based).
+   *
+   * @param request - Subscription request with watched sorts/features.
+   * @param options - Per-call request options.
+   * @returns Subscription ID.
+   */
+  async subscribeToKb(request, options) {
+    return this.http.post(`${BASE5}/subscribe`, request, options);
+  }
+  // --- Episode Recording ---
+  /**
+   * Record an episodic memory entry for an agent.
+   *
+   * @param request - Episode to record.
+   * @param options - Per-call request options.
+   * @returns The created episode ID.
+   */
+  async recordEpisode(request, options) {
+    return this.http.post(`${BASE5}/episodes`, request, options);
   }
   // --- WebSocket Subscriptions ---
   /**
@@ -1814,7 +1961,26 @@ var CognitiveClientWithMetadata = class {
     );
   }
   async provideFeedback(request, options) {
-    return this.http.requestWithMetadata("POST", `${BASE5}/feedback`, {
+    return this.http.requestWithMetadata("POST", "/api/v1/cognitive/feedback", {
+      body: request,
+      options
+    });
+  }
+  async integratedCycle(request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE5}/integrated-cycle`,
+      { body: request, options }
+    );
+  }
+  async subscribeToKb(request, options) {
+    return this.http.requestWithMetadata("POST", `${BASE5}/subscribe`, {
+      body: request,
+      options
+    });
+  }
+  async recordEpisode(request, options) {
+    return this.http.requestWithMetadata("POST", `${BASE5}/episodes`, {
       body: request,
       options
     });
@@ -1932,6 +2098,7 @@ var FuzzyClientWithMetadata = class {
 
 // src/resources/constraints.ts
 var BASE7 = "/api/v1/constraints";
+var SESSION_BASE = "/api/v1/constraint-sessions";
 var ConstraintsClient = class {
   /** @internal */
   http;
@@ -1959,6 +2126,57 @@ var ConstraintsClient = class {
   async getGraph(request, options) {
     return this.http.post(`${BASE7}/graph`, request, options);
   }
+  // --- Session Management ---
+  /**
+   * Create a constraint session.
+   *
+   * @param request - Session creation parameters.
+   * @param options - Per-call request options.
+   * @returns Session status.
+   */
+  async createSession(request, options) {
+    return this.http.post(SESSION_BASE, request, options);
+  }
+  /**
+   * Get a constraint session by ID.
+   *
+   * @param sessionId - Session ID.
+   * @param options - Per-call request options.
+   * @returns Session status.
+   */
+  async getSession(sessionId, options) {
+    return this.http.get(`${SESSION_BASE}/${sessionId}`, options);
+  }
+  /**
+   * Add constraints to a session.
+   *
+   * @param sessionId - Session ID.
+   * @param request - Constraints to add.
+   * @param options - Per-call request options.
+   * @returns Updated session status.
+   */
+  async addConstraints(sessionId, request, options) {
+    return this.http.post(
+      `${SESSION_BASE}/${sessionId}/constraints`,
+      request,
+      options
+    );
+  }
+  /**
+   * Bind variables in a constraint session.
+   *
+   * @param sessionId - Session ID.
+   * @param request - Variable bindings.
+   * @param options - Per-call request options.
+   * @returns Binding result.
+   */
+  async bindVariables(sessionId, request, options) {
+    return this.http.post(
+      `${SESSION_BASE}/${sessionId}/bindings`,
+      request,
+      options
+    );
+  }
   /**
    * Return a metadata-aware variant of this client.
    *
@@ -1986,6 +2204,33 @@ var ConstraintsClientWithMetadata = class {
       options
     });
   }
+  async createSession(request, options) {
+    return this.http.requestWithMetadata("POST", SESSION_BASE, {
+      body: request,
+      options
+    });
+  }
+  async getSession(sessionId, options) {
+    return this.http.requestWithMetadata(
+      "GET",
+      `${SESSION_BASE}/${sessionId}`,
+      { options }
+    );
+  }
+  async addConstraints(sessionId, request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${SESSION_BASE}/${sessionId}/constraints`,
+      { body: request, options }
+    );
+  }
+  async bindVariables(sessionId, request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${SESSION_BASE}/${sessionId}/bindings`,
+      { body: request, options }
+    );
+  }
 };
 
 // src/resources/namespaces.ts
@@ -2301,6 +2546,82 @@ var ExecutionClient = class {
   async getChoicePoints(sessionId, options) {
     return this.http.get(`${BASE10}/sessions/${sessionId}/choice-points`, options);
   }
+  // --- Residuation ---
+  /**
+   * Residuate a goal (suspend until data becomes available).
+   *
+   * @param sessionId - Session ID.
+   * @param request - Residuation request.
+   * @param options - Per-call request options.
+   * @returns Residuation result.
+   */
+  async residuate(sessionId, request, options) {
+    return this.http.post(
+      `${BASE10}/sessions/${sessionId}/residuate`,
+      request,
+      options
+    );
+  }
+  /**
+   * Bind a term with sort and feature values.
+   *
+   * @param sessionId - Session ID.
+   * @param request - Binding request.
+   * @param options - Per-call request options.
+   * @returns Binding result with evaluation results from released residuations.
+   */
+  async bind(sessionId, request, options) {
+    return this.http.post(
+      `${BASE10}/sessions/${sessionId}/bindings`,
+      request,
+      options
+    );
+  }
+  /**
+   * Release residuations for a term (attempt evaluation).
+   *
+   * @param sessionId - Session ID.
+   * @param request - Release request.
+   * @param options - Per-call request options.
+   * @returns Released goals and evaluation results.
+   */
+  async releaseResiduations(sessionId, request, options) {
+    return this.http.post(
+      `${BASE10}/sessions/${sessionId}/residuate/release`,
+      request,
+      options
+    );
+  }
+  /**
+   * Append residuations from a source term to a target term.
+   *
+   * @param sessionId - Session ID.
+   * @param request - Append request.
+   * @param options - Per-call request options.
+   * @returns Append result.
+   */
+  async appendResiduations(sessionId, request, options) {
+    return this.http.post(
+      `${BASE10}/sessions/${sessionId}/residuations/append`,
+      request,
+      options
+    );
+  }
+  /**
+   * Get residuations for a term.
+   *
+   * @param sessionId - Session ID.
+   * @param request - Get residuations request.
+   * @param options - Per-call request options.
+   * @returns Residuation details.
+   */
+  async getResiduations(sessionId, request, options) {
+    return this.http.post(
+      `${BASE10}/sessions/${sessionId}/residuations`,
+      request,
+      options
+    );
+  }
   /**
    * Return a metadata-aware variant of this client.
    *
@@ -2363,6 +2684,41 @@ var ExecutionClientWithMetadata = class {
       { options }
     );
   }
+  async residuate(sessionId, request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE10}/sessions/${sessionId}/residuate`,
+      { body: request, options }
+    );
+  }
+  async bind(sessionId, request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE10}/sessions/${sessionId}/bindings`,
+      { body: request, options }
+    );
+  }
+  async releaseResiduations(sessionId, request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE10}/sessions/${sessionId}/residuate/release`,
+      { body: request, options }
+    );
+  }
+  async appendResiduations(sessionId, request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE10}/sessions/${sessionId}/residuations/append`,
+      { body: request, options }
+    );
+  }
+  async getResiduations(sessionId, request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE10}/sessions/${sessionId}/residuations`,
+      { body: request, options }
+    );
+  }
 };
 
 // src/resources/causal.ts
@@ -4900,21 +5256,671 @@ var ExtractClientWithMetadata = class {
   }
 };
 
-// src/client.ts
-var ReasoningLayerClient = class {
-  /** Sort (type hierarchy) operations. */
-  sorts;
-  /** Psi-term CRUD operations. */
-  terms;
-  /** Inference engine operations (backward/forward chaining, fuzzy, Bayesian, NAF). */
-  inference;
-  /** Query operations (unification, OSF search, validation). */
-  query;
-  /** Cognitive agent operations (BDI cycle, beliefs, goals, messaging). */
-  cognitive;
-  /** Fuzzy operations (unification, merge, subsumption, top-K search). */
-  fuzzy;
-  /** Constraint operations (arithmetic solving, graph visualization). */
+// src/resources/oversight.ts
+var BASE27 = "/api/v1/oversight";
+var OversightClient = class {
+  /** @internal */
+  http;
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Run single-pass FormalJudge oversight verification.
+   *
+   * @param request - Judge request with trajectory and user intent.
+   * @param options - Per-call request options.
+   * @returns Verdict, scores, violations, and optional certificate.
+   */
+  async judge(request, options) {
+    return this.http.post(`${BASE27}/judge`, request, options);
+  }
+  /**
+   * Run iterative refinement FormalJudge pipeline.
+   *
+   * @param request - Judge request with trajectory and user intent.
+   * @param options - Per-call request options.
+   * @returns Results from each refinement round with convergence status.
+   */
+  async refine(request, options) {
+    return this.http.post(
+      `${BASE27}/judge/refine`,
+      request,
+      options
+    );
+  }
+  /**
+   * Return a metadata-aware variant of this client.
+   *
+   * @returns A new client instance whose methods return `Promise<ApiResponse<T>>`.
+   */
+  withMetadata() {
+    return new OversightClientWithMetadata(this.http);
+  }
+};
+var OversightClientWithMetadata = class {
+  http;
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Run single-pass FormalJudge oversight verification.
+   *
+   * @param request - Judge request with trajectory and user intent.
+   * @param options - Per-call request options.
+   * @returns Verdict, scores, violations, and optional certificate wrapped in {@link ApiResponse}.
+   */
+  async judge(request, options) {
+    return this.http.requestWithMetadata("POST", `${BASE27}/judge`, {
+      body: request,
+      options
+    });
+  }
+  /**
+   * Run iterative refinement FormalJudge pipeline.
+   *
+   * @param request - Judge request with trajectory and user intent.
+   * @param options - Per-call request options.
+   * @returns Results from each refinement round with convergence status wrapped in {@link ApiResponse}.
+   */
+  async refine(request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE27}/judge/refine`,
+      { body: request, options }
+    );
+  }
+};
+
+// src/resources/cdl.ts
+var BASE28 = "/api/v1/cdl";
+var CdlClient = class {
+  /** @internal */
+  http;
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Run differentiable forward chaining (Phases 1+2).
+   *
+   * @param request - Forward chaining parameters.
+   * @param options - Per-call request options.
+   * @returns Weighted facts, iteration metrics, and symbolic result.
+   */
+  async differentiableForwardChain(request, options) {
+    return this.http.post(
+      `${BASE28}/forward-chain/differentiable`,
+      request,
+      options
+    );
+  }
+  /**
+   * Perform soft (differentiable) unification between two terms (Phase 2).
+   *
+   * @param request - Soft unification request with two term IDs.
+   * @param options - Per-call request options.
+   * @returns Confidence scores and compatibility.
+   */
+  async softUnify(request, options) {
+    return this.http.post(`${BASE28}/soft-unify`, request, options);
+  }
+  /**
+   * Run tagged forward chaining with probabilistic semiring (Phase 1).
+   *
+   * @param request - Tagged forward chaining parameters.
+   * @param options - Per-call request options.
+   * @returns Tagged facts with probabilities.
+   */
+  async taggedForwardChain(request, options) {
+    return this.http.post(`${BASE28}/forward-chain/tagged`, request, options);
+  }
+  /**
+   * Run monadic fixpoint inference (Phase 3).
+   *
+   * @param request - Monadic fixpoint parameters.
+   * @param options - Per-call request options.
+   * @returns Facts with monadic metadata.
+   */
+  async monadicFixpoint(request, options) {
+    return this.http.post(
+      `${BASE28}/monadic-fixpoint`,
+      request,
+      options
+    );
+  }
+  /**
+   * Run derived inference through composed CDL layer (Phase 4).
+   *
+   * @param request - Feature pairs for inference.
+   * @param options - Per-call request options.
+   * @returns Inference results with architecture info.
+   */
+  async derivedInference(request, options) {
+    return this.http.post(
+      `${BASE28}/derived-inference`,
+      request,
+      options
+    );
+  }
+  /**
+   * Classify text for safety violations using CDL fact grounding (Phase 5).
+   *
+   * @param request - Safety classification request.
+   * @param options - Per-call request options.
+   * @returns Safety decisions, probabilities, and model info.
+   */
+  async classifySafety(request, options) {
+    return this.http.post(
+      `${BASE28}/classify-safety`,
+      request,
+      options
+    );
+  }
+  /**
+   * Dynamically add a sort to the CDL architecture (Phase 6).
+   *
+   * @param request - Sort definition.
+   * @param options - Per-call request options.
+   * @returns Adaptation result with verification.
+   */
+  async dynamicAddSort(request, options) {
+    return this.http.post(
+      `${BASE28}/dynamic/add-sort`,
+      request,
+      options
+    );
+  }
+  /**
+   * Get CDL subsystem status.
+   *
+   * @param options - Per-call request options.
+   * @returns CDL component statuses.
+   */
+  async getStatus(options) {
+    return this.http.get(`${BASE28}/status`, options);
+  }
+  /**
+   * Return a metadata-aware variant of this client.
+   *
+   * @returns A new client instance whose methods return `Promise<ApiResponse<T>>`.
+   */
+  withMetadata() {
+    return new CdlClientWithMetadata(this.http);
+  }
+};
+var CdlClientWithMetadata = class {
+  http;
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  async differentiableForwardChain(request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE28}/forward-chain/differentiable`,
+      { body: request, options }
+    );
+  }
+  async softUnify(request, options) {
+    return this.http.requestWithMetadata("POST", `${BASE28}/soft-unify`, {
+      body: request,
+      options
+    });
+  }
+  async taggedForwardChain(request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE28}/forward-chain/tagged`,
+      { body: request, options }
+    );
+  }
+  async monadicFixpoint(request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE28}/monadic-fixpoint`,
+      { body: request, options }
+    );
+  }
+  async derivedInference(request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE28}/derived-inference`,
+      { body: request, options }
+    );
+  }
+  async classifySafety(request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE28}/classify-safety`,
+      { body: request, options }
+    );
+  }
+  async dynamicAddSort(request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE28}/dynamic/add-sort`,
+      { body: request, options }
+    );
+  }
+  async getStatus(options) {
+    return this.http.requestWithMetadata("GET", `${BASE28}/status`, {
+      options
+    });
+  }
+};
+
+// src/resources/neuro-symbolic.ts
+var BASE29 = "/api/v1/admin/neuro-symbolic";
+var NeuroSymbolicClient = class {
+  /** @internal */
+  http;
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get neuro-symbolic system status.
+   *
+   * @param options - Per-call request options.
+   * @returns System status.
+   */
+  async getStatus(options) {
+    return this.http.get(`${BASE29}/status`, options);
+  }
+  /**
+   * Get neuro-symbolic diagnostics.
+   *
+   * @param options - Per-call request options.
+   * @returns Diagnostics information.
+   */
+  async getDiagnostics(options) {
+    return this.http.get(`${BASE29}/diagnostics`, options);
+  }
+  /**
+   * Trigger scorer training.
+   *
+   * @param options - Per-call request options.
+   * @returns Training trigger result.
+   */
+  async trainScorer(options) {
+    return this.http.post(`${BASE29}/train`, void 0, options);
+  }
+  /**
+   * Trigger embedding training.
+   *
+   * @param options - Per-call request options.
+   * @returns Training trigger result.
+   */
+  async trainEmbeddings(options) {
+    return this.http.post(
+      `${BASE29}/train/embeddings`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * Trigger GFlowNet training.
+   *
+   * @param options - Per-call request options.
+   * @returns GFlowNet training result.
+   */
+  async trainGflownet(options) {
+    return this.http.post(
+      `${BASE29}/train/gflownet`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * Run end-to-end training.
+   *
+   * @param request - Training configuration.
+   * @param options - Per-call request options.
+   * @returns Training results.
+   */
+  async trainE2e(request, options) {
+    return this.http.post(`${BASE29}/train/e2e`, request, options);
+  }
+  /**
+   * Save trained weights.
+   *
+   * @param options - Per-call request options.
+   * @returns Save result.
+   */
+  async saveWeights(options) {
+    return this.http.post(`${BASE29}/save-weights`, void 0, options);
+  }
+  /**
+   * Verify embedding quality.
+   *
+   * @param options - Per-call request options.
+   * @returns Verification results for containment, meet preservation, and specificity.
+   */
+  async verifyEmbeddings(options) {
+    return this.http.get(
+      `${BASE29}/embeddings/verify`,
+      options
+    );
+  }
+  /**
+   * Look up a sort's box embedding.
+   *
+   * @param request - Sort box lookup request.
+   * @param options - Per-call request options.
+   * @returns Sort box coordinates and volume.
+   */
+  async sortBoxLookup(request, options) {
+    return this.http.post(
+      `${BASE29}/embeddings/sort-box`,
+      request,
+      options
+    );
+  }
+  /**
+   * Return a metadata-aware variant of this client.
+   *
+   * @returns A new client instance whose methods return `Promise<ApiResponse<T>>`.
+   */
+  withMetadata() {
+    return new NeuroSymbolicClientWithMetadata(this.http);
+  }
+};
+var NeuroSymbolicClientWithMetadata = class {
+  http;
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  async getStatus(options) {
+    return this.http.requestWithMetadata(
+      "GET",
+      `${BASE29}/status`,
+      { options }
+    );
+  }
+  async getDiagnostics(options) {
+    return this.http.requestWithMetadata(
+      "GET",
+      `${BASE29}/diagnostics`,
+      { options }
+    );
+  }
+  async trainScorer(options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE29}/train`,
+      { options }
+    );
+  }
+  async trainEmbeddings(options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE29}/train/embeddings`,
+      { options }
+    );
+  }
+  async trainGflownet(options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE29}/train/gflownet`,
+      { options }
+    );
+  }
+  async trainE2e(request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE29}/train/e2e`,
+      { body: request, options }
+    );
+  }
+  async saveWeights(options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE29}/save-weights`,
+      { options }
+    );
+  }
+  async verifyEmbeddings(options) {
+    return this.http.requestWithMetadata(
+      "GET",
+      `${BASE29}/embeddings/verify`,
+      { options }
+    );
+  }
+  async sortBoxLookup(request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE29}/embeddings/sort-box`,
+      { body: request, options }
+    );
+  }
+};
+
+// src/resources/analysis.ts
+var BASE30 = "/api/v1/analysis";
+var AnalysisClient = class {
+  /** @internal */
+  http;
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Run sort discovery analysis on existing terms.
+   *
+   * @param request - Discovery parameters.
+   * @param options - Per-call request options.
+   * @returns Discovery results with recommendations.
+   */
+  async sortDiscovery(request, options) {
+    return this.http.post(`${BASE30}/sort-discovery`, request, options);
+  }
+  /**
+   * Start an interactive attribute exploration session.
+   *
+   * @param request - Exploration parameters.
+   * @param options - Per-call request options.
+   * @returns Session ID and first question.
+   */
+  async startExploration(request, options) {
+    return this.http.post(
+      `${BASE30}/attribute-exploration/start`,
+      request,
+      options
+    );
+  }
+  /**
+   * Confirm the current implication in an exploration session.
+   *
+   * @param sessionId - Exploration session ID.
+   * @param options - Per-call request options.
+   * @returns Next question and progress.
+   */
+  async confirmImplication(sessionId, options) {
+    return this.http.post(
+      `${BASE30}/attribute-exploration/${sessionId}/confirm`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * Refute the current implication with a counterexample.
+   *
+   * @param sessionId - Exploration session ID.
+   * @param request - Counterexample.
+   * @param options - Per-call request options.
+   * @returns Next question and progress.
+   */
+  async refuteImplication(sessionId, request, options) {
+    return this.http.post(
+      `${BASE30}/attribute-exploration/${sessionId}/refute`,
+      request,
+      options
+    );
+  }
+  /**
+   * Get the current status of an exploration session.
+   *
+   * @param sessionId - Exploration session ID.
+   * @param options - Per-call request options.
+   * @returns Session status with progress and confirmed implications.
+   */
+  async getExplorationStatus(sessionId, options) {
+    return this.http.get(
+      `${BASE30}/attribute-exploration/${sessionId}/status`,
+      options
+    );
+  }
+  /**
+   * Complete an exploration session and create rules from the discovered basis.
+   *
+   * @param sessionId - Exploration session ID.
+   * @param options - Per-call request options.
+   * @returns Final implications and rules created.
+   */
+  async completeExploration(sessionId, options) {
+    return this.http.post(
+      `${BASE30}/attribute-exploration/${sessionId}/complete`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * Return a metadata-aware variant of this client.
+   *
+   * @returns A new client instance whose methods return `Promise<ApiResponse<T>>`.
+   */
+  withMetadata() {
+    return new AnalysisClientWithMetadata(this.http);
+  }
+};
+var AnalysisClientWithMetadata = class {
+  http;
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  async sortDiscovery(request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE30}/sort-discovery`,
+      { body: request, options }
+    );
+  }
+  async startExploration(request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE30}/attribute-exploration/start`,
+      { body: request, options }
+    );
+  }
+  async confirmImplication(sessionId, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE30}/attribute-exploration/${sessionId}/confirm`,
+      { options }
+    );
+  }
+  async refuteImplication(sessionId, request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE30}/attribute-exploration/${sessionId}/refute`,
+      { body: request, options }
+    );
+  }
+  async getExplorationStatus(sessionId, options) {
+    return this.http.requestWithMetadata(
+      "GET",
+      `${BASE30}/attribute-exploration/${sessionId}/status`,
+      { options }
+    );
+  }
+  async completeExploration(sessionId, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE30}/attribute-exploration/${sessionId}/complete`,
+      { options }
+    );
+  }
+};
+
+// src/resources/preferences.ts
+var BASE31 = "/api/v1/preferences";
+var PreferencesClient = class {
+  /** @internal */
+  http;
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Record a user's term selection for preference learning.
+   *
+   * @param request - Selection to record.
+   * @param options - Per-call request options.
+   * @returns Recording result.
+   */
+  async recordSelection(request, options) {
+    return this.http.post(`${BASE31}/selection`, request, options);
+  }
+  /**
+   * Predict user preferences for candidate terms.
+   *
+   * @param request - Prediction request with candidates.
+   * @param options - Per-call request options.
+   * @returns Predictions sorted by score.
+   */
+  async predict(request, options) {
+    return this.http.post(`${BASE31}/predict`, request, options);
+  }
+  /**
+   * Return a metadata-aware variant of this client.
+   *
+   * @returns A new client instance whose methods return `Promise<ApiResponse<T>>`.
+   */
+  withMetadata() {
+    return new PreferencesClientWithMetadata(this.http);
+  }
+};
+var PreferencesClientWithMetadata = class {
+  http;
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  async recordSelection(request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE31}/selection`,
+      { body: request, options }
+    );
+  }
+  async predict(request, options) {
+    return this.http.requestWithMetadata(
+      "POST",
+      `${BASE31}/predict`,
+      { body: request, options }
+    );
+  }
+};
+
+// src/client.ts
+var ReasoningLayerClient = class {
+  /** Sort (type hierarchy) operations. */
+  sorts;
+  /** Psi-term CRUD operations. */
+  terms;
+  /** Inference engine operations (backward/forward chaining, fuzzy, Bayesian, NAF). */
+  inference;
+  /** Query operations (unification, OSF search, validation). */
+  query;
+  /** Cognitive agent operations (BDI cycle, beliefs, goals, messaging). */
+  cognitive;
+  /** Fuzzy operations (unification, merge, subsumption, top-K search). */
+  fuzzy;
+  /** Constraint operations (arithmetic solving, graph visualization). */
   constraints;
   /** Namespace operations (hierarchy, imports, metadata). */
   namespaces;
@@ -4956,6 +5962,16 @@ var ReasoningLayerClient = class {
   discovery;
   /** Entity extraction operations. */
   extract;
+  /** FormalJudge oversight operations (safety verification, refinement). */
+  oversight;
+  /** Categorical Deep Learning operations (differentiable FC, soft unification, safety). */
+  cdl;
+  /** Neuro-symbolic operations (training, embeddings, diagnostics). */
+  neuroSymbolic;
+  /** Analysis and FCA operations (sort discovery, attribute exploration). */
+  analysis;
+  /** Bayesian preference learning operations (selection recording, prediction). */
+  preferences;
   /**
    * Create a new ReasoningLayerClient.
    *
@@ -4967,7 +5983,7 @@ var ReasoningLayerClient = class {
     const resolved = resolveConfig(config);
     const http = new HttpClient(resolved);
     const ws = new WebSocketClient(resolved);
-    this.sorts = new SortsClient(http);
+    this.sorts = new SortsClient(http, resolved.tenantId);
     this.terms = new TermsClient(http);
     this.inference = new InferenceClient(http);
     this.query = new QueryClient(http);
@@ -4994,6 +6010,11 @@ var ReasoningLayerClient = class {
     this.actionReviews = new ActionReviewsClient(http);
     this.discovery = new DiscoveryClient(http);
     this.extract = new ExtractClient(http);
+    this.oversight = new OversightClient(http);
+    this.cdl = new CdlClient(http);
+    this.neuroSymbolic = new NeuroSymbolicClient(http);
+    this.analysis = new AnalysisClient(http);
+    this.preferences = new PreferencesClient(http);
   }
 };
 
@@ -5758,6 +6779,20 @@ var SortBuilder = class _SortBuilder {
 };
 
 // src/builders/psi.ts
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function coerceObjectFeatures(obj) {
+  const rawFeatures = obj.features;
+  if (!isPlainObject(rawFeatures)) {
+    return void 0;
+  }
+  const coerced = {};
+  for (const [k, v] of Object.entries(rawFeatures)) {
+    coerced[k] = coerceFeatureValue(v);
+  }
+  return coerced;
+}
 function coerceFeatureValue(value) {
   if (value === null) {
     throw new ValidationError("null is not a valid feature value in psi() shorthand. Use FeatureInput.uninstantiated() for null values.");
@@ -5774,38 +6809,29 @@ function coerceFeatureValue(value) {
   if (Array.isArray(value)) {
     return value.map(coerceFeatureValue);
   }
-  if (typeof value === "object") {
-    const obj = value;
-    if ("term_id" in obj && typeof obj.term_id === "string") {
-      return { term_id: obj.term_id };
+  if (isPlainObject(value)) {
+    if ("term_id" in value && typeof value.term_id === "string") {
+      return { term_id: value.term_id };
     }
-    if ("name" in obj && typeof obj.name === "string" && "constraint" in obj) {
-      return { name: obj.name, constraint: obj.constraint };
+    if ("name" in value && typeof value.name === "string" && "constraint" in value) {
+      return { name: value.name, constraint: value.constraint };
     }
-    if ("name" in obj && typeof obj.name === "string") {
-      return { name: obj.name };
+    if ("name" in value && typeof value.name === "string") {
+      return { name: value.name };
     }
-    if ("sort_name" in obj && typeof obj.sort_name === "string") {
-      const features = obj.features;
+    if ("sort_name" in value && typeof value.sort_name === "string") {
+      const features = coerceObjectFeatures(value);
       if (features) {
-        const coerced = {};
-        for (const [k, v] of Object.entries(features)) {
-          coerced[k] = coerceFeatureValue(v);
-        }
-        return { sort_name: obj.sort_name, features: coerced };
+        return { sort_name: value.sort_name, features };
       }
-      return { sort_name: obj.sort_name };
+      return { sort_name: value.sort_name };
     }
-    if ("sort_id" in obj && typeof obj.sort_id === "string") {
-      const features = obj.features;
+    if ("sort_id" in value && typeof value.sort_id === "string") {
+      const features = coerceObjectFeatures(value);
       if (features) {
-        const coerced = {};
-        for (const [k, v] of Object.entries(features)) {
-          coerced[k] = coerceFeatureValue(v);
-        }
-        return { sort_id: obj.sort_id, features: coerced };
+        return { sort_id: value.sort_id, features };
       }
-      return { sort_id: obj.sort_id };
+      return { sort_id: value.sort_id };
     }
   }
   throw new ValidationError(`Cannot coerce value of type ${typeof value} to FeatureInputValueDto`);
@@ -5857,9 +6883,6 @@ function discriminateFeatureValue(value) {
   );
 }
 
-// src/index.ts
-var SDK_VERSION2 = "0.1.0";
-
 exports.ApiError = ApiError;
 exports.BadRequestError = BadRequestError;
 exports.ConstraintViolationError = ConstraintViolationError;
@@ -5871,7 +6894,7 @@ exports.NotFoundError = NotFoundError;
 exports.RateLimitError = RateLimitError;
 exports.ReasoningLayerClient = ReasoningLayerClient;
 exports.ReasoningLayerError = ReasoningLayerError;
-exports.SDK_VERSION = SDK_VERSION2;
+exports.SDK_VERSION = SDK_VERSION;
 exports.SortBuilder = SortBuilder;
 exports.TermInput = TermInput;
 exports.TimeoutError = TimeoutError;