fixtureqa 0.16.0__tar.gz → 0.17.0__tar.gz

{fixtureqa-0.16.0/fixtureqa.egg-info → fixtureqa-0.17.0}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: fixtureqa
-Version: 0.16.0
+Version: 0.17.0
 Summary: FIXture — FIX Protocol Testing Tool
 Requires-Python: >=3.10
 License-File: LICENSE
-Requires-Dist: fixcore-engine==0.11.0
+Requires-Dist: fixcore-engine==0.11.1
 Requires-Dist: fastapi>=0.111.0
 Requires-Dist: uvicorn[standard]>=0.29.0
 Requires-Dist: websockets>=12.0

{fixtureqa-0.16.0 → fixtureqa-0.17.0}/README.md

@@ -1,6 +1,6 @@
 # FIXture
 
-A Python FIX protocol testing tool. Supports FIX 4.2 and 4.4, dynamic session creation at runtime (no restart required), and both initiator and acceptor roles per session.
+A Python FIX protocol testing tool. Supports FIX 4.0–4.4 and FIX 5.0 (over FIXT.1.1), dynamic session creation at runtime (no restart required), and both initiator and acceptor roles per session.
 
 ![FIXture](frontend/src/assets/logo-dark.svg)
 
@@ -8,16 +8,19 @@ A Python FIX protocol testing tool. Supports FIX 4.2 and 4.4, dynamic session cr
 
 ## Features
 
-- **FIX 4.2 and 4.4** support with bundled data dictionaries
-- **Initiator and acceptor** roles, configurable per session
+- **FIX 4.0–4.4 and FIX 5.0** — every classic version plus FIX 5.0/SP1/SP2 over FIXT.1.1 (transport + application dictionary, ApplVerID on the Logon), with bundled data dictionaries
+- **Custom data dictionaries** — upload per-user spec XMLs and pick them per session; built-in spec browser for every bundled/uploaded dictionary (messages, fields, enums, repeating groups)
+- **Initiator and acceptor** roles, configurable per session, with the full engine config surface (schedules, timers, resend/validation behaviour) in the session form
 - **Dynamic sessions** — add or remove sessions without restarting
-- **Multi-user auth** — JWT login, per-user session isolation, admin panel
-- **Message log** — real-time IN/OUT stream with field breakdown, filtering, cursor pagination
-- **Compose & send** — paste raw FIX or use message templates; auto-inject tag 60 and primary ID
+- **Multi-user auth** — JWT login and admin panel; sessions are visible and sendable to every user, control (start/stop/edit/delete) stays with the owner or an admin, and each sent message is attributed to the user who sent it
+- **Message log** — real-time IN/OUT stream with field breakdown, filtering, cursor pagination, and full-history search (substring or regex)
+- **Compose & send** — paste raw FIX or use message templates; one message per line sends a batch in order; auto-inject tag 60 and primary ID; value generators (`uuid()`, `ORD-{seq(8)}`, …)
+- **Algo orders (FIXatdl)** — upload a broker's ATDL file and build orders from a generated form: typed parameters, conditional enable/hide and cross-field validation (StateRules/StrategyEdits), the strategy identifier stamped automatically; validate-without-saving for authoring your own files
 - **Templates** — create/edit reusable message templates with FIX spec field definitions
+- **Custom tags** — per-user tag definitions (name, type, enum labels) that decode in the message log; ATDL parameters can register themselves automatically
 - **Scenarios** — automated send/expect/delay test scripts with live pass/fail results; repeatable steps/scenarios, value generators (`uuid()`, `ORD-{seq(8)}`, …) in send values, `{recv:<tag>}` to echo an order's tags into the ack/fill that answers it, and cross-session **suites** that coordinate through real FIX traffic (e.g. a client scenario and a venue scenario run together)
 - **Venue simulation** — auto-ack and auto-fill responses for inbound NewOrderSingles
-- **Performance testing** — rate-controlled order injection with latency correlation (p50/p95/p99), live dashboard, run history and CSV export; order/exec shapes templatable per counterparty; amend (35=G) and cancel (35=F) flavours with their own reply latencies (see [PERF.md](PERF.md))
+- **Performance testing** — rate-controlled order injection with latency correlation (p50/p95/p99), live dashboard, run history and CSV export; order/exec shapes templatable per counterparty; amend (35=G) and cancel (35=F) flavours with their own reply latencies; a 4-session relay topology (`client → relay → venue`) that measures per-hop pass-through latency (see [PERF.md](PERF.md))
 - **Log analysis** — Overview stats, Throughput chart, Reject detail, Latency measurement (p50/p95/p99)
 - **Export** — download session messages as CSV or raw FIX
 - **Sequence numbers** — view and reset TX/RX seqnums per session

{fixtureqa-0.16.0 → fixtureqa-0.17.0}/fixture/api/app.py

@@ -54,10 +54,10 @@ async def lifespan(app: FastAPI):
         await app.state.perf_registry.shutdown()
     except Exception:
         pass
-    # Force-stop all running sessions so their asyncio tasks can be cancelled cleanly
+    # Stop all running sessions so their asyncio tasks can be cancelled cleanly
     for sid in list(sm._sessions.keys()):
         try:
-            await sm.stop_session(sid, force=True)
+            await sm.stop_session(sid)
         except Exception:
             pass
     sm.close()  # flush SQLite writer

{fixtureqa-0.16.0 → fixtureqa-0.17.0}/fixture/api/routers/atdl.py

@@ -55,6 +55,8 @@ def _strategy_dict(s) -> dict:
                 "type": p.type,
                 "kind": p.kind,
                 "required": p.required,
+                "true_wire_value": p.true_wire_value,
+                "false_wire_value": p.false_wire_value,
                 "enums": [{"enum_id": e.enum_id, "wire_value": e.wire_value}
                           for e in p.enums],
             }

{fixtureqa-0.16.0 → fixtureqa-0.17.0}/fixture/api/routers/sessions.py

@@ -1,5 +1,5 @@
 from typing import Annotated, Optional
-from fastapi import APIRouter, Depends, HTTPException, Query
+from fastapi import APIRouter, Depends, HTTPException
 
 from ...core.message_store import MessageStore
 from ...core.session_manager import SessionManager
@@ -56,6 +56,8 @@ def _config_from_request(body: SessionConfigRequest, owner_uid: str) -> SessionC
 
 def _session_response(sm: SessionManager, session_id: str, us: Optional[UserStore] = None,
                       counts: Optional[dict] = None) -> SessionResponse:
+    """Sessions are visible to all users, so every response carries
+    owner_username (resolved via `us`) for the UI owner badge / "Mine" filter."""
     cfg = sm.get_config(session_id)
     if cfg is None:
         raise HTTPException(status_code=404, detail="Session not found")
@@ -126,19 +128,11 @@ def _session_response(sm: SessionManager, session_id: str, us: Optional[UserStor
     )
 
 
-def _owner_store(us: UserStore, user: User) -> Optional[UserStore]:
-    """Every response carries owner_username: sessions are visible to all users,
-    so the UI owner badge / "Mine" filter needs the owner on every session,
-    not just for admins."""
-    return us
-
-
 @router.get("/", response_model=list[SessionResponse])
 def list_sessions(sm: SM, us: US, user: CurrentUser):
     configs = sm.list_sessions_for_user(user.uid, is_admin=user.is_admin)
-    user_store = _owner_store(us, user)
     counts = sm.message_counts()
-    return [_session_response(sm, cfg.session_id, user_store, counts) for cfg in configs]
+    return [_session_response(sm, cfg.session_id, us, counts) for cfg in configs]
 
 
 @router.post("/", response_model=SessionResponse, status_code=201)
@@ -168,7 +162,7 @@ async def create_session(body: SessionConfigRequest, sm: SM, us: US, ss: SS, use
                 pass  # best-effort rollback; surface the original start failure
             raise HTTPException(status_code=500, detail=f"Failed to start session: {e}")
 
-    return _session_response(sm, session_id, _owner_store(us, user))
+    return _session_response(sm, session_id, us)
 
 
 @router.post("/import", response_model=list[SessionResponse], status_code=201)
@@ -188,13 +182,13 @@ def import_sessions(body: list[SessionConfigRequest], sm: SM, us: US, ss: SS, us
             session_id = sm.add_session(cfg)
         except (HTTPException, ValueError, KeyError):
             continue  # invalid / conflicting entry — skip just this one
-        created.append(_session_response(sm, session_id, _owner_store(us, user)))
+        created.append(_session_response(sm, session_id, us))
     return created
 
 
 @router.get("/{session_id}", response_model=SessionResponse)
 def get_session(session_id: str, _cfg: ViewableSession, sm: SM, us: US, user: CurrentUser):
-    return _session_response(sm, session_id, _owner_store(us, user))
+    return _session_response(sm, session_id, us)
 
 
 @router.patch("/{session_id}", response_model=SessionResponse)
@@ -209,7 +203,7 @@ def update_session(session_id: str, body: UpdateSessionRequest, _cfg: OwnedSessi
         raise HTTPException(status_code=409, detail=str(e))
     except (ValueError, KeyError) as e:
         raise HTTPException(status_code=422, detail=str(e))
-    return _session_response(sm, session_id, _owner_store(us, user))
+    return _session_response(sm, session_id, us)
 
 
 @router.delete("/{session_id}", status_code=204)
@@ -226,20 +220,13 @@ async def start_session(session_id: str, _cfg: OwnedSession, sm: SM, us: US, use
         await sm.start_session(session_id)
     except RuntimeError as e:
         raise HTTPException(status_code=409, detail=str(e))
-    return _session_response(sm, session_id, _owner_store(us, user))
+    return _session_response(sm, session_id, us)
 
 
 @router.post("/{session_id}/stop", response_model=SessionResponse)
-async def stop_session(
-    session_id: str,
-    _cfg: OwnedSession,
-    sm: SM,
-    us: US,
-    user: CurrentUser,
-    force: bool = Query(default=False),
-):
-    await sm.stop_session(session_id, force=force)
-    return _session_response(sm, session_id, _owner_store(us, user))
+async def stop_session(session_id: str, _cfg: OwnedSession, sm: SM, us: US, user: CurrentUser):
+    await sm.stop_session(session_id)
+    return _session_response(sm, session_id, us)
 
 
 @router.post("/{session_id}/send")
@@ -258,7 +245,13 @@ async def send_message(session_id: str, body: SendMessageRequest, _cfg: Viewable
     except ValueError as e:
         raise HTTPException(status_code=422, detail=str(e))
 
-    ok = await sm.send_message(session_id, msg, user_id=user.uid)
+    from ...core.session_manager import SendError
+    try:
+        ok = await sm.send_message(session_id, msg, user_id=user.uid)
+    except SendError as e:
+        # A real send failure on a logged-on session — report the engine's
+        # error instead of the misleading "not logged on".
+        raise HTTPException(status_code=500, detail=f"Send failed: {e}")
     if not ok:
         raise HTTPException(status_code=409, detail="Session not logged on")
     return {"ok": True}

{fixtureqa-0.16.0 → fixtureqa-0.17.0}/fixture/core/atdl_parser.py

@@ -16,7 +16,10 @@ itself is walked only to map a ``<Control parameterRef=...>`` to the parameter a
 Edit/StrategyEdit/StateRule semantics (FIXatdl 1.1 spec):
   * ``Edit`` is a boolean expression: either an ``operator`` (EX/NX/EQ/NE/LE/LT/
     GE/GT over ``field`` vs ``value`` or ``field2``) **or** a ``logicOperator``
-    (AND/OR/XOR/NOT over child Edits) — never both.
+    (AND/OR/XOR/NOT over child Edits) — never both. ``field``/``field2`` name a
+    strategy parameter, or a *standard FIX field* with the ``FIX_`` prefix
+    (e.g. ``FIX_OrderQty``) — the latter resolve against the order ticket, not
+    the parameter list.
   * ``StrategyEdit`` is an *assertion*: the order is valid when its Edit is TRUE,
     and ``errorMessage`` is shown when it is FALSE.
   * ``StateRule`` action is *in-effect when its Edit is TRUE*: ``enabled="false"``
@@ -83,6 +86,10 @@ class Parameter:
     type: str                             # raw ATDL type, e.g. "Price_t"
     kind: str                             # form kind: int|float|bool|string|…
     required: bool
+    # Boolean_t wire encoding (ATDL trueWireValue/falseWireValue, default Y/N);
+    # Edits/StateRules still speak "true"/"false". "" for non-boolean params.
+    true_wire_value: str = ""
+    false_wire_value: str = ""
     enums: list[EnumPair] = _dcfield(default_factory=list)
 
 
@@ -95,7 +102,7 @@ class Edit:
     (``logic`` + ``children``), or an *EditRef* leaf (``ref`` = a named Edit id).
     """
     operator: str = ""      # EX/NX/EQ/NE/LE/LT/GE/GT ('' unless a comparison)
-    field: str = ""         # parameter *name* being tested
+    field: str = ""         # parameter *name* (or FIX_-prefixed standard field)
     field2: str = ""        # compare against another field's value
     value: str = ""         # …or against this literal
     has_value: bool = False # value="" (present) vs value absent
@@ -334,6 +341,8 @@ def atdl_warnings(atdl: AtdlFile) -> list[str]:
                 w.append(f"EditRef '{ref}' in '{s.name}' does not resolve to a "
                          "named <Edit id=...>.")
         for fld in sorted(fields):
+            if fld.startswith("FIX_"):
+                continue  # standard FIX field ref, resolved against the order ticket
             if fld not in names:
                 w.append(f"An Edit in '{s.name}' references unknown field '{fld}'.")
         for sr in s.state_rules:
@@ -345,13 +354,16 @@ def atdl_warnings(atdl: AtdlFile) -> list[str]:
 
 def _parse_parameter(el) -> Parameter:
     atdl_type = _xsi_type(el)
+    kind = _TYPE_KIND.get(atdl_type, "string")
     return Parameter(
         name=el.get("name", ""),
         fix_tag=_int_attr(el, "fixTag", 0),
         type=atdl_type,
-        kind=_TYPE_KIND.get(atdl_type, "string"),
+        kind=kind,
         # ATDL `use` is "optional"/"required"; absent → optional.
         required=(el.get("use", "optional").lower() == "required"),
+        true_wire_value=(el.get("trueWireValue", "Y") if kind == "bool" else ""),
+        false_wire_value=(el.get("falseWireValue", "N") if kind == "bool" else ""),
         enums=[
             EnumPair(enum_id=ep.get("enumID", ""), wire_value=ep.get("wireValue", ""))
             for ep in _find_local(el, "EnumPair")

{fixtureqa-0.16.0 → fixtureqa-0.17.0}/fixture/core/atdl_store.py

@@ -32,6 +32,10 @@ class AtdlStore:
     def __init__(self, data_dir: str):
         self._data_dir = data_dir
         self._lock = threading.RLock()
+        # path -> (mtime, strategy_count): list() used to re-parse every file
+        # on every call just to display its count; parse once per on-disk
+        # version instead (mtime change = new upload replaced the file).
+        self._counts: dict[str, tuple[float, int]] = {}
 
     # --- paths ---
     def _dir(self, uid: str) -> str:
@@ -62,10 +66,36 @@ class AtdlStore:
             parsed = parse_atdl(xml_text)
         except AtdlParseError as e:
             raise AtdlValidationError(str(e)) from e
+        path = self._path(uid, name)
         with self._lock:
-            atomic_write_text(self._path(uid, name), xml_text)
+            atomic_write_text(path, xml_text)
+            try:
+                self._counts[path] = (os.path.getmtime(path), len(parsed.strategies))
+            except OSError:
+                pass
         return {"name": name, "strategy_count": len(parsed.strategies),
-                "value": self._path(uid, name)}
+                "value": path}
+
+    def _strategy_count(self, path: str) -> int:
+        """Strategy count for a stored file, parsed at most once per on-disk
+        version. 0 for a file that vanished or no longer parses."""
+        try:
+            mtime = os.path.getmtime(path)
+        except OSError:
+            return 0
+        with self._lock:
+            hit = self._counts.get(path)
+            if hit is not None and hit[0] == mtime:
+                return hit[1]
+        count = 0
+        try:
+            with open(path) as f:
+                count = len(parse_atdl(f.read()).strategies)
+        except (OSError, AtdlParseError):
+            pass
+        with self._lock:
+            self._counts[path] = (mtime, count)
+        return count
 
     def list(self, uid: str) -> list[dict]:
         """This user's uploaded ATDL files (name + strategy count)."""
@@ -75,14 +105,9 @@ class AtdlStore:
             for fn in sorted(os.listdir(d)):
                 if not fn.lower().endswith(".xml"):
                     continue
-                count = 0
-                try:
-                    with open(self._path(uid, fn)) as f:
-                        count = len(parse_atdl(f.read()).strategies)
-                except (OSError, AtdlParseError):
-                    pass
-                out.append({"name": fn, "strategy_count": count,
-                            "value": self._path(uid, fn)})
+                path = self._path(uid, fn)
+                out.append({"name": fn, "strategy_count": self._strategy_count(path),
+                            "value": path})
         return out
 
     def get_parsed(self, uid: str, name: str) -> AtdlFile:
@@ -98,6 +123,7 @@ class AtdlStore:
         name = self._sanitize(name)
         with self._lock:
             path = self._path(uid, name)
+            self._counts.pop(path, None)
             if not os.path.isfile(path):
                 return False
             os.remove(path)

{fixtureqa-0.16.0 → fixtureqa-0.17.0}/fixture/core/fix_application.py

@@ -1,4 +1,4 @@
-import asyncio
+import logging
 import time
 
 from fixcore.application import Application
@@ -7,6 +7,8 @@ from fixcore.session.session_id import SessionID
 
 from .events import EventHandler, EventType, SessionEvent
 
+logger = logging.getLogger(__name__)
+
 
 def _flatten_groups(groups: dict, into: dict) -> None:
     """Merge repeating-group member fields into a flat {tag: value} dict.
@@ -73,24 +75,18 @@ class FixApplication(Application):
         self._emit(EventType.SESSION_STATUS_CHANGED, {"status": "LOGGED_OUT"})
 
     def to_admin(self, message: Message, session_id: SessionID) -> None:
-        self._emit(EventType.MESSAGE_SENT, self._payload(message, admin=True))
+        self._emit_message(EventType.MESSAGE_SENT, message, admin=True)
 
     def to_app(self, message: Message, session_id: SessionID) -> None:
-        try:
-            self._emit(EventType.MESSAGE_SENT, self._payload(message, admin=False))
-        except Exception:
-            pass
+        self._emit_message(EventType.MESSAGE_SENT, message, admin=False)
 
     def from_admin(self, message: Message, session_id: SessionID) -> None:
-        recv_perf_ns = time.perf_counter_ns()
-        self._emit(EventType.MESSAGE_RECEIVED, self._payload(message, admin=True, recv_perf_ns=recv_perf_ns))
+        self._emit_message(EventType.MESSAGE_RECEIVED, message, admin=True,
+                           recv_perf_ns=time.perf_counter_ns())
 
     def from_app(self, message: Message, session_id: SessionID) -> None:
-        recv_perf_ns = time.perf_counter_ns()
-        try:
-            self._emit(EventType.MESSAGE_RECEIVED, self._payload(message, admin=False, recv_perf_ns=recv_perf_ns))
-        except Exception:
-            pass
+        self._emit_message(EventType.MESSAGE_RECEIVED, message, admin=False,
+                           recv_perf_ns=time.perf_counter_ns())
 
     # ------------------------------------------------------------------
     # Internal
@@ -108,6 +104,22 @@ class FixApplication(Application):
             payload["recv_perf_ns"] = recv_perf_ns
         return payload
 
+    def _emit_message(self, event_type: EventType, message: Message, *,
+                      admin: bool, recv_perf_ns: int | None = None) -> None:
+        """Build the payload and emit. An Application callback must never raise
+        into the engine (it would tear down the fixcore session task), so
+        payload building — which walks Message internals — is guarded here for
+        all four to_*/from_* callbacks. Previously only the app-level pair was
+        wrapped; an admin message whose payload failed to build raised into
+        fixcore."""
+        try:
+            payload = self._payload(message, admin=admin, recv_perf_ns=recv_perf_ns)
+        except Exception:
+            logger.exception("[%s] dropped a message event: payload build failed",
+                             self._session_id)
+            return
+        self._emit(event_type, payload)
+
     def _emit(self, event_type: EventType, payload: dict) -> None:
         try:
             self._event_handler(SessionEvent(
@@ -116,4 +128,7 @@ class FixApplication(Application):
                 payload=payload,
             ))
         except Exception:
-            pass
+            # Swallow (never raise into the engine) but don't hide it — a
+            # failing handler chain means events are being lost.
+            logger.exception("[%s] event handler failed for %s",
+                             self._session_id, event_type.name)

{fixtureqa-0.16.0 → fixtureqa-0.17.0}/fixture/core/perf_engine.py

@@ -41,7 +41,7 @@ from .perf_models import (
 from .perf_payload import PayloadFactory, ScenarioSelector
 from .perf_stats import BurstGate, PerfStats, TokenBucket
 from .perf_writer import PerfWriter
-from .session_manager import SessionManager
+from .session_manager import SendError, SessionManager
 
 logger = logging.getLogger(__name__)
 
@@ -525,7 +525,13 @@ class PerfRun:
     async def _send(self, session_id: str, msg: Message) -> bool:
         """Single send path — tallies every outbound app message per leg
         (type-agnostic) for the messages-per-second chart, then delegates."""
-        ok = await self._sm.send_message(session_id, msg)
+        try:
+            ok = await self._sm.send_message(session_id, msg)
+        except SendError:
+            # Counted like a not-logged-on refusal (rejected/failed) rather
+            # than crashing the injector/venue task mid-run; the underlying
+            # error is already logged by the session.
+            ok = False
         if ok:
             if session_id == self.config.client_session_id:
                 self.stats.msgs_sent_client += 1

{fixtureqa-0.16.0 → fixtureqa-0.17.0}/fixture/core/scenario_runner.py

@@ -20,7 +20,7 @@ from fixcore.message.message import Message
 from .events import SessionEvent, EventType
 from .fix_builder import _ordered_pairs
 from .fix_time import utc_timestamp
-from .session_manager import SessionManager
+from .session_manager import SendError, SessionManager
 from .template_store import TemplateStore
 from . import value_gen
 
@@ -519,9 +519,12 @@ class ScenarioRunner:
         loop = self._loop
         if loop is None:
             return "Scenario runner not bound to an event loop"
-        ok = asyncio.run_coroutine_threadsafe(
-            self._sm.send_message(session_id, msg), loop
-        ).result(timeout=5)
+        try:
+            ok = asyncio.run_coroutine_threadsafe(
+                self._sm.send_message(session_id, msg), loop
+            ).result(timeout=5)
+        except SendError as e:
+            return f"Send failed: {e}"
         if not ok:
             return "Session not logged on"
         return None

{fixtureqa-0.16.0 → fixtureqa-0.17.0}/fixture/core/session.py

@@ -32,6 +32,13 @@ _sending_user: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar(
 logger = logging.getLogger(__name__)
 
 
+class SendError(RuntimeError):
+    """An application-level send failed for a reason other than "not logged
+    on" (encode error, transport blow-up). Distinct so callers can report the
+    real cause — these used to be swallowed into a False return, which the API
+    then misreported as "Session not logged on". Import via session_manager."""
+
+
 class _NullLog:
     """fixcore Log that drops everything — for perf sessions (no wire logging)."""
 
@@ -177,7 +184,7 @@ class Session:
         self._app = None
         self._fixcore_session_id = None
 
-    async def stop(self, force: bool = False) -> None:
+    async def stop(self) -> None:
         for task in list(self._venue_tasks):
             task.cancel()
         if self._transport is not None:
@@ -203,7 +210,11 @@ class Session:
         ))
 
     async def send_message(self, message: Message, user_id: Optional[str] = None) -> bool:
-        """Send an application-level FIX message. Returns False if not logged on.
+        """Send an application-level FIX message.
+
+        Returns False when the session is not logged on (the normal, expected
+        refusal). Any other failure raises SendError carrying the engine's
+        error, after logging it.
 
         `user_id` attributes the send to a human user; it's stashed in a
         ContextVar that the to_app/to_admin log path reads. None (engine/auto
@@ -218,8 +229,9 @@ class Session:
         try:
             await transport_session.send_app(message)
             return True
-        except Exception:
-            return False
+        except Exception as e:
+            logger.exception("[%s] send_app failed", self.config.session_id)
+            raise SendError(str(e)) from e
         finally:
             _sending_user.reset(token)
 

{fixtureqa-0.16.0 → fixtureqa-0.17.0}/fixture/core/session_manager.py

@@ -5,7 +5,9 @@ import shutil
 import threading
 from typing import Dict, List, Optional, Set
 from .models import SessionConfig, SessionState, SessionStatus
-from .session import Session
+# SendError is re-exported here: external code (routes, perf, scenarios) only
+# imports from SessionManager, never from Session directly.
+from .session import SendError, Session  # noqa: F401 (SendError re-export)
 from .events import EventHandler, EventType, SessionEvent
 from .config_store import ConfigStore
 from .inbound import InboundMessage, SessionSubscription, DEFAULT_MAXSIZE
@@ -71,8 +73,8 @@ class SessionManager:
     async def start_session(self, session_id: str) -> None:
         await self._get(session_id).start()
 
-    async def stop_session(self, session_id: str, force: bool = False) -> None:
-        await self._get(session_id).stop(force=force)
+    async def stop_session(self, session_id: str) -> None:
+        await self._get(session_id).stop()
 
     def update_session(self, session_id: str, req) -> SessionConfig:
         """Update config fields on a stopped session.
@@ -90,7 +92,13 @@ class SessionManager:
             if session.state.status != SessionStatus.STOPPED:
                 raise RuntimeError("Session must be stopped before editing")
             cfg = session.config
-            updates = {k: v for k, v in req.model_dump().items() if v is not None}
+            # Only fields the caller actually sent are applied, so an explicit
+            # null can clear a nullable field (previously indistinguishable
+            # from "not provided" and silently dropped). None is still skipped
+            # for the non-nullable fields, where it is never a valid value.
+            nullable = {"data_dictionary_path", "app_data_dictionary"}
+            updates = {k: v for k, v in req.model_dump(exclude_unset=True).items()
+                       if v is not None or k in nullable}
             if "connection_type" in updates:
                 updates["connection_type"] = ConnectionType(updates["connection_type"])
             if "session_role" in updates:
@@ -125,7 +133,7 @@ class SessionManager:
             session = self._sessions.pop(session_id, None)
         if session is None:
             raise KeyError(f"Unknown session: {session_id!r}")
-        await session.stop(force=True)  # await — outside the lock
+        await session.stop()  # await — outside the lock
         self._persist()  # disk I/O — outside the lock
 
     def get_state(self, session_id: str) -> SessionState:
@@ -172,6 +180,7 @@ class SessionManager:
         return self._get(session_id).set_seqnums(sender, target)
 
     async def send_message(self, session_id: str, message, user_id: Optional[str] = None) -> bool:
+        """False = not logged on; raises SendError on an actual send failure."""
         return await self._get(session_id).send_message(message, user_id=user_id)
 
     # ------------------------------------------------------------------