fugacio-copilot 0.2.0__tar.gz → 0.3.0__tar.gz

{fugacio_copilot-0.2.0 → fugacio_copilot-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: fugacio-copilot
-Version: 0.2.0
+Version: 0.3.0
 Summary: Chemical-engineering design copilot/agent for the Fugacio stack.
 Author-email: Owen Carey <37121709+owenthcarey@users.noreply.github.com>
 License-Expression: Apache-2.0
@@ -10,7 +10,7 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Scientific/Engineering :: Chemistry
 Requires-Python: >=3.11
-Requires-Dist: fugacio-sim==0.2.0
+Requires-Dist: fugacio-sim==0.3.0
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.34; extra == 'anthropic'
 Provides-Extra: llm
@@ -33,17 +33,22 @@ registry**, deterministic, JSON-in/JSON-out functions exposed with the same
 function-calling schemas OpenAI/Anthropic expect:
 
 - **Properties & equilibrium**: `list_components`, `component_properties`,
-  `saturation_pressure`, `bubble_pressure`, `flash_drum`.
+  `saturation_pressure`, `bubble_pressure`, `flash_drum`. The flash, the
+  heater, the columns, and the exchanger accept a `method` (`pr`, `srk`, `nrtl`,
+  `unifac`, `pcsaft`, `iapws`, ...) that selects the property package.
 - **Molecular PC-SAFT**: `saft_flash`, `saft_density`, `saft_saturation_pressure`,
   `saft_bubble_pressure`, and `saft_residual_enthalpy`, the molecular EOS preferred
   for associating fluids (water, alcohols).
-- **Unit operations**: `heat_exchanger`, `compressor` (and turbine), `pump`,
-  `valve`, each closing a rigorous energy balance.
-- **Distillation**: `shortcut_distillation` (Fenske-Underwood-Gilliland) and
-  `rigorous_distillation` (multistage column with duties).
-- **Gradient-based optimization**: `optimize_flash_temperature` and
-  `optimize_column_reflux` solve for the operating variable that hits a target by
-  differentiating straight through the equilibrium flash and the column.
+- **Unit operations**: `heat_exchanger` (one-sided heater/cooler),
+  `two_sided_heat_exchanger` (hot and cold streams, rigorous T-Q curves, one
+  closing spec), `compressor` (and turbine), `pump`, `valve`, each closing a
+  rigorous energy balance.
+- **Distillation**: `shortcut_distillation` (Fenske-Underwood-Gilliland),
+  `rigorous_distillation` (simultaneous-correction MESH column with stage
+  energy balances, profiles, and duties), and `absorber`.
+- **Gradient-based optimization**: `optimize_flash_temperature` differentiates
+  straight through the equilibrium flash; `optimize_column_reflux` imposes the
+  purity as a specification of the MESH column and reports the reflux it takes.
 
 A model-agnostic **agent loop** (`run_agent`) drives plan→act→answer; the planner
 is injected, so the loop is fully testable with a scripted planner while a real

{fugacio_copilot-0.2.0 → fugacio_copilot-0.3.0}/README.md

@@ -11,17 +11,22 @@ registry**, deterministic, JSON-in/JSON-out functions exposed with the same
 function-calling schemas OpenAI/Anthropic expect:
 
 - **Properties & equilibrium**: `list_components`, `component_properties`,
-  `saturation_pressure`, `bubble_pressure`, `flash_drum`.
+  `saturation_pressure`, `bubble_pressure`, `flash_drum`. The flash, the
+  heater, the columns, and the exchanger accept a `method` (`pr`, `srk`, `nrtl`,
+  `unifac`, `pcsaft`, `iapws`, ...) that selects the property package.
 - **Molecular PC-SAFT**: `saft_flash`, `saft_density`, `saft_saturation_pressure`,
   `saft_bubble_pressure`, and `saft_residual_enthalpy`, the molecular EOS preferred
   for associating fluids (water, alcohols).
-- **Unit operations**: `heat_exchanger`, `compressor` (and turbine), `pump`,
-  `valve`, each closing a rigorous energy balance.
-- **Distillation**: `shortcut_distillation` (Fenske-Underwood-Gilliland) and
-  `rigorous_distillation` (multistage column with duties).
-- **Gradient-based optimization**: `optimize_flash_temperature` and
-  `optimize_column_reflux` solve for the operating variable that hits a target by
-  differentiating straight through the equilibrium flash and the column.
+- **Unit operations**: `heat_exchanger` (one-sided heater/cooler),
+  `two_sided_heat_exchanger` (hot and cold streams, rigorous T-Q curves, one
+  closing spec), `compressor` (and turbine), `pump`, `valve`, each closing a
+  rigorous energy balance.
+- **Distillation**: `shortcut_distillation` (Fenske-Underwood-Gilliland),
+  `rigorous_distillation` (simultaneous-correction MESH column with stage
+  energy balances, profiles, and duties), and `absorber`.
+- **Gradient-based optimization**: `optimize_flash_temperature` differentiates
+  straight through the equilibrium flash; `optimize_column_reflux` imposes the
+  purity as a specification of the MESH column and reports the reflux it takes.
 
 A model-agnostic **agent loop** (`run_agent`) drives plan→act→answer; the planner
 is injected, so the loop is fully testable with a scripted planner while a real

{fugacio_copilot-0.2.0 → fugacio_copilot-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fugacio-copilot"
-version = "0.2.0"
+version = "0.3.0"
 description = "Chemical-engineering design copilot/agent for the Fugacio stack."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -22,7 +22,7 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Chemistry",
 ]
 dependencies = [
-    "fugacio-sim==0.2.0",
+    "fugacio-sim==0.3.0",
 ]
 
 [project.optional-dependencies]

{fugacio_copilot-0.2.0 → fugacio_copilot-0.3.0}/src/fugacio/copilot/__init__.py

@@ -83,4 +83,4 @@ __all__ = [
     "tool_schemas",
 ]
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"

{fugacio_copilot-0.2.0 → fugacio_copilot-0.3.0}/src/fugacio/copilot/tools.py

@@ -26,8 +26,11 @@ from fugacio.copilot.integration_tools import integration_tool_specs
 from fugacio.copilot.mpc_tools import mpc_tool_specs
 from fugacio.copilot.saft_tools import saft_tool_specs
 from fugacio.sim import (
+    METHODS,
     STEAM_LEVELS,
+    ColumnFeed,
     Stream,
+    absorber,
     annualized_capital,
     azeotrope_pressure,
     azeotrope_temperature,
@@ -41,19 +44,21 @@ from fugacio.sim import (
     cylinder_volume,
     equilibrium_reactor,
     flash_drum,
+    heat_exchanger,
     heat_exchanger_area,
     heater,
     lmtd,
     npv,
     nrtl_model_for,
+    package_for,
     pfr,
     pump,
     pxy_diagram,
     reactive_flash,
     relative_volatility,
     residue_curve_map,
+    rigorous_column,
     shortcut_column,
-    solve_column,
     steam_heating,
     steam_turbine,
     stoichiometric_reactor,
@@ -66,6 +71,9 @@ from fugacio.sim import (
     valve,
     vapor_molar_volume_ideal,
 )
+from fugacio.sim import distillate_rate as _spec_distillate_rate
+from fugacio.sim import purity as _spec_purity
+from fugacio.sim import reflux_ratio as _spec_reflux_ratio
 from fugacio.thermo import (
     PR,
     PowerLaw,
@@ -209,15 +217,25 @@ def _bubble_pressure(components: list[str], x: list[float], temperature: float)
     }
 
 
+def _package(components: list[str], method: str | None) -> Any:
+    """Property package for ``method`` (``None`` keeps the Peng-Robinson default)."""
+    if method is None or method.lower() == "pr":
+        return None
+    if method.lower() not in METHODS:
+        raise ValueError(f"unknown thermodynamic method {method!r}; choose from {METHODS}")
+    return package_for(components, method.lower())
+
+
 def _flash(
     components: list[str],
     z: list[float],
     flow: float,
     temperature: float,
     pressure: float,
+    method: str | None = None,
 ) -> JsonDict:
     feed = Stream.from_fractions(tuple(components), jnp.asarray(z), flow, temperature, pressure)
-    vapor, liquid = flash_drum(feed, temperature, pressure)
+    vapor, liquid = flash_drum(feed, temperature, pressure, model=_package(components, method))
     return {
         "vapor_fraction": float(vapor.total / feed.total),
         "vapor": {"flow_mol_s": float(vapor.total), "composition": [float(v) for v in vapor.z]},
@@ -237,9 +255,10 @@ def _heat_exchanger(
     pressure: float,
     t_out: float | None = None,
     duty: float | None = None,
+    method: str | None = None,
 ) -> JsonDict:
     feed = _stream(components, z, flow, temperature, pressure)
-    res = heater(feed, t_out=t_out, duty=duty)
+    res = heater(feed, t_out=t_out, duty=duty, model=_package(components, method))
     return {
         "outlet_temperature_k": float(res.outlet.t),
         "duty_w": float(res.duty),
@@ -358,6 +377,15 @@ def _shortcut_distillation(
     }
 
 
+def _stream_dict(s: Stream) -> JsonDict:
+    return {
+        "flow_mol_s": float(s.total),
+        "composition": [float(v) for v in s.z],
+        "temperature_k": float(s.t),
+        "pressure_pa": float(s.p),
+    }
+
+
 def _rigorous_distillation(
     components: list[str],
     z: list[float],
@@ -368,11 +396,28 @@ def _rigorous_distillation(
     feed_stage: int,
     reflux: float,
     distillate_rate: float,
-    q: float = 1.0,
+    q: float | None = None,
+    condenser: str = "total",
+    efficiency: float = 1.0,
+    method: str | None = None,
 ) -> JsonDict:
+    del q  # the MESH model takes the feed state from its temperature and pressure
     feed = _stream(components, z, feed_flow, feed_temperature, pressure)
-    res = solve_column(feed, n_stages, feed_stage, reflux, distillate_rate, q=q)
+    res = rigorous_column(
+        [ColumnFeed(feed, feed_stage)],
+        n_stages,
+        p=pressure,
+        condenser=condenser,
+        specs=[_spec_reflux_ratio(reflux), _spec_distillate_rate(distillate_rate)],
+        efficiency=efficiency,
+        model=_package(components, method),
+    )
     return {
+        "converged": bool(res.residual_norm < 1e-6),
+        "residual_norm": float(res.residual_norm),
+        "stage_temperatures_k": [float(v) for v in res.t],
+        "liquid_flows_mol_s": [float(v) for v in res.liquid_flow],
+        "vapor_flows_mol_s": [float(v) for v in res.vapor_flow],
         "distillate": {
             "flow_mol_s": float(res.distillate.total),
             "composition": [float(v) for v in res.distillate.z],
@@ -390,6 +435,83 @@ def _rigorous_distillation(
     }
 
 
+def _two_sided_heat_exchanger(
+    hot_components: list[str],
+    hot_z: list[float],
+    hot_flow: float,
+    hot_temperature: float,
+    hot_pressure: float,
+    cold_components: list[str],
+    cold_z: list[float],
+    cold_flow: float,
+    cold_temperature: float,
+    cold_pressure: float,
+    duty: float | None = None,
+    t_hot_out: float | None = None,
+    t_cold_out: float | None = None,
+    min_approach: float | None = None,
+    ua: float | None = None,
+    zones: int = 4,
+    flow: str = "counter",
+    hot_method: str | None = None,
+    cold_method: str | None = None,
+) -> JsonDict:
+    hot = _stream(hot_components, hot_z, hot_flow, hot_temperature, hot_pressure)
+    cold = _stream(cold_components, cold_z, cold_flow, cold_temperature, cold_pressure)
+    res = heat_exchanger(
+        hot,
+        cold,
+        duty=duty,
+        t_hot_out=t_hot_out,
+        t_cold_out=t_cold_out,
+        min_approach=min_approach,
+        ua=ua,
+        zones=zones,
+        flow=flow,
+        model_hot=_package(hot_components, hot_method),
+        model_cold=_package(cold_components, cold_method),
+    )
+    return {
+        "duty_w": float(res.duty),
+        "ua_w_per_k": _finite(float(res.ua)),
+        "lmtd_k": _finite(float(res.lmtd)),
+        "approach_hot_end_k": float(res.approach_hot_end),
+        "approach_cold_end_k": float(res.approach_cold_end),
+        "min_approach_k": float(res.min_approach),
+        "hot_out": _stream_dict(res.hot_out),
+        "cold_out": _stream_dict(res.cold_out),
+        "hot_curve_k": [float(v) for v in res.hot_curve],
+        "cold_curve_k": [float(v) for v in res.cold_curve],
+    }
+
+
+def _absorber(
+    components: list[str],
+    gas_z: list[float],
+    gas_flow: float,
+    gas_temperature: float,
+    solvent_z: list[float],
+    solvent_flow: float,
+    solvent_temperature: float,
+    pressure: float,
+    n_stages: int,
+    method: str | None = None,
+) -> JsonDict:
+    gas = _stream(components, gas_z, gas_flow, gas_temperature, pressure)
+    solvent = _stream(components, solvent_z, solvent_flow, solvent_temperature, pressure)
+    res = absorber(gas, solvent, n_stages, p=pressure, model=_package(components, method))
+    absorbed = gas.n - res.distillate.n
+    return {
+        "converged": bool(res.residual_norm < 1e-6),
+        "treated_gas": _stream_dict(res.distillate),
+        "rich_solvent": _stream_dict(res.bottoms),
+        "fraction_absorbed": [
+            float(a / g) if float(g) > 0.0 else 0.0 for a, g in zip(absorbed, gas.n, strict=True)
+        ],
+        "stage_temperatures_k": [float(v) for v in res.t],
+    }
+
+
 def _safeguarded_newton(
     f: Callable[[float], Any], lo: float, hi: float, iters: int = 40, tol: float = 1e-7
 ) -> float:
@@ -450,22 +572,29 @@ def _optimize_column_reflux(
     distillate_rate: float,
     light_key: int,
     target_purity: float,
-    q: float = 1.0,
-    iters: int = 8,
+    q: float | None = None,
+    iters: int | None = None,
+    method: str | None = None,
 ) -> JsonDict:
+    del q, iters  # the purity is imposed directly as a MESH specification
     feed = _stream(components, z, feed_flow, feed_temperature, pressure)
-
-    def purity_of_reflux(reflux: float) -> Any:
-        res = solve_column(feed, n_stages, feed_stage, reflux, distillate_rate, q=q)
-        return res.distillate.z[light_key]
-
-    reflux_opt = _safeguarded_newton(
-        lambda r: purity_of_reflux(r) - target_purity, 0.2, 25.0, iters=iters
+    res = rigorous_column(
+        [ColumnFeed(feed, feed_stage)],
+        n_stages,
+        p=pressure,
+        specs=[
+            _spec_distillate_rate(distillate_rate),
+            _spec_purity("distillate", light_key, target_purity),
+        ],
+        model=_package(components, method),
     )
     return {
-        "reflux_ratio": reflux_opt,
-        "achieved_purity": float(purity_of_reflux(reflux_opt)),
+        "reflux_ratio": float(res.reflux_ratio),
+        "achieved_purity": float(res.distillate.z[light_key]),
         "target_purity": target_purity,
+        "converged": bool(res.residual_norm < 1e-6),
+        "condenser_duty_w": float(res.condenser_duty),
+        "reboiler_duty_w": float(res.reboiler_duty),
     }
 
 
@@ -1335,6 +1464,11 @@ def default_registry() -> dict[str, ToolSpec]:
                     "flow": {"type": "number", "description": "Total feed flow (mol/s)"},
                     "temperature": {"type": "number"},
                     "pressure": {"type": "number"},
+                    "method": {
+                        "type": "string",
+                        "enum": list(METHODS),
+                        "description": "Thermodynamic method (default pr)",
+                    },
                 },
                 "required": ["components", "z", "flow", "temperature", "pressure"],
             },
@@ -1356,11 +1490,63 @@ def default_registry() -> dict[str, ToolSpec]:
                     "pressure": {"type": "number"},
                     "t_out": {"type": "number", "description": "Target outlet temperature (K)"},
                     "duty": {"type": "number", "description": "Signed heat added (W)"},
+                    "method": {
+                        "type": "string",
+                        "enum": list(METHODS),
+                        "description": "Thermodynamic method (default pr)",
+                    },
                 },
                 "required": ["components", "z", "flow", "temperature", "pressure"],
             },
             run=_heat_exchanger,
         ),
+        ToolSpec(
+            name="two_sided_heat_exchanger",
+            description=(
+                "Countercurrent (or parallel) two-stream exchanger with rigorous enthalpy "
+                "curves on both sides. Give exactly one closing spec: duty (W), t_hot_out, "
+                "t_cold_out, min_approach (K), or ua (W/K). Returns duty, UA, LMTD, "
+                "approaches, both outlets, and the T-Q curves. Each side may use its own "
+                "method (e.g. iapws for steam, nrtl for aqueous)."
+            ),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "hot_components": {"type": "array", "items": {"type": "string"}},
+                    "hot_z": {"type": "array", "items": {"type": "number"}},
+                    "hot_flow": {"type": "number"},
+                    "hot_temperature": {"type": "number"},
+                    "hot_pressure": {"type": "number"},
+                    "cold_components": {"type": "array", "items": {"type": "string"}},
+                    "cold_z": {"type": "array", "items": {"type": "number"}},
+                    "cold_flow": {"type": "number"},
+                    "cold_temperature": {"type": "number"},
+                    "cold_pressure": {"type": "number"},
+                    "duty": {"type": "number"},
+                    "t_hot_out": {"type": "number"},
+                    "t_cold_out": {"type": "number"},
+                    "min_approach": {"type": "number"},
+                    "ua": {"type": "number"},
+                    "zones": {"type": "integer"},
+                    "flow": {"type": "string", "enum": ["counter", "parallel"]},
+                    "hot_method": {"type": "string", "enum": list(METHODS)},
+                    "cold_method": {"type": "string", "enum": list(METHODS)},
+                },
+                "required": [
+                    "hot_components",
+                    "hot_z",
+                    "hot_flow",
+                    "hot_temperature",
+                    "hot_pressure",
+                    "cold_components",
+                    "cold_z",
+                    "cold_flow",
+                    "cold_temperature",
+                    "cold_pressure",
+                ],
+            },
+            run=_two_sided_heat_exchanger,
+        ),
         ToolSpec(
             name="compressor",
             description=(
@@ -1457,8 +1643,9 @@ def default_registry() -> dict[str, ToolSpec]:
         ToolSpec(
             name="rigorous_distillation",
             description=(
-                "Rigorous multistage column (Wang-Henke, constant molar overflow) with EOS "
-                "K-values; returns product compositions, temperatures, and column duties."
+                "Rigorous multistage column: simultaneous-correction MESH (Naphtali-Sandholm) "
+                "with full stage energy balances and the chosen property package; returns "
+                "product streams, stage temperature and flow profiles, and column duties."
             ),
             parameters={
                 "type": "object",
@@ -1472,7 +1659,13 @@ def default_registry() -> dict[str, ToolSpec]:
                     "feed_stage": {"type": "integer"},
                     "reflux": {"type": "number"},
                     "distillate_rate": {"type": "number"},
-                    "q": {"type": "number"},
+                    "condenser": {"type": "string", "enum": ["total", "partial"]},
+                    "efficiency": {"type": "number", "description": "Murphree efficiency"},
+                    "method": {
+                        "type": "string",
+                        "enum": list(METHODS),
+                        "description": "Thermodynamic method (default pr)",
+                    },
                 },
                 "required": [
                     "components",
@@ -1488,6 +1681,45 @@ def default_registry() -> dict[str, ToolSpec]:
             },
             run=_rigorous_distillation,
         ),
+        ToolSpec(
+            name="absorber",
+            description=(
+                "Countercurrent absorber (no condenser or reboiler): gas enters the bottom "
+                "stage, lean solvent the top; returns treated gas, rich solvent, the "
+                "fraction of each component absorbed, and the stage temperatures."
+            ),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "components": {"type": "array", "items": {"type": "string"}},
+                    "gas_z": {"type": "array", "items": {"type": "number"}},
+                    "gas_flow": {"type": "number"},
+                    "gas_temperature": {"type": "number"},
+                    "solvent_z": {"type": "array", "items": {"type": "number"}},
+                    "solvent_flow": {"type": "number"},
+                    "solvent_temperature": {"type": "number"},
+                    "pressure": {"type": "number"},
+                    "n_stages": {"type": "integer"},
+                    "method": {
+                        "type": "string",
+                        "enum": list(METHODS),
+                        "description": "Thermodynamic method (default pr)",
+                    },
+                },
+                "required": [
+                    "components",
+                    "gas_z",
+                    "gas_flow",
+                    "gas_temperature",
+                    "solvent_z",
+                    "solvent_flow",
+                    "solvent_temperature",
+                    "pressure",
+                    "n_stages",
+                ],
+            },
+            run=_absorber,
+        ),
         ToolSpec(
             name="optimize_flash_temperature",
             description=(
@@ -1509,8 +1741,8 @@ def default_registry() -> dict[str, ToolSpec]:
         ToolSpec(
             name="optimize_column_reflux",
             description=(
-                "Gradient-based solve for the reflux ratio that achieves a target distillate "
-                "purity of the light key, differentiating through the rigorous column."
+                "Reflux ratio that achieves a target distillate purity of the light key, "
+                "imposed directly as a specification of the rigorous MESH column."
             ),
             parameters={
                 "type": "object",
@@ -1525,7 +1757,11 @@ def default_registry() -> dict[str, ToolSpec]:
                     "distillate_rate": {"type": "number"},
                     "light_key": {"type": "integer"},
                     "target_purity": {"type": "number"},
-                    "q": {"type": "number"},
+                    "method": {
+                        "type": "string",
+                        "enum": list(METHODS),
+                        "description": "Thermodynamic method (default pr)",
+                    },
                 },
                 "required": [
                     "components",

fugacio_copilot-0.3.0/tests/test_flowsheet_tools.py

@@ -0,0 +1,126 @@
+"""Copilot tools backed by the property packages, the MESH column, and the exchanger."""
+
+import pytest
+
+from fugacio.copilot import call_tool, tool_schemas
+
+
+def test_new_flowsheet_tools_are_registered() -> None:
+    names = {s["name"] for s in tool_schemas()}
+    assert names >= {"two_sided_heat_exchanger", "absorber"}
+    by_name = {s["name"]: s for s in tool_schemas()}
+    for tool in ("flash_drum", "heat_exchanger", "rigorous_distillation", "absorber"):
+        assert "method" in by_name[tool]["parameters"]["properties"]
+
+
+def test_flash_drum_accepts_a_method() -> None:
+    base = {
+        "components": ["ethanol", "water"],
+        "z": [0.3, 0.7],
+        "flow": 10.0,
+        "temperature": 360.0,
+        "pressure": 1.013e5,
+    }
+    ideal = call_tool("flash_drum", base)
+    nrtl = call_tool("flash_drum", {**base, "method": "nrtl"})
+    assert 0.0 < nrtl["vapor_fraction"] < 1.0
+    # NRTL knows about the ethanol/water non-ideality; PR alone gives a different split.
+    assert nrtl["vapor"]["composition"][0] != pytest.approx(
+        ideal["vapor"]["composition"][0], abs=1e-3
+    )
+    with pytest.raises(ValueError, match="unknown thermodynamic method"):
+        call_tool("flash_drum", {**base, "method": "voodoo"})
+
+
+def test_rigorous_distillation_reports_profiles_and_converges() -> None:
+    result = call_tool(
+        "rigorous_distillation",
+        {
+            "components": ["benzene", "toluene"],
+            "z": [0.5, 0.5],
+            "feed_flow": 100.0,
+            "feed_temperature": 365.0,
+            "pressure": 1.013e5,
+            "n_stages": 12,
+            "feed_stage": 6,
+            "reflux": 2.5,
+            "distillate_rate": 50.0,
+            "method": "srk",
+        },
+    )
+    assert result["converged"]
+    assert len(result["stage_temperatures_k"]) == 12
+    assert result["stage_temperatures_k"][0] < result["stage_temperatures_k"][-1]
+    assert result["distillate"]["composition"][0] > 0.95
+    assert result["bottoms"]["composition"][1] > 0.95
+    assert result["condenser_duty_w"] < 0.0 < result["reboiler_duty_w"]
+
+
+def test_optimize_column_reflux_imposes_purity_spec() -> None:
+    result = call_tool(
+        "optimize_column_reflux",
+        {
+            "components": ["propane", "n-butane"],
+            "z": [0.5, 0.5],
+            "feed_flow": 100.0,
+            "feed_temperature": 320.0,
+            "pressure": 10e5,
+            "n_stages": 8,
+            "feed_stage": 4,
+            "distillate_rate": 50.0,
+            "light_key": 0,
+            "target_purity": 0.9,
+        },
+    )
+    assert result["converged"]
+    assert result["achieved_purity"] == pytest.approx(0.9, abs=1e-6)
+    assert result["reflux_ratio"] > 0.0
+
+
+def test_two_sided_heat_exchanger_closes_energy_balance() -> None:
+    result = call_tool(
+        "two_sided_heat_exchanger",
+        {
+            "hot_components": ["n-hexane"],
+            "hot_z": [1.0],
+            "hot_flow": 20.0,
+            "hot_temperature": 380.0,
+            "hot_pressure": 5e5,
+            "cold_components": ["water"],
+            "cold_z": [1.0],
+            "cold_flow": 100.0,
+            "cold_temperature": 300.0,
+            "cold_pressure": 3e5,
+            "t_hot_out": 330.0,
+            "cold_method": "iapws",
+        },
+    )
+    assert result["duty_w"] > 0.0
+    assert result["hot_out"]["temperature_k"] == pytest.approx(330.0, abs=1e-6)
+    assert 300.0 < result["cold_out"]["temperature_k"] < 380.0
+    assert result["min_approach_k"] > 0.0
+    assert result["ua_w_per_k"] is not None and result["ua_w_per_k"] > 0.0
+    assert len(result["hot_curve_k"]) == len(result["cold_curve_k"])
+
+
+def test_absorber_tool_recovers_heavy_component() -> None:
+    result = call_tool(
+        "absorber",
+        {
+            "components": ["methane", "propane", "n-decane"],
+            "gas_z": [0.9, 0.1, 0.0],
+            "gas_flow": 100.0,
+            "gas_temperature": 300.0,
+            "solvent_z": [0.0, 0.0, 1.0],
+            "solvent_flow": 60.0,
+            "solvent_temperature": 300.0,
+            "pressure": 20e5,
+            "n_stages": 6,
+        },
+    )
+    assert result["converged"]
+    assert result["fraction_absorbed"][1] > 0.5  # propane captured
+    assert result["fraction_absorbed"][0] < 0.2  # methane mostly passes through
+    assert result["treated_gas"]["flow_mol_s"] + result["rich_solvent"][
+        "flow_mol_s"
+    ] == pytest.approx(160.0, rel=1e-6)