@kortexya/reasoninglayer 1.1.0 → 1.2.0

package/dist/index.cjs

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "1.1.0";
+var SDK_VERSION = "1.2.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -7653,6 +7653,100 @@ var Scheduling = class {
   });
 };
 
+// src/api-spec/generated/FlowNetworks.ts
+var FlowNetworks = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * No description
+   *
+   * @tags flow-networks
+   * @name CloneFlowNetwork
+   * @summary Clone a flow network for what-if analysis.
+   * @request POST:/api/v1/flow-networks/{network_id}/clone
+   * @secure
+   */
+  cloneFlowNetwork = (networkId, params = {}) => this.http.request({
+    path: `/api/v1/flow-networks/${networkId}/clone`,
+    method: "POST",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags flow-networks
+   * @name CommitFlowNetwork
+   * @summary Commit structural mutations (capacity updates and/or new edges).
+   * @request POST:/api/v1/flow-networks/{network_id}/commit
+   * @secure
+   */
+  commitFlowNetwork = (networkId, data, params = {}) => this.http.request({
+    path: `/api/v1/flow-networks/${networkId}/commit`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags flow-networks
+   * @name CreateFlowNetwork
+   * @summary Create a new flow network.
+   * @request POST:/api/v1/flow-networks
+   * @secure
+   */
+  createFlowNetwork = (data, params = {}) => this.http.request({
+    path: `/api/v1/flow-networks`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags flow-networks
+   * @name GetFlowNetwork
+   * @summary Get a flow network's status.
+   * @request GET:/api/v1/flow-networks/{network_id}
+   * @secure
+   */
+  getFlowNetwork = (networkId, params = {}) => this.http.request({
+    path: `/api/v1/flow-networks/${networkId}`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags flow-networks
+   * @name SolveFlowNetwork
+   * @summary Solve a flow network with the chosen algorithm.
+   * @request POST:/api/v1/flow-networks/{network_id}/solve
+   * @secure
+   */
+  solveFlowNetwork = (networkId, data, params = {}) => this.http.request({
+    path: `/api/v1/flow-networks/${networkId}/solve`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
 // src/api-spec/generated/Admin.ts
 var Admin = class {
   http;
@@ -9514,19 +9608,10 @@ function ConstraintInputDtoFromFrontToApi(model) {
   }
 }
 function BackwardChainResponseFromApiToFront(dto) {
-  const wireRefs = dto.referenced_terms;
-  let referencedTerms;
-  if (wireRefs) {
-    referencedTerms = {};
-    for (const [uuid, term] of Object.entries(wireRefs)) {
-      referencedTerms[uuid] = TermDtoFromApiToFront(term);
-    }
-  }
   return {
     solutions: dto.solutions.map(SolutionDtoFromApiToFront),
     queryTimeMs: dto.query_time_ms,
-    goalId: dto.goal_id ?? void 0,
-    referencedTerms
+    goalId: dto.goal_id ?? void 0
   };
 }
 function ForwardChainResponseFromApiToFront(dto) {
@@ -9898,8 +9983,7 @@ function BackwardChainRequestFromFrontToApi(model) {
     max_solutions: model.maxSolutions,
     min_certainty: model.minCertainty,
     timeout_ms: model.timeoutMs ?? void 0,
-    constraints: model.constraints?.map(ConstraintInputDtoFromFrontToApi),
-    expand_bindings: model.expandBindings
+    constraints: model.constraints?.map(ConstraintInputDtoFromFrontToApi)
   };
 }
 function ForwardChainRequestFromFrontToApi(model) {
@@ -10052,12 +10136,6 @@ var InferenceClient = class {
    *
    * The `timeout_ms` field on the request is a wall-clock timeout for the search.
    * When it fires, the backend returns whatever solutions have been found so far.
-   *
-   * Pass `expandBindings: true` to receive the full {@link TermDto} of every
-   * Ψ-term transitively referenced by a solution's bindings in the
-   * `referencedTerms` sidecar map of the response. Lets the caller read complex
-   * bound values (lists of nested Ψ-terms etc.) without follow-up
-   * `terms.get(uuid)` calls.
    */
   async backwardChain(request) {
     const wireRequest = {
@@ -21075,6 +21153,181 @@ var SchedulingClient = class {
   }
 };
 
+// src/normalizers/flow-networks.ts
+function EdgeSpecFromFrontToApi(edge) {
+  const dto = {
+    from: edge.from,
+    to: edge.to,
+    capacity: edge.capacity
+  };
+  if (edge.cost !== void 0 && edge.cost !== null) {
+    dto.cost = edge.cost;
+  }
+  if (edge.label !== void 0 && edge.label !== null) {
+    dto.label = edge.label;
+  }
+  return dto;
+}
+function EdgeCapacityUpdateFromFrontToApi(update) {
+  return { label: update.label, capacity: update.capacity };
+}
+function CreateFlowNetworkRequestFromFrontToApi(request) {
+  const dto = {
+    nodes: request.nodes,
+    source: request.source,
+    sink: request.sink,
+    edges: request.edges.map(EdgeSpecFromFrontToApi)
+  };
+  if (request.description !== void 0 && request.description !== null) {
+    dto.description = request.description;
+  }
+  return dto;
+}
+function CommitFlowNetworkRequestFromFrontToApi(request) {
+  const dto = {};
+  if (request.updateCapacities !== void 0) {
+    dto.update_capacities = request.updateCapacities.map(
+      EdgeCapacityUpdateFromFrontToApi
+    );
+  }
+  if (request.addEdges !== void 0) {
+    dto.add_edges = request.addEdges.map(EdgeSpecFromFrontToApi);
+  }
+  return dto;
+}
+function SolveFlowNetworkRequestFromFrontToApi(request) {
+  return { algorithm: request.algorithm };
+}
+function FlowNetworkResponseFromApiToFront(dto) {
+  return {
+    id: dto.id,
+    source: dto.source,
+    sink: dto.sink,
+    nodeCount: dto.node_count,
+    edgeCount: dto.edge_count,
+    description: dto.description ?? void 0
+  };
+}
+function EdgeFlowFromApiToFront(dto) {
+  return {
+    from: dto.from,
+    to: dto.to,
+    label: dto.label ?? void 0,
+    capacity: dto.capacity,
+    flow: dto.flow
+  };
+}
+function EdgeClassificationFromApiToFront(dto) {
+  return {
+    from: dto.from,
+    to: dto.to,
+    label: dto.label ?? void 0,
+    class: dto.class
+  };
+}
+function MinCutFromApiToFront(dto) {
+  return {
+    sourceSide: dto.source_side,
+    sinkSide: dto.sink_side,
+    cutEdges: dto.cut_edges.map(EdgeFlowFromApiToFront)
+  };
+}
+function SolveFlowNetworkResponseFromApiToFront(dto) {
+  const wireClassifications = dto.classifications;
+  return {
+    algorithm: dto.algorithm,
+    edgeFlows: dto.edge_flows.map(EdgeFlowFromApiToFront),
+    totalFlow: dto.total_flow ?? void 0,
+    totalCost: dto.total_cost ?? void 0,
+    classifications: wireClassifications ? wireClassifications.map(EdgeClassificationFromApiToFront) : void 0,
+    minCut: dto.min_cut ? MinCutFromApiToFront(dto.min_cut) : void 0
+  };
+}
+
+// src/resources/flow-networks.ts
+var FlowNetworksClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Create and persist a new flow network.
+   *
+   * @param request - graph shape, source/sink, and initial edges.
+   * @returns metadata for the new network (including its id).
+   * @throws HTTP 400 if the input is malformed (duplicate node names,
+   *   source/sink not in `nodes`, edges referencing unknown nodes,
+   *   negative capacities, duplicate edge labels).
+   */
+  async create(request) {
+    const response = await this.api.createFlowNetwork(
+      CreateFlowNetworkRequestFromFrontToApi(request)
+    );
+    return FlowNetworkResponseFromApiToFront(response.data);
+  }
+  /**
+   * Fetch the current status snapshot of a flow network.
+   *
+   * @throws HTTP 404 if the id is unknown.
+   */
+  async get(networkId) {
+    const response = await this.api.getFlowNetwork(networkId);
+    return FlowNetworkResponseFromApiToFront(response.data);
+  }
+  /**
+   * Clone an existing flow network for what-if analysis.  The clone
+   * receives a new id and its own mutable graph; the original is
+   * unaffected.
+   *
+   * @throws HTTP 404 if the id is unknown.
+   */
+  async clone(networkId) {
+    const response = await this.api.cloneFlowNetwork(networkId);
+    return FlowNetworkResponseFromApiToFront(response.data);
+  }
+  /**
+   * Apply structural mutations to an existing network: replace
+   * capacities of labelled edges and/or append new edges.  Both
+   * fields on the request are optional; capacity updates apply
+   * before new edges are added.
+   *
+   * @throws HTTP 400 if a referenced label is unknown, an appended
+   *   edge references undeclared nodes, or capacities are negative.
+   * @throws HTTP 404 if the id is unknown.
+   */
+  async commit(networkId, request) {
+    const response = await this.api.commitFlowNetwork(
+      networkId,
+      CommitFlowNetworkRequestFromFrontToApi(request)
+    );
+    return FlowNetworkResponseFromApiToFront(response.data);
+  }
+  /**
+   * Run the chosen algorithm against the persisted network.
+   *
+   * @remarks
+   * The response shape narrows per algorithm:
+   *
+   * - `max_flow` — `totalFlow` + `edgeFlows`.
+   * - `min_cost_max_flow` — `totalFlow`, `totalCost`, `edgeFlows`.
+   * - `classify_edges` / `classify_edges_optimal` — `classifications`.
+   * - `min_cut` — `totalFlow`, `edgeFlows`, `minCut`.
+   *
+   * Fields irrelevant to the chosen algorithm are `undefined`.
+   *
+   * @throws HTTP 404 if the id is unknown.
+   */
+  async solve(networkId, request) {
+    const response = await this.api.solveFlowNetwork(
+      networkId,
+      SolveFlowNetworkRequestFromFrontToApi(request)
+    );
+    return SolveFlowNetworkResponseFromApiToFront(response.data);
+  }
+};
+
 // src/normalizers/osfql.ts
 function OsfqlResponseFromApiToFront(dto) {
   return {
@@ -22464,6 +22717,8 @@ var ReasoningLayerClient = class {
   optimize;
   /** Scheduling feasibility via capacitated bipartite b-matching (staff rostering, assignment problems). */
   scheduling;
+  /** Generic flow-network resource: max-flow, min-cost max-flow, edge classification, min-cut over a persisted graph. */
+  flowNetworks;
   /** OSFQL execution operations. */
   osfql;
   /** Conversational AI operations (NL → OSFQL with self-correction). */
@@ -22543,11 +22798,12 @@ var ReasoningLayerClient = class {
       rlTraining: this.rlTraining
     };
   }
-  /** Advanced reasoning operations — optimization, ILP, CDL, execution, preferences, discovery, scheduling. */
+  /** Advanced reasoning operations — optimization, ILP, CDL, execution, preferences, discovery, scheduling, flow networks. */
   get reasoningOps() {
     return this._reasoning ??= {
       optimize: this.optimize,
       scheduling: this.scheduling,
+      flowNetworks: this.flowNetworks,
       ilp: this.ilp,
       cdl: this.cdl,
       execution: this.execution,
@@ -22703,6 +22959,7 @@ var ReasoningLayerClient = class {
     this.rag = new RagClient(generatedRag);
     this.optimize = new OptimizeClient(generatedInference, generatedSorts, generatedQuery, generatedTerms, resolved.tenantId);
     this.scheduling = new SchedulingClient(new Scheduling(generatedHttp));
+    this.flowNetworks = new FlowNetworksClient(new FlowNetworks(generatedHttp));
     this.osfql = new OsfqlClient(generatedOsfql);
     this.conversation = new ConversationClient(generatedHttp);
     this.research = new ResearchClient(generatedHttp);
@@ -22856,6 +23113,9 @@ __export(scheduling_exports, {
 });
 var ANY_ROLE = "any";
 
+// src/types/flow-networks.ts
+var flow_networks_exports = {};
+
 // src/types/ilp.ts
 var ilp_exports = {};
 
@@ -23571,6 +23831,7 @@ exports.Conversation = conversation_exports;
 exports.Discovery = discovery_exports;
 exports.Execution = execution_exports;
 exports.Extract = extract_exports;
+exports.FlowNetworks = flow_networks_exports;
 exports.ForbiddenError = ForbiddenError;
 exports.Functions = functions_exports;
 exports.Fuzzy = fuzzy_exports;