@kortexya/reasoninglayer 0.20.0 → 0.21.0

package/dist/index.js

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "0.20.0";
+var SDK_VERSION = "0.21.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -955,11 +955,10 @@ var Sorts = class {
     ...params
   });
   /**
-   * @description This enables semantic search over sort names for NER label pre-filtering. Must be called after bulk sort creation (e.g., after ontology hydration) to make sorts searchable via embedding similarity. Returns the number of sorts indexed.
+   * No description
    *
    * @tags sorts
    * @name IndexSorts
-   * @summary Index all sorts for a tenant into the vector store (Qdrant).
    * @request POST:/api/v1/sorts/index
    * @secure
    */
@@ -7405,6 +7404,22 @@ var Scheduling = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Same hard constraints as `/scheduling/feasibility` plus a list of soft `preferences` (each a per-cell score added to the optimizer's objective).  Returns the per-cell trichotomy across the space of **optimal** schedules, plus `total_score` (sum of preference scores at chosen cells in the optimum). `confirmed_true` / `confirmed_false` here are stronger than in `/feasibility`: they hold across every optimum, not every feasible schedule.  Cells with status `free` indicate ties — multiple optima exist and the cell varies between them. Preferences targeting cells that are already pinned, blocked by a day-off, restricted-to-shift, or otherwise structurally fixed are silently ignored — those cells are not the optimizer's choice to make.
+   *
+   * @tags scheduling
+   * @name Optimize
+   * @summary `POST /api/v1/scheduling/optimize`
+   * @request POST:/api/v1/scheduling/optimize
+   */
+  optimize = (data, params = {}) => this.http.request({
+    path: `/api/v1/scheduling/optimize`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/Admin.ts
@@ -20534,6 +20549,36 @@ function SchedulingFeasibilityResponseFromApiToFront(dto) {
     assignments: dto.assignments.map(AssignmentFromApiToFront)
   };
 }
+function PreferenceFromFrontToApi(pref) {
+  return {
+    agent_id: pref.agentId,
+    day: pref.day,
+    shift: pref.shift,
+    score: pref.score
+  };
+}
+function SchedulingOptimizeRequestFromFrontToApi(request) {
+  const dto = {
+    agents: request.agents.map(AgentSpecFromFrontToApi),
+    days: request.days,
+    shifts_per_day: request.shiftsPerDay,
+    demands: request.demands.map(ShiftDemandFromFrontToApi)
+  };
+  if (request.pins !== void 0) {
+    dto.pins = request.pins.map(PinFromFrontToApi);
+  }
+  if (request.preferences !== void 0) {
+    dto.preferences = request.preferences.map(PreferenceFromFrontToApi);
+  }
+  return dto;
+}
+function SchedulingOptimizeResponseFromApiToFront(dto) {
+  return {
+    status: dto.status,
+    totalScore: dto.total_score,
+    assignments: dto.assignments.map(AssignmentFromApiToFront)
+  };
+}
 
 // src/resources/scheduling.ts
 var SchedulingClient = class {
@@ -20564,6 +20609,70 @@ var SchedulingClient = class {
     );
     return SchedulingFeasibilityResponseFromApiToFront(response.data);
   }
+  /**
+   * Solve the scheduling problem with **soft preferences** and
+   * return the per-cell envelope across the space of *optimal*
+   * schedules.
+   *
+   * @param request - the scheduling problem plus optional
+   *   `preferences` (per-cell scores added to the optimizer's
+   *   objective).  Same hard-constraint shape as
+   *   {@link SchedulingClient.feasibility}.
+   * @returns a {@link SchedulingOptimizeResponse} with `totalScore`
+   *   and per-cell trichotomy across optimal schedules.
+   *
+   * @throws HTTP 400 errors are surfaced when the input is malformed
+   *   (duplicate agent IDs, pins or preferences referencing unknown
+   *   agents, ambiguous pin role on multi-role agents, role minima
+   *   exceeding total demand, etc.).
+   *
+   * @remarks
+   * The trichotomy returned here is **strictly stronger** than the
+   * one from {@link SchedulingClient.feasibility}:
+   *
+   *   - `"confirmed_true"` — assigned in *every* optimum.
+   *   - `"confirmed_false"` — assigned in *no* optimum.
+   *   - `"free"` — varies across the optima; the optimizer is indifferent
+   *     between equally-good choices.
+   *
+   * `totalScore` is the sum of {@link Preference.score} over assigned
+   * cells in the optimum (`0` when no preferences are supplied or
+   * the problem is infeasible).
+   *
+   * Preferences targeting structurally-fixed cells (pinned cells,
+   * day-off / shift-only restricted cells, agents not in the grid)
+   * are silently ignored — the optimizer has no choice to make there.
+   *
+   * Empty `preferences` is equivalent to calling
+   * {@link SchedulingClient.feasibility} (every feasible schedule
+   * is optimal under a zero objective), but slower; prefer
+   * `feasibility()` when you only need the feasibility envelope.
+   *
+   * @example Score Aisha as a strong preference for emergency cover
+   * ```typescript
+   * const report = await client.scheduling.optimize({
+   *   agents: [
+   *     { id: 'aisha', roles: ['icu', 'emergency'], maxAssignments: 5 },
+   *     { id: 'bob',   roles: ['general'],          maxAssignments: 5 },
+   *   ],
+   *   days: 7,
+   *   shiftsPerDay: 3,
+   *   demands: [{ day: 0, shift: 0, total: 2, roleMinimums: { icu: 1 } }],
+   *   preferences: [
+   *     { agentId: 'aisha', day: 0, shift: 0, score: 10 },
+   *   ],
+   * });
+   *
+   * console.log(report.totalScore);   // 10 if Aisha is in the optimum
+   * console.log(report.status);       // 'feasible' | 'infeasible'
+   * ```
+   */
+  async optimize(request) {
+    const response = await this.api.optimize(
+      SchedulingOptimizeRequestFromFrontToApi(request)
+    );
+    return SchedulingOptimizeResponseFromApiToFront(response.data);
+  }
 };
 
 // src/normalizers/osfql.ts