@kortexya/reasoninglayer 1.24.0 → 1.25.0

package/dist/index.js

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "1.24.0";
+var SDK_VERSION = "1.25.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -8438,6 +8438,23 @@ var Functions = class {
   constructor(http) {
     this.http = http;
   }
+  /**
+   * @description # The disposition is the caller's `?callers=refuse` (the default) refuses while anything calls the function and names every caller; `?callers=orphan` withdraws it anyway and reports the callers left naming something that no longer resolves. A withdrawal that silently orphans its callers is the state the missing route already produced. # Authorization Requires `X-Tenant-Id`. The function store is tenant-keyed, so another tenant's function is `404` rather than forbidden. Every request is captured by the audit middleware.
+   *
+   * @tags functions
+   * @name DeleteFunction
+   * @summary Withdraw a registered function.
+   * @request DELETE:/api/v1/functions/{name}
+   * @secure
+   */
+  deleteFunction = (name, query, params = {}) => this.http.request({
+    path: `/api/v1/functions/${name}`,
+    method: "DELETE",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description Never writes to the KB — returns a validated draft for human review.
    *
@@ -8508,6 +8525,24 @@ var Functions = class {
     format: "json",
     ...params
   });
+  /**
+   * @description # Why this is not `POST /functions/register` Registration already replaces by name — silently, reporting nothing about what it displaced. `PUT` is the operation that says so: it refuses when nothing is registered under the name (that is registration's job), and answers with the previous signature, the new one, whether the arity moved, and everything that calls the function. # The arity is the hazard A function's identity is its NAME, so a replacement keeps every caller's reference valid — nothing dangles. That is exactly why an arity change is dangerous rather than merely breaking: every call still resolves, and one passing the old number of arguments starts failing at evaluation time. Reported, not refused: the caller may be replacing the function precisely because its signature was wrong. # Authorization Identical to `DELETE`: tenant-keyed, plugin-owned functions refused, audited.
+   *
+   * @tags functions
+   * @name ReplaceFunction
+   * @summary Replace a registered function's definition.
+   * @request PUT:/api/v1/functions/{name}
+   * @secure
+   */
+  replaceFunction = (name, data, params = {}) => this.http.request({
+    path: `/api/v1/functions/${name}`,
+    method: "PUT",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/WebhookActions.ts
@@ -14330,7 +14365,13 @@ function RuleEntryDtoFromApiToFront(dto) {
     ruleId: dto.rule_id,
     head: PsiTermDtoFromApiToFront(dto.head),
     body: dto.body.map(PsiTermDtoFromApiToFront),
-    certainty: dto.certainty ?? void 0
+    certainty: dto.certainty ?? void 0,
+    origin: dto.origin,
+    withdrawable: dto.withdrawable,
+    notWithdrawable: dto.not_withdrawable ? {
+      code: dto.not_withdrawable.code,
+      reason: dto.not_withdrawable.reason
+    } : void 0
   };
 }
 function GetRulesResponseFromApiToFront(dto) {
@@ -15229,7 +15270,8 @@ function FindBySortRequestFromFrontToApi(model) {
   return {
     sort_id: model.sortId ?? void 0,
     sort_name: model.sortName ?? void 0,
-    filter: model.filter ?? void 0
+    filter: model.filter ?? void 0,
+    limit: model.limit ?? void 0
   };
 }
 function OsfSearchRequestFromFrontToApi(model) {
@@ -17401,7 +17443,7 @@ var ConstraintsClient = class {
       type: "application/json",
       format: "json"
     });
-    return response.data;
+    return ConstraintGraphResponseFromApiToFront(response.data);
   }
   // --- Session Management ---
   /**
@@ -23476,9 +23518,11 @@ function StructuredIngestionStatsDtoFromApiToFront(dto) {
     elapsedMs: dto.elapsed_ms,
     entitiesCreated: dto.entities_created,
     entitiesExtracted: dto.entities_extracted,
+    recordsAvailable: dto.records_available,
     recordsProcessed: dto.records_processed,
     relationsCreated: dto.relations_created,
     relationsDiscovered: dto.relations_discovered,
+    rowsCollapsed: dto.rows_collapsed,
     sortsCreated: dto.sorts_created,
     tablesDiscovered: dto.tables_discovered,
     termsCreated: dto.terms_created,
@@ -26335,6 +26379,34 @@ function DraftFunctionResponseFromApiToFront(dto) {
     warnings: dto.warnings
   };
 }
+function FunctionCallerFromApiToFront(dto) {
+  return {
+    kind: dto.kind,
+    name: dto.name,
+    termId: dto.term_id ?? void 0
+  };
+}
+function FunctionWithdrawalReportFromApiToFront(dto) {
+  return {
+    name: dto.name,
+    functionId: dto.function_id,
+    carrierDeleted: dto.carrier_deleted,
+    deregistered: dto.deregistered,
+    // The wire omits the field when nothing was orphaned; the SDK always
+    // hands back an array, so a caller never has to guard the read.
+    callersOrphaned: (dto.callers_orphaned ?? []).map(FunctionCallerFromApiToFront)
+  };
+}
+function ReplaceFunctionResponseFromApiToFront(dto) {
+  return {
+    name: dto.name,
+    functionId: dto.function_id,
+    previous: FunctionSummaryDtoFromApiToFront(dto.previous),
+    current: FunctionSummaryDtoFromApiToFront(dto.current),
+    arityChanged: dto.arity_changed,
+    callers: (dto.callers ?? []).map(FunctionCallerFromApiToFront)
+  };
+}
 
 // src/resources/functions.ts
 var FunctionsClient = class {
@@ -26479,6 +26551,85 @@ var FunctionsClient = class {
     const response = await this.api.listFunctions();
     return ListFunctionsResponseFromApiToFront(response.data);
   }
+  /**
+   * Withdraw a registered function.
+   *
+   * @param name - The registered function's name — its identity.
+   * @param options - `callers` decides what happens to the things that call
+   *   it. Defaults to `'refuse'`.
+   * @returns What the withdrawal removed, in each representation that held it.
+   * @throws {ApiError} 400 if something still calls the function under the
+   *   default `'refuse'` (the body carries `code: 'function_has_callers'` and
+   *   the caller list); 403 for a plugin-contributed function; 404 if nothing
+   *   is registered under that name.
+   *
+   * @remarks
+   * A function is carried twice — the durable `meta.function` carrier that is
+   * the source of truth, and the evaluator's own registry used for dispatch
+   * and recursive cross-calls — and the report names both, because forgetting
+   * either leaves it half-alive: still evaluable, or back after a restart.
+   *
+   * `'refuse'` names every caller; `'orphan'` withdraws anyway and reports the
+   * callers left naming something that no longer resolves.
+   *
+   * @example
+   * ```typescript
+   * const report = await client.functions.deleteFunction('scale', { callers: 'orphan' });
+   * for (const orphan of report.callersOrphaned) {
+   *   console.warn(`${orphan.kind} ${orphan.name} now calls a function that is gone`);
+   * }
+   * ```
+   */
+  async deleteFunction(name, options) {
+    const response = await this.api.deleteFunction(
+      name,
+      options?.callers === void 0 ? void 0 : { callers: options.callers }
+    );
+    return FunctionWithdrawalReportFromApiToFront(response.data);
+  }
+  /**
+   * Replace a registered function's definition.
+   *
+   * @param name - The registered function's name. Unchanged by the
+   *   replacement — the name IS the identity.
+   * @param request - The replacement's arity and clauses.
+   * @returns Both signatures, whether the arity moved, and everything that
+   *   calls the function.
+   * @throws {ApiError} 400 if the replacement's clauses are rejected — in
+   *   which case the registration is left exactly as it was; 403 for a
+   *   plugin-contributed function; 404 if nothing is registered under that
+   *   name (creating one is {@link FunctionsClient.registerFunction}'s job).
+   *
+   * @remarks
+   * `registerFunction` already replaces by name — silently, reporting nothing
+   * about what it displaced. This is the operation that says so.
+   *
+   * A function's identity is its NAME, so a replacement keeps every caller's
+   * reference valid: nothing dangles. That is exactly why an arity change is
+   * the dangerous edit — every call still resolves, and one passing the old
+   * argument count starts failing at evaluation time. `arityChanged` is
+   * reported rather than refused, because a caller may be replacing the
+   * function precisely because its signature was wrong.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.functions.replaceFunction('scale', {
+   *   arity: 2,
+   *   clauses: [multiplyClause],
+   * });
+   * if (result.arityChanged) {
+   *   console.warn(`arity ${result.previous.arity} -> ${result.current.arity};`,
+   *     `${result.callers.length} caller(s) were written against the old one`);
+   * }
+   * ```
+   */
+  async replaceFunction(name, request) {
+    const response = await this.api.replaceFunction(name, {
+      arity: request.arity,
+      clauses: request.clauses.map(FunctionClauseDtoFromFrontToApi)
+    });
+    return ReplaceFunctionResponseFromApiToFront(response.data);
+  }
   /**
    * Draft a user-defined function from a natural-language description.
    *
@@ -27732,6 +27883,7 @@ function ClearTenantResponseFromApiToFront(dto) {
     sortsDeleted: dto.sorts_deleted,
     inferenceStateCleared: dto.inference_state_cleared,
     cacheInvalidated: dto.cache_invalidated,
+    vectorsDeleted: dto.vectors_deleted,
     pluginInstallsDeleted: dto.plugin_installs_deleted
   };
 }
@@ -32896,7 +33048,14 @@ function BindingSummaryDtoFromApiToFront(dto) {
     keyColumns: dto.key_columns,
     sortId: dto.sort_id,
     sourceId: dto.source_id,
-    tableName: dto.table_name
+    tableName: dto.table_name,
+    keyProvenance: {
+      source: dto.key_provenance.source,
+      chosenBy: dto.key_provenance.chosen_by,
+      explanation: dto.key_provenance.explanation,
+      guaranteedUnique: dto.key_provenance.guaranteed_unique,
+      durability: dto.key_provenance.durability
+    }
   };
 }
 function ListBindingsResponseFromApiToFront(dto) {