@kortexya/reasoninglayer 1.24.0 → 1.26.0

package/dist/index.cjs

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "1.24.0";
+var SDK_VERSION = "1.26.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -8440,6 +8440,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.
    *
@@ -8476,6 +8493,22 @@ var Functions = class {
     format: "json",
     ...params
   });
+  /**
+   * @description # Why this route had to exist `/api/v1/functions` had five routes and none of them returned a definition: the listing answers summaries (`name`, `arity`, `clauses_count`, `kind`), and `GET /api/v1/functions/{name}` was a `405`. So `PUT` replaced a definition its caller could not see — a client fixing one clause of a three-clause function had to remember the other two or lose them, and the route made a partial edit look like a whole one (#235). # The clauses come back in the shape `PUT` takes [`GetFunctionResponse::clauses`] is the exact `clauses` payload `POST /functions/register` and `PUT /functions/{name}` accept, so a read-modify-write needs no translation layer that could drop a body variant on the way through. Making that true meant widening the request shape: `BinaryOperatorDto` carried four of the domain's thirteen operators and `ExpressionDto` was missing `UnaryOp` and `Conditional`, while OSFQL `DERIVE` builds function bodies with every one of them. A read in the old shape would have had to drop a `CASE WHEN` or lie about a `%`. # Reading is not changing A plugin-contributed function is refused by `DELETE` and `PUT` and **returned** by this route, with `replaceable: false` and the refusal the mutation would answer with. The listing already admits it exists; refusing to describe it would leave a client unable to show what the plugin contributed while still showing its name. The refusal is read from the same walk the mutation routes run, so the two cannot disagree. # Authorization Requires `X-Tenant-Id`. The function store is tenant-keyed, so another tenant's function is `404` rather than forbidden — saying anything else would confirm the name exists somewhere.
+   *
+   * @tags functions
+   * @name GetFunction
+   * @summary Read one registered function's definition.
+   * @request GET:/api/v1/functions/{name}
+   * @secure
+   */
+  getFunction = (name, params = {}) => this.http.request({
+    path: `/api/v1/functions/${name}`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description This is the discovery counterpart to `register_function`/`evaluate_function`: it projects the tenant's slice of the function sub-lattice into a list of typed signatures (name + arity + clause count) without evaluating anything. The tenant is taken from the authenticated principal (never a body field), honouring the tenancy-scoping invariant.
    *
@@ -8510,6 +8543,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
@@ -14332,7 +14383,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) {
@@ -15231,7 +15288,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) {
@@ -17403,7 +17461,7 @@ var ConstraintsClient = class {
       type: "application/json",
       format: "json"
     });
-    return response.data;
+    return ConstraintGraphResponseFromApiToFront(response.data);
   }
   // --- Session Management ---
   /**
@@ -23478,9 +23536,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,
@@ -26131,6 +26191,23 @@ function ExpressionDtoFromFrontToApi(model) {
       right: ExpressionDtoFromFrontToApi(model.right)
     };
   }
+  if (model.type === "UnaryOp") {
+    return {
+      type: "UnaryOp",
+      op: model.op,
+      operand: ExpressionDtoFromFrontToApi(model.operand)
+    };
+  }
+  if (model.type === "Conditional") {
+    return {
+      type: "Conditional",
+      branches: model.branches.map((b) => ({
+        when: ExpressionDtoFromFrontToApi(b.when),
+        then: ExpressionDtoFromFrontToApi(b.then)
+      })),
+      default: model.default ? ExpressionDtoFromFrontToApi(model.default) : model.default
+    };
+  }
   return model;
 }
 function ExpressionDtoFromApiToFront(dto) {
@@ -26149,6 +26226,23 @@ function ExpressionDtoFromApiToFront(dto) {
       right: ExpressionDtoFromApiToFront(dto.right)
     };
   }
+  if (dto.type === "UnaryOp") {
+    return {
+      type: "UnaryOp",
+      op: dto.op,
+      operand: ExpressionDtoFromApiToFront(dto.operand)
+    };
+  }
+  if (dto.type === "Conditional") {
+    return {
+      type: "Conditional",
+      branches: dto.branches.map((b) => ({
+        when: ExpressionDtoFromApiToFront(b.when),
+        then: ExpressionDtoFromApiToFront(b.then)
+      })),
+      default: dto.default ? ExpressionDtoFromApiToFront(dto.default) : dto.default
+    };
+  }
   return dto;
 }
 function FunctionBodyDtoFromFrontToApi(model) {
@@ -26337,6 +26431,54 @@ 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)
+  };
+}
+function GetFunctionResponseFromApiToFront(dto) {
+  const signature = {
+    name: dto.name,
+    functionId: dto.function_id,
+    arity: dto.arity,
+    kind: dto.kind,
+    replaceable: dto.replaceable,
+    notReplaceable: dto.not_replaceable ?? void 0,
+    // The wire omits the field when nothing calls it; the SDK always hands
+    // back an array, as the withdrawal report already does.
+    callers: (dto.callers ?? []).map(FunctionCallerFromApiToFront)
+  };
+  if (dto.clauses == null) {
+    return {
+      ...signature,
+      unrepresentable: dto.unrepresentable ?? "The engine returned no clauses for this function and gave no reason."
+    };
+  }
+  return { ...signature, clauses: dto.clauses.map(FunctionClauseDtoFromApiToFront) };
+}
 
 // src/resources/functions.ts
 var FunctionsClient = class {
@@ -26400,7 +26542,9 @@ var FunctionsClient = class {
    * ```
    */
   async registerFunction(request) {
-    const response = await this.api.registerFunction(RegisterFunctionRequestFromFrontToApi(request));
+    const response = await this.api.registerFunction(
+      RegisterFunctionRequestFromFrontToApi(request)
+    );
     return RegisterFunctionResponseFromApiToFront(response.data);
   }
   /**
@@ -26451,7 +26595,9 @@ var FunctionsClient = class {
    * ```
    */
   async evaluateFunction(request) {
-    const response = await this.api.evaluateFunction(EvaluateFunctionRequestFromFrontToApi(request));
+    const response = await this.api.evaluateFunction(
+      EvaluateFunctionRequestFromFrontToApi(request)
+    );
     return EvaluateFunctionResponseFromApiToFront(response.data);
   }
   /**
@@ -26481,6 +26627,128 @@ var FunctionsClient = class {
     const response = await this.api.listFunctions();
     return ListFunctionsResponseFromApiToFront(response.data);
   }
+  /**
+   * Read one registered function's definition.
+   *
+   * @param name - The registered function's name — its identity.
+   * @returns The signature, everything that calls it, whether a `PUT` would
+   *   act or refuse, and the clauses in the shape a replacement takes.
+   * @throws {ApiError} 404 if nothing is registered under that name for the
+   *   authenticated tenant. Another tenant's function is 404 too — saying
+   *   anything else would confirm the name exists somewhere.
+   *
+   * @remarks
+   * This is what makes {@link FunctionsClient.replaceFunction} an edit. `PUT`
+   * replaces the WHOLE definition, so without a read a client fixing one
+   * clause of a three-clause function had to re-author the other two from
+   * memory, and any it forgot were deleted.
+   *
+   * `clauses` and `unrepresentable` are exclusive: a definition holding a
+   * construct the register shape cannot express comes back with no clauses and
+   * a reason, because a degraded read written back would destroy the real
+   * definition. Narrow on `clauses === undefined` before using them.
+   *
+   * A plugin-contributed function is refused by `DELETE`/`PUT` and returned
+   * here, with `replaceable: false` and the refusal the mutation would give.
+   *
+   * @example
+   * ```typescript
+   * const definition = await client.functions.getFunction('scale');
+   * if (definition.clauses === undefined) {
+   *   throw new Error(`scale cannot be edited: ${definition.unrepresentable}`);
+   * }
+   * if (!definition.replaceable) {
+   *   throw new Error(definition.notReplaceable?.reason);
+   * }
+   * await client.functions.replaceFunction('scale', {
+   *   arity: definition.arity,
+   *   clauses: definition.clauses.map(tweak),
+   * });
+   * ```
+   */
+  async getFunction(name) {
+    const response = await this.api.getFunction(name);
+    return GetFunctionResponseFromApiToFront(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.
    *
@@ -27734,6 +28002,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
   };
 }
@@ -32898,7 +33167,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) {