@kortexya/reasoninglayer 1.1.0 → 1.2.1

package/dist/index.d.cts

@@ -109,7 +109,7 @@ type JsonValue$1 = string | number | boolean | null | JsonValue$1[] | object;
  * This is the single source of truth for the version constant.
  * The `scripts/release.sh` script updates this value alongside `package.json`.
  */
-declare const SDK_VERSION = "1.1.0";
+declare const SDK_VERSION = "1.2.1";
 /**
  * Authentication mode for the SDK.
  *
@@ -1334,17 +1334,6 @@ interface BackwardChainRequest$1 {
      * Internally converted to Ψ-term constraints for TRUE HOMOICONICITY.
      */
     constraints?: ConstraintInputDto$1[];
-    /**
-     * When true, the response's `referenced_terms` field is populated
-     * with the full TermDto for every term transitively referenced by
-     * any solution's bindings. Lets the caller read complex bound
-     * values (lists of nested Ψ-terms etc.) in one request instead of
-     * chasing references via getTerm.
-     *
-     * Default: false (existing behaviour preserved).
-     * @default false
-     */
-    expand_bindings?: boolean;
     /**
      * The goal to prove (as a term).
      * Either `goal` or `goal_id` must be provided, but not both.
@@ -1411,17 +1400,6 @@ interface BackwardChainResponse$1 {
      * @min 0
      */
     query_time_ms: number;
-    /**
-     * Populated when the request had `expand_bindings: true`.
-     * Maps UUID-as-string → TermDto for every term transitively
-     * referenced by the solutions' bindings.  Capped at
-     * MAX_EXPAND_TERMS to prevent runaway responses.
-     *
-     * Keys are stringified UUIDs because JSON object keys must be
-     * strings; this also matches the existing `referenced_terms`
-     * shape on `TermDto` for consistency.
-     */
-    referenced_terms?: object | null;
     /** Solutions found */
     solutions: SolutionDto$1[];
 }
@@ -2647,6 +2625,19 @@ interface CollectionResponse {
     /** Collection DTO */
     collection: CollectionDto$1;
 }
+/**
+ * Request body for `POST /api/v1/flow-networks/{id}/commit` —
+ * structural mutations applied in a single atomic step.
+ */
+interface CommitFlowNetworkRequest$1 {
+    /**
+     * Edges to append.  Source/destination must reference declared
+     * nodes.
+     */
+    add_edges?: FlowEdgeDto[];
+    /** Capacity updates keyed by edge label. */
+    update_capacities?: EdgeCapacityUpdateDto[];
+}
 /** Request to commit to an alternative */
 interface CommitRequest$1 {
     /**
@@ -3518,6 +3509,22 @@ interface CreateExecutionSessionRequest$1 {
     /** @format uuid */
     tenant_id: string;
 }
+/** Request body for `POST /api/v1/flow-networks`. */
+interface CreateFlowNetworkRequest$1 {
+    /**
+     * Optional human-readable description.  Stored only as part of the
+     * response for inspection convenience.
+     */
+    description?: string | null;
+    /** Initial edges.  Order is preserved in inspection responses. */
+    edges: FlowEdgeDto[];
+    /** Node names.  Must be unique. */
+    nodes: string[];
+    /** Sink node name.  Must appear in `nodes`, distinct from `source`. */
+    sink: string;
+    /** Source node name.  Must appear in `nodes`. */
+    source: string;
+}
 /**
  * Request to create and persist a goal.
  *
@@ -5287,6 +5294,35 @@ interface E2ETrainingResponse$1 {
     /** Whether E2E training was triggered successfully. */
     triggered: boolean;
 }
+/** Replace the capacity of a labelled edge. */
+interface EdgeCapacityUpdateDto {
+    /**
+     * New capacity (must be ≥ 0).
+     * @format int64
+     */
+    capacity: number;
+    /** Edge label declared at construction or via a prior commit. */
+    label: string;
+}
+/** Flow snapshot for a single forward edge. */
+interface EdgeFlowDto {
+    /**
+     * Original capacity.
+     * @format int64
+     */
+    capacity: number;
+    /**
+     * Flow currently routed through this edge in the solver's output.
+     * @format int64
+     */
+    flow: number;
+    /** Source node name. */
+    from: string;
+    /** Caller-supplied label, if any. */
+    label?: string | null;
+    /** Destination node name. */
+    to: string;
+}
 /** Edge type in the graph */
 type EdgeTypeDto$1 = "subtype" | "multiple_inheritance" | "glb_path" | "lub_path" | "constraint_dependency" | "propagation" | "feature" | "coreference" | "trigger_dependency" | "relation_source" | "relation_target" | "identity" | "derivation" | {
     custom: string;
@@ -6739,6 +6775,63 @@ interface FixSuggestionDto$1 {
     /** Type of fix (e.g., "add_fact", "modify_feature", "narrow_sort", "add_rule") */
     fix_type?: string | null;
 }
+/** Strategy chosen at solve time. */
+type FlowAlgorithmDto = {
+    kind: "max_flow";
+} | {
+    kind: "min_cost_max_flow";
+} | {
+    kind: "classify_edges";
+} | {
+    kind: "classify_edges_optimal";
+} | {
+    kind: "min_cut";
+};
+/** A single directed edge specification. */
+interface FlowEdgeDto {
+    /**
+     * Capacity (must be ≥ 0).
+     * @format int64
+     */
+    capacity: number;
+    /**
+     * Optional per-unit-flow cost.  Defaults to zero — pure max-flow
+     * algorithms ignore this field.
+     * @format int64
+     */
+    cost?: number | null;
+    /** Source node name. */
+    from: string;
+    /**
+     * Optional caller-supplied label.  Must be unique.  Used to
+     * reference the edge in `commit` requests and to identify it in
+     * solver output.
+     */
+    label?: string | null;
+    /** Destination node name. */
+    to: string;
+}
+/** Status snapshot returned by every endpoint that does not solve. */
+interface FlowNetworkResponse$1 {
+    /** Optional description echoed from the create request. */
+    description?: string | null;
+    /**
+     * Number of declared forward edges.
+     * @min 0
+     */
+    edge_count: number;
+    /** Stable identifier assigned at creation; clones receive a new id. */
+    id: string;
+    /**
+     * Number of declared nodes.
+     * @min 0
+     */
+    node_count: number;
+    /** Sink node name. */
+    sink: string;
+    /** Source node name. */
+    source: string;
+}
 /** Request for forall */
 interface ForallRequest$1 {
     /** Generator goal that produces solutions */
@@ -11212,6 +11305,18 @@ interface MetaSortsResponse$1 {
      */
     variable: string;
 }
+/** Min-cut partition output. */
+interface MinCutDto {
+    /**
+     * Cut edges (saturated forward edges crossing source-side →
+     * sink-side).  Their summed `capacity` equals the max flow value.
+     */
+    cut_edges: EdgeFlowDto[];
+    /** Names of nodes on the sink side of the cut. */
+    sink_side: string[];
+    /** Names of nodes on the source side of the cut. */
+    source_side: string[];
+}
 /** Information about what's missing from a query */
 interface MissingInfoDto$1 {
     /** Human-readable description */
@@ -14991,6 +15096,35 @@ interface SolveConstraintResponse$1 {
     success: boolean;
     suspended_constraints: string[];
 }
+/** Request body for `POST /api/v1/flow-networks/{id}/solve`. */
+interface SolveFlowNetworkRequest$1 {
+    /** Algorithm to dispatch. */
+    algorithm: FlowAlgorithmDto;
+}
+/**
+ * Solver output.  Fields irrelevant to the chosen algorithm are
+ * omitted via `skip_serializing_if`.
+ */
+interface SolveFlowNetworkResponse$1 {
+    /** Echo of the algorithm dispatched. */
+    algorithm: FlowAlgorithmDto;
+    /** Per-edge classification (classify_* algorithms only). */
+    classifications?: any[] | null;
+    /** Per-edge flow snapshot. */
+    edge_flows: EdgeFlowDto[];
+    /** Min-cut partition (min_cut algorithm only). */
+    min_cut?: null | MinCutDto;
+    /**
+     * Total cost of the realised flow (mcmf only).
+     * @format int64
+     */
+    total_cost?: number | null;
+    /**
+     * Total flow source → sink (max-flow / mcmf / min-cut).
+     * @format int64
+     */
+    total_flow?: number | null;
+}
 /** Response with ancestor sorts */
 interface SortAncestorsResponse {
     ancestors: SortInfoDto$1[];
@@ -20980,16 +21114,6 @@ interface BackwardChainRequest {
     timeoutMs?: number | null;
     /** Additional constraints (deprecated — prefer ConstrainedVariable in goal). */
     constraints?: ConstraintInputDto[];
-    /**
-     * When true, the response's `referencedTerms` field is populated with the
-     * full {@link TermDto} for every term transitively referenced by any
-     * solution's bindings. Lets the caller read complex bound values
-     * (lists of nested Ψ-terms etc.) in one request instead of chasing
-     * references via {@link TermsResource.get}.
-     *
-     * @defaultValue `false`
-     */
-    expandBindings?: boolean;
 }
 /** Response from backward chaining inference. */
 interface BackwardChainResponse {
@@ -20999,13 +21123,6 @@ interface BackwardChainResponse {
     queryTimeMs: number;
     /** Goal ID if the goal was saved (when save_goal=true). */
     goalId?: string | null;
-    /**
-     * Populated when the request had `expandBindings: true`. Maps UUID →
-     * {@link TermDto} for every term transitively referenced by the solutions'
-     * bindings. Capped at the backend's MAX_EXPAND_TERMS to prevent runaway
-     * responses.
-     */
-    referencedTerms?: Record<string, TermDto>;
 }
 /**
  * Request for forward chaining inference.
@@ -21726,12 +21843,6 @@ declare class InferenceClient {
      *
      * 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.
      */
     backwardChain(request: Omit<BackwardChainRequest, 'goal'> & {
         goal?: TermInputArg | null;
@@ -40922,6 +41033,362 @@ declare class SchedulingClient {
     optimize(request: SchedulingOptimizeRequest): Promise<SchedulingOptimizeResponse>;
 }
 
+declare class FlowNetworks<SecurityDataType = unknown> {
+    http: HttpClient<SecurityDataType>;
+    constructor(http: HttpClient<SecurityDataType>);
+    /**
+     * 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: string, params?: RequestParams) => Promise<HttpResponse<FlowNetworkResponse$1, void>>;
+    /**
+     * 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: string, data: CommitFlowNetworkRequest$1, params?: RequestParams) => Promise<HttpResponse<FlowNetworkResponse$1, void>>;
+    /**
+     * No description
+     *
+     * @tags flow-networks
+     * @name CreateFlowNetwork
+     * @summary Create a new flow network.
+     * @request POST:/api/v1/flow-networks
+     * @secure
+     */
+    createFlowNetwork: (data: CreateFlowNetworkRequest$1, params?: RequestParams) => Promise<HttpResponse<FlowNetworkResponse$1, void>>;
+    /**
+     * 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: string, params?: RequestParams) => Promise<HttpResponse<FlowNetworkResponse$1, void>>;
+    /**
+     * 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: string, data: SolveFlowNetworkRequest$1, params?: RequestParams) => Promise<HttpResponse<SolveFlowNetworkResponse$1, void>>;
+}
+
+/**
+ * Strategy chosen at solve time.
+ *
+ * The flow network is algorithm-agnostic — the same persisted graph
+ * can be solved with different algorithms, and the response shape
+ * narrows the relevant fields per algorithm.
+ *
+ * - `"max_flow"` — Dinic's algorithm.  Returns `totalFlow` + per-edge flow.
+ * - `"min_cost_max_flow"` — Successive-shortest-path MCMF.  Returns
+ *   `totalFlow`, `totalCost`, per-edge flow.  Edges should carry `cost`.
+ * - `"classify_edges"` — Dulmage–Mendelsohn residual classification.
+ *   Returns per-edge `always_used` / `never_used` / `sometimes_used`.
+ * - `"classify_edges_optimal"` — As above, but only over **optimal**
+ *   (min-cost) max-flow solutions.
+ * - `"min_cut"` — Source-sink min cut.  Returns the cut partition and
+ *   the saturated cut edges.
+ */
+type FlowAlgorithm = {
+    kind: 'max_flow';
+} | {
+    kind: 'min_cost_max_flow';
+} | {
+    kind: 'classify_edges';
+} | {
+    kind: 'classify_edges_optimal';
+} | {
+    kind: 'min_cut';
+};
+/**
+ * A single directed edge in the flow network.
+ */
+interface EdgeSpec {
+    /** Source node name.  Must appear in the network's node list. */
+    from: string;
+    /** Destination node name.  Must appear in the network's node list. */
+    to: string;
+    /** Capacity (must be ≥ 0). */
+    capacity: number;
+    /**
+     * Optional per-unit-flow cost.  Defaults to zero — pure max-flow
+     * algorithms ignore this field.
+     */
+    cost?: number | null;
+    /**
+     * Optional caller-supplied label.  Must be unique across the
+     * network when present.  Used to reference the edge in commit
+     * requests and to identify it in solver output.
+     */
+    label?: string | null;
+}
+/**
+ * Input to {@link FlowNetworksClient.create}.
+ */
+interface CreateFlowNetworkRequest {
+    /** Node names.  Must be unique. */
+    nodes: string[];
+    /** Source node name.  Must appear in `nodes`. */
+    source: string;
+    /** Sink node name.  Must appear in `nodes`, distinct from `source`. */
+    sink: string;
+    /** Initial edges.  Order is preserved in inspection responses. */
+    edges: EdgeSpec[];
+    /**
+     * Optional human-readable description.  Stored only as part of the
+     * response for inspection convenience.
+     */
+    description?: string | null;
+}
+/**
+ * Status snapshot returned by every endpoint that does not solve
+ * (create, get, clone, commit).
+ */
+interface FlowNetworkResponse {
+    /** Stable identifier assigned at creation; clones receive a new id. */
+    id: string;
+    /** Source node name. */
+    source: string;
+    /** Sink node name. */
+    sink: string;
+    /** Number of declared nodes. */
+    nodeCount: number;
+    /** Number of declared forward edges. */
+    edgeCount: number;
+    /** Optional description echoed from the create request. */
+    description?: string | null;
+}
+/**
+ * Replace the capacity of a labelled edge.
+ */
+interface EdgeCapacityUpdate {
+    /** Edge label declared at construction or via a prior commit. */
+    label: string;
+    /** New capacity (must be ≥ 0). */
+    capacity: number;
+}
+/**
+ * Input to {@link FlowNetworksClient.commit}.
+ *
+ * @remarks
+ * Both fields are optional and may be supplied together.  Capacity
+ * updates apply before new edges are appended.
+ */
+interface CommitFlowNetworkRequest {
+    /** Capacity updates keyed by edge label. */
+    updateCapacities?: EdgeCapacityUpdate[];
+    /**
+     * Edges to append.  Source/destination must reference declared
+     * nodes.
+     */
+    addEdges?: EdgeSpec[];
+}
+/**
+ * Input to {@link FlowNetworksClient.solve}.
+ */
+interface SolveFlowNetworkRequest {
+    /** Algorithm to dispatch. */
+    algorithm: FlowAlgorithm;
+}
+/**
+ * Flow snapshot for a single forward edge.
+ */
+interface EdgeFlow {
+    /** Source node name. */
+    from: string;
+    /** Destination node name. */
+    to: string;
+    /** Caller-supplied label, if any. */
+    label?: string | null;
+    /** Original capacity. */
+    capacity: number;
+    /** Flow currently routed through this edge in the solver's output. */
+    flow: number;
+}
+/** Edge feasibility class. */
+type EdgeClass = 'always_used' | 'never_used' | 'sometimes_used';
+/**
+ * Per-edge classification produced by the `classify_edges` /
+ * `classify_edges_optimal` algorithms.
+ */
+interface EdgeClassification {
+    from: string;
+    to: string;
+    label?: string | null;
+    /** Class string: `"always_used"`, `"never_used"`, `"sometimes_used"`. */
+    class: EdgeClass;
+}
+/**
+ * Min-cut partition output (only populated when `algorithm.kind`
+ * is `"min_cut"`).
+ */
+interface MinCutReport {
+    /** Names of nodes on the source side of the cut. */
+    sourceSide: string[];
+    /** Names of nodes on the sink side of the cut. */
+    sinkSide: string[];
+    /**
+     * Cut edges (saturated forward edges crossing source-side →
+     * sink-side).  Their summed `capacity` equals the max flow value.
+     */
+    cutEdges: EdgeFlow[];
+}
+/**
+ * Solver output.  Fields irrelevant to the chosen algorithm are
+ * undefined (the backend omits them via `skip_serializing_if`).
+ */
+interface SolveFlowNetworkResponse {
+    /** Echo of the algorithm dispatched. */
+    algorithm: FlowAlgorithm;
+    /** Per-edge flow snapshot. */
+    edgeFlows: EdgeFlow[];
+    /** Total flow source → sink (max-flow / mcmf / min-cut). */
+    totalFlow?: number | null;
+    /** Total cost of the realised flow (mcmf only). */
+    totalCost?: number | null;
+    /** Per-edge classification (classify_* algorithms only). */
+    classifications?: EdgeClassification[] | null;
+    /** Min-cut partition (min_cut algorithm only). */
+    minCut?: MinCutReport | null;
+}
+
+type flowNetworks_CommitFlowNetworkRequest = CommitFlowNetworkRequest;
+type flowNetworks_CreateFlowNetworkRequest = CreateFlowNetworkRequest;
+type flowNetworks_EdgeCapacityUpdate = EdgeCapacityUpdate;
+type flowNetworks_EdgeClass = EdgeClass;
+type flowNetworks_EdgeClassification = EdgeClassification;
+type flowNetworks_EdgeFlow = EdgeFlow;
+type flowNetworks_EdgeSpec = EdgeSpec;
+type flowNetworks_FlowAlgorithm = FlowAlgorithm;
+type flowNetworks_FlowNetworkResponse = FlowNetworkResponse;
+type flowNetworks_MinCutReport = MinCutReport;
+type flowNetworks_SolveFlowNetworkRequest = SolveFlowNetworkRequest;
+type flowNetworks_SolveFlowNetworkResponse = SolveFlowNetworkResponse;
+declare namespace flowNetworks {
+  export type { flowNetworks_CommitFlowNetworkRequest as CommitFlowNetworkRequest, flowNetworks_CreateFlowNetworkRequest as CreateFlowNetworkRequest, flowNetworks_EdgeCapacityUpdate as EdgeCapacityUpdate, flowNetworks_EdgeClass as EdgeClass, flowNetworks_EdgeClassification as EdgeClassification, flowNetworks_EdgeFlow as EdgeFlow, flowNetworks_EdgeSpec as EdgeSpec, flowNetworks_FlowAlgorithm as FlowAlgorithm, flowNetworks_FlowNetworkResponse as FlowNetworkResponse, flowNetworks_MinCutReport as MinCutReport, flowNetworks_SolveFlowNetworkRequest as SolveFlowNetworkRequest, flowNetworks_SolveFlowNetworkResponse as SolveFlowNetworkResponse };
+}
+
+/**
+ * Resource client for the generic flow-network engine.
+ *
+ * @remarks
+ * The engine persists a directed capacitated graph under a stable id
+ * and dispatches a chosen algorithm (max-flow, min-cost max-flow,
+ * edge-classification, min-cut) over it.  Domain shapes (scheduling,
+ * transportation, …) become translators that build a
+ * {@link CreateFlowNetworkRequest}; the engine itself knows nothing
+ * about agents, days, or shifts.
+ *
+ * Lifecycle mirrors the `/spaces` resource: `create` → optional
+ * `clone` (for what-if branches) → optional `commit` (capacity tweaks
+ * / edge appends) → `solve`.
+ *
+ * @example Solve max-flow on a tiny network
+ * ```typescript
+ * const network = await client.flowNetworks.create({
+ *   nodes: ['s', 'a', 'b', 't'],
+ *   source: 's',
+ *   sink: 't',
+ *   edges: [
+ *     { from: 's', to: 'a', capacity: 3 },
+ *     { from: 's', to: 'b', capacity: 2 },
+ *     { from: 'a', to: 't', capacity: 2 },
+ *     { from: 'b', to: 't', capacity: 3 },
+ *   ],
+ * });
+ *
+ * const result = await client.flowNetworks.solve(network.id, {
+ *   algorithm: { kind: 'max_flow' },
+ * });
+ *
+ * console.log(result.totalFlow); // 4
+ * ```
+ *
+ * @example What-if branch via clone + commit
+ * ```typescript
+ * const branch = await client.flowNetworks.clone(network.id);
+ * await client.flowNetworks.commit(branch.id, {
+ *   updateCapacities: [{ label: 'edge-a-t', capacity: 5 }],
+ * });
+ * const result = await client.flowNetworks.solve(branch.id, {
+ *   algorithm: { kind: 'max_flow' },
+ * });
+ * ```
+ */
+declare class FlowNetworksClient {
+    /** @internal */
+    private readonly api;
+    /** @internal */
+    constructor(api: FlowNetworks);
+    /**
+     * 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).
+     */
+    create(request: CreateFlowNetworkRequest): Promise<FlowNetworkResponse>;
+    /**
+     * Fetch the current status snapshot of a flow network.
+     *
+     * @throws HTTP 404 if the id is unknown.
+     */
+    get(networkId: string): Promise<FlowNetworkResponse>;
+    /**
+     * 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.
+     */
+    clone(networkId: string): Promise<FlowNetworkResponse>;
+    /**
+     * 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.
+     */
+    commit(networkId: string, request: CommitFlowNetworkRequest): Promise<FlowNetworkResponse>;
+    /**
+     * 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.
+     */
+    solve(networkId: string, request: SolveFlowNetworkRequest): Promise<SolveFlowNetworkResponse>;
+}
+
 declare class Osfql<SecurityDataType = unknown> {
     http: HttpClient<SecurityDataType>;
     constructor(http: HttpClient<SecurityDataType>);
@@ -42952,10 +43419,11 @@ interface AiGroup {
     readonly context: ContextClient;
     readonly rlTraining: RlTrainingClient;
 }
-/** Advanced reasoning operations — optimization, ILP, CDL, execution, preferences, discovery, scheduling. */
+/** Advanced reasoning operations — optimization, ILP, CDL, execution, preferences, discovery, scheduling, flow networks. */
 interface ReasoningGroup {
     readonly optimize: OptimizeClient;
     readonly scheduling: SchedulingClient;
+    readonly flowNetworks: FlowNetworksClient;
     readonly ilp: IlpClient;
     readonly cdl: CdlClient;
     readonly execution: ExecutionClient;
@@ -43105,6 +43573,8 @@ declare class ReasoningLayerClient {
     readonly optimize: OptimizeClient;
     /** Scheduling feasibility via capacitated bipartite b-matching (staff rostering, assignment problems). */
     readonly scheduling: SchedulingClient;
+    /** Generic flow-network resource: max-flow, min-cost max-flow, edge classification, min-cut over a persisted graph. */
+    readonly flowNetworks: FlowNetworksClient;
     /** OSFQL execution operations. */
     readonly osfql: OsfqlClient;
     /** Conversational AI operations (NL → OSFQL with self-correction). */
@@ -43152,7 +43622,7 @@ declare class ReasoningLayerClient {
     get core(): CoreGroup;
     /** AI and machine learning operations — agents, oversight, neuro-symbolic, RAG, generation, context, RL training. */
     get ai(): AiGroup;
-    /** Advanced reasoning operations — optimization, ILP, CDL, execution, preferences, discovery, scheduling. */
+    /** Advanced reasoning operations — optimization, ILP, CDL, execution, preferences, discovery, scheduling, flow networks. */
     get reasoningOps(): ReasoningGroup;
     /** Analysis operations — causal, statistical, fuzzy, scenarios, communities, visualization. */
     get analysisOps(): AnalysisGroup;
@@ -44226,4 +44696,4 @@ declare function toUntaggedFeatures(features: PlainFeatureMap): Record<string, F
  */
 declare function toTermInputDto(input: PsiTermInput | TermInputDto): TermInputDto;
 
-export { ANY_ROLE, actionReviews as ActionReviews, type AddFactRequest, type AddFactResponse, type AddRuleRequest, type AddRuleResponse, admin as Admin, type AiGroup, analysis as Analysis, type AnalysisGroup, ApiError, type ApiResponse, type AuthConfig, AuthenticationError, type BackwardChainRequest, type BackwardChainResponse, BadRequestError, type BulkAddTermsRequest, type BulkAddTermsResponse, type BulkCreateSortsRequest, type BulkCreateSortsResponse, cdl as CDL, causal as Causal, type ClearTermsResponse, type ClientConfig, cognitive as Cognitive, collections as Collections, communities as Communities, compliance as Compliance, type ConstrainedPlainVar, ConstraintViolationError, constraints as Constraints, control as Control, conversation as Conversation, type ConversationMessageRequest, type ConversationMessageResponse, type ConversationSummaryDto, type ConversationTurnsResponse, type CoreGroup, type CreateResearchSessionRequest, type CreateResearchSessionResponse, type CreateSortRequest, type CreateTermRequest, type DataGroup, discovery as Discovery, type ErrorResponse$1 as ErrorResponse, execution as Execution, extract as Extract, type FeatureInputValueDto, type FeatureValueDto, ForbiddenError, type ForwardChainRequest, type ForwardChainResponse, functions as Functions, fuzzy as Fuzzy, FuzzyShape, type FuzzyShapeDto, generation as Generation, type GlbRequest, type GlbResponse, health as Health, homoiconic as Homoiconic, ilp as ILP, imageExtraction as ImageExtraction, inference as Inference, type IngestPaperRequest, type IngestPaperResponse, ingestion as Ingestion, IngestionFailedError, IngestionSession, type IngestionSyncOptions, type Interceptor, InternalServerError, type JsonValue$1 as JsonValue, LP, type ListConversationsResponse, type LubRequest, type LubResponse, namespaces as Namespaces, NetworkError, neuroSymbolic as NeuroSymbolic, NotFoundError, ontology as Ontology, operations as Operations, optimize as Optimize, type OsfSearchRequest, type OsfSearchResponse, osfql as Osfql, type OsfqlRequest, type OsfqlResponse, type OsfqlValue, oversight as Oversight, type PaginationParams, type PaperMetadataDto, type PaperSource, type PlainFeatureMap, type PlainFeatureValue, plainValues as PlainValues, preferences as Preferences, proofEngine as ProofEngine, type PsiTermDto, type PsiTermInput, query as Query, rag as RAG, RateLimitError, type RateLimitInfo, reasoning as Reasoning, type ReasoningGroup, ReasoningLayerClient, ReasoningLayerError, type RequestOptions, research as Research, type ResearchContradictionsResponse, type ResearchCycleResponse, type ResearchFindingsResponse, type ResearchGapsResponse, type ResearchReportResponse, type ResearchSessionResponse, reviews as Reviews, row as Row, SDK_VERSION, scenarios as Scenarios, scheduling as Scheduling, type SearchPapersRequest, type SearchPapersResponse, SortBuilder, type SortDto, type SortInfoDto, sorts as Sorts, sources as Sources, spaces as Spaces, statistical as Statistical, synthetic as Synthetic, type SystemGroup, type TermDto, type TermInputArg, type TermInputDto, type TermListResponse, type TermPatternDto, type TermResponse, terms as Terms, TimeoutError, type TurnDto, type UpdateTermRequest, utilities as Utilities, ValidationError, Value, type ValueDto, values as Values, type VerifyClaimRequest, type VerifyClaimResponse, visualization as Visualization, WebSocketClient, WebSocketConnection, webhookActions as WebhookActions, type WorkflowGroup, allen, constrained, discriminateFeatureValue, guard, isConstrainedPlainVar, isPsiTermInput, isTaggedValueDto, isUuid, psi, toTaggedFeatures, toTaggedValue, toTermInputDto, toUntaggedFeatures, toUntaggedValue };
+export { ANY_ROLE, actionReviews as ActionReviews, type AddFactRequest, type AddFactResponse, type AddRuleRequest, type AddRuleResponse, admin as Admin, type AiGroup, analysis as Analysis, type AnalysisGroup, ApiError, type ApiResponse, type AuthConfig, AuthenticationError, type BackwardChainRequest, type BackwardChainResponse, BadRequestError, type BulkAddTermsRequest, type BulkAddTermsResponse, type BulkCreateSortsRequest, type BulkCreateSortsResponse, cdl as CDL, causal as Causal, type ClearTermsResponse, type ClientConfig, cognitive as Cognitive, collections as Collections, communities as Communities, compliance as Compliance, type ConstrainedPlainVar, ConstraintViolationError, constraints as Constraints, control as Control, conversation as Conversation, type ConversationMessageRequest, type ConversationMessageResponse, type ConversationSummaryDto, type ConversationTurnsResponse, type CoreGroup, type CreateResearchSessionRequest, type CreateResearchSessionResponse, type CreateSortRequest, type CreateTermRequest, type DataGroup, discovery as Discovery, type ErrorResponse$1 as ErrorResponse, execution as Execution, extract as Extract, type FeatureInputValueDto, type FeatureValueDto, flowNetworks as FlowNetworks, ForbiddenError, type ForwardChainRequest, type ForwardChainResponse, functions as Functions, fuzzy as Fuzzy, FuzzyShape, type FuzzyShapeDto, generation as Generation, type GlbRequest, type GlbResponse, health as Health, homoiconic as Homoiconic, ilp as ILP, imageExtraction as ImageExtraction, inference as Inference, type IngestPaperRequest, type IngestPaperResponse, ingestion as Ingestion, IngestionFailedError, IngestionSession, type IngestionSyncOptions, type Interceptor, InternalServerError, type JsonValue$1 as JsonValue, LP, type ListConversationsResponse, type LubRequest, type LubResponse, namespaces as Namespaces, NetworkError, neuroSymbolic as NeuroSymbolic, NotFoundError, ontology as Ontology, operations as Operations, optimize as Optimize, type OsfSearchRequest, type OsfSearchResponse, osfql as Osfql, type OsfqlRequest, type OsfqlResponse, type OsfqlValue, oversight as Oversight, type PaginationParams, type PaperMetadataDto, type PaperSource, type PlainFeatureMap, type PlainFeatureValue, plainValues as PlainValues, preferences as Preferences, proofEngine as ProofEngine, type PsiTermDto, type PsiTermInput, query as Query, rag as RAG, RateLimitError, type RateLimitInfo, reasoning as Reasoning, type ReasoningGroup, ReasoningLayerClient, ReasoningLayerError, type RequestOptions, research as Research, type ResearchContradictionsResponse, type ResearchCycleResponse, type ResearchFindingsResponse, type ResearchGapsResponse, type ResearchReportResponse, type ResearchSessionResponse, reviews as Reviews, row as Row, SDK_VERSION, scenarios as Scenarios, scheduling as Scheduling, type SearchPapersRequest, type SearchPapersResponse, SortBuilder, type SortDto, type SortInfoDto, sorts as Sorts, sources as Sources, spaces as Spaces, statistical as Statistical, synthetic as Synthetic, type SystemGroup, type TermDto, type TermInputArg, type TermInputDto, type TermListResponse, type TermPatternDto, type TermResponse, terms as Terms, TimeoutError, type TurnDto, type UpdateTermRequest, utilities as Utilities, ValidationError, Value, type ValueDto, values as Values, type VerifyClaimRequest, type VerifyClaimResponse, visualization as Visualization, WebSocketClient, WebSocketConnection, webhookActions as WebhookActions, type WorkflowGroup, allen, constrained, discriminateFeatureValue, guard, isConstrainedPlainVar, isPsiTermInput, isTaggedValueDto, isUuid, psi, toTaggedFeatures, toTaggedValue, toTermInputDto, toUntaggedFeatures, toUntaggedValue };