@kortexya/reasoninglayer 1.25.0 → 1.26.0

package/dist/index.cjs

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "1.25.0";
+var SDK_VERSION = "1.26.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -8493,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.
    *
@@ -26175,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) {
@@ -26193,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) {
@@ -26409,6 +26459,26 @@ function ReplaceFunctionResponseFromApiToFront(dto) {
     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 {
@@ -26472,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);
   }
   /**
@@ -26523,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);
   }
   /**
@@ -26553,6 +26627,49 @@ 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.
    *