@hy-sde-org/dsh-code-runtime-kernels 0.1.2-rc.1 → 0.1.5-rc.1

package/dist/python/runner.js

@@ -35,13 +35,19 @@ import ast
 import asyncio
 import builtins
 import contextvars
+import importlib
 import io
 import json
+import marshal
 import os
+import pickle
 import signal
 import sys
 import threading
+import time
 import traceback
+import types
+import zlib
 from typing import Any
 
 # ---------------------------------------------------------------------------
@@ -194,11 +200,70 @@ class _RunnerState:
         self.capture_rid: str | None = None
         # (run_id, seq) -> Future awaiting the host's reply to a binding call.
         self.pending_calls: dict[tuple[str, int], asyncio.Future] = {}
+        # Namespace persistence (session snapshots): the spec of the CURRENT
+        # exec, whether this process already restored once, and how the last
+        # run settled (a snapshot is written only after a successful run).
+        self.snapshot_spec: dict | None = None
+        self.restored_once: bool = False
+        self.last_status: str = "ok"
 
 
 _CURRENT_RID: contextvars.ContextVar[str | None] = contextvars.ContextVar("dsh_rid", default=None)
 _STATE = _RunnerState()
 
+# ---------------------------------------------------------------------------
+# Optional ipykernel/real-IPython execution mode (config pythonImpl: ipykernel)
+# ---------------------------------------------------------------------------
+#
+# The default runner is self-contained stdlib; this mode swaps cell execution
+# to a real IPython shell (magics, !cmd, display) while keeping the SAME
+# protocol, namespaces, binding proxies, and snapshot machinery.
+
+_IPYTHON_SHELL = None
+_IPYTHON_SKIP = {"In", "Out", "get_ipython", "exit", "quit", "open", "_", "__", "___", "_oh", "_ih"}
+
+
+def _maybe_init_ipython() -> None:
+    """Activate IPython semantics when the host configured pythonImpl: ipykernel.
+
+    Fails loud at boot (exit 2) when IPython is not importable so the host
+    reports a startup failure instead of silently running with stdlib.
+    """
+    global _IPYTHON_SHELL
+    if os.environ.get("DSH_KERNEL_PYTHON_IMPL") != "ipykernel":
+        return
+    try:
+        from IPython.core.displayhook import DisplayHook
+        from IPython.core.interactiveshell import DisplayTrap, InteractiveShell
+    except ImportError as exc:
+        sys.stderr.write(
+            "dsh-code-runtime-kernels: pythonImpl 'ipykernel' needs IPython in the interpreter"
+            + " that spawns kernels (pip install ipykernel): " + str(exc) + "\n")
+        sys.stderr.flush()
+        os._exit(2)
+    shell = InteractiveShell.instance()
+    shell.colors = "NoColor"
+
+    class _QuietDisplayHook(DisplayHook):
+        def write_output_prompt(self):
+            pass
+
+        def write_format_data(self, format_dict, md_dict=None):
+            pass
+
+    # IPython installs its own sys.displayhook + DisplayTrap at init; both must
+    # be replaced (and the trap re-bound) or every expression prints Out[n].
+    hook = _QuietDisplayHook(shell=shell, cache_size=0)
+    shell.displayhook = hook
+    shell.display_trap = DisplayTrap(hook=hook)
+    sys.displayhook = hook
+    ns = shell.user_ns
+    if not isinstance(ns.get("__name__"), str):
+        ns["__name__"] = "__main__"
+    _STATE.user_ns = ns
+    _IPYTHON_SHELL = shell
+
+
 _call_seq = 0
 
 
@@ -380,6 +445,7 @@ def _finish_run(
     invalid_output: bool = False,
     message: str = "",
 ) -> None:
+    _STATE.last_status = "ok" if (status == "ok" and not cancelled) else "error"
     _STATE.execution_count += 1
     frame: dict = {
         "type": "done",
@@ -410,7 +476,77 @@ async def _await_code(code_obj: Any, ns: dict) -> Any:
     return eval(code_obj, ns)
 
 
+async def _run_cell_ipython(code: str, run_id: str, namespaces: list[dict]) -> None:
+    """IPython-mode cell: real shell semantics (magics, !cmd, display, TLA).
+
+    run_cell_async executes inside the runner's live asyncio loop (run_cell
+    would try run_until_complete on a loop that is already running), so
+    top-level await interleaves exactly like stdlib mode. It returns the last
+    expression as result.result and splits syntax/exec errors into
+    error_before_exec / error_in_exec; the completion value still goes through
+    the lossless-JSON gate so the return-value contract is identical to
+    stdlib mode.
+    """
+    ns = _STATE.user_ns
+    restores = _materialize_namespaces(run_id, ns, namespaces)
+    _STATE.capture_rid = run_id
+    token = _CURRENT_RID.set(run_id)
+    try:
+        transformed_cell = None
+        preprocessing_exc = None
+        try:
+            transformed_cell = _IPYTHON_SHELL.transform_cell(code)
+        except Exception as exc:  # noqa: BLE001 - any transform failure is the cell's parse error
+            preprocessing_exc = (type(exc), exc, exc.__traceback__)
+        result = await _IPYTHON_SHELL.run_cell_async(
+            code, store_history=False, transformed_cell=transformed_cell, preprocessing_exc_tuple=preprocessing_exc)
+        _flush_stream_proxies(run_id)
+        if not result.success:
+            exc = result.error_in_exec
+            if exc is None:
+                exc = result.error_before_exec
+            tb = traceback.format_exception(type(exc), exc, exc.__traceback__) if exc is not None else []
+            _emit({
+                "type": "error",
+                "id": run_id,
+                "ename": type(exc).__name__ if exc is not None else "Error",
+                "evalue": str(exc) if exc is not None else "cell failed",
+                "traceback": tb,
+            })
+            _finish_run(run_id, status="error", message=str(exc) if exc is not None else "cell failed")
+            return
+        value = result.result
+        if value is None:
+            _finish_run(run_id, status="ok")
+            return
+        serialized_ok, serialized = _lossless_json(value)
+        if not serialized_ok:
+            _finish_run(run_id, status="error", invalid_output=True)
+            return
+        _finish_run(run_id, status="ok", value=serialized, has_value=True)
+    except KeyboardInterrupt:
+        _flush_stream_proxies(run_id)
+        _STATE.cancel_requested = False
+        _finish_run(run_id, status="error", cancelled=True)
+    except asyncio.CancelledError:
+        _flush_stream_proxies(run_id)
+        _STATE.cancel_requested = False
+        _finish_run(run_id, status="error", cancelled=True)
+        raise
+    finally:
+        _CURRENT_RID.reset(token)
+        _STATE.capture_rid = None
+        for name, previous in restores:
+            if previous is _MISSING:
+                ns.pop(name, None)
+            else:
+                ns[name] = previous
+
+
 async def _run_cell(code: str, run_id: str, namespaces: list[dict]) -> None:
+    if _IPYTHON_SHELL is not None:
+        await _run_cell_ipython(code, run_id, namespaces)
+        return
     sys.stdout = _StreamProxy("stdout")
     sys.stderr = _StreamProxy("stderr")  # noqa: F841 - kept for symmetry
     ns = _STATE.user_ns
@@ -477,6 +613,224 @@ async def _run_cell(code: str, run_id: str, namespaces: list[dict]) -> None:
                 ns[name] = previous
 
 
+# ---------------------------------------------------------------------------
+# Namespace persistence: session snapshots (stdlib pickle + zlib, atomic)
+# ---------------------------------------------------------------------------
+#
+# The kernel owns the file. After every successfully settled run the user
+# namespace is packed entry by entry and written to spec["path"] via
+# temp-file-and-rename; a fresh process restores it once, on its first exec.
+# Entries that cannot be represented (user-defined class instances, lambdas in
+# containers, closures over non-picklables) are named, never silently dropped.
+# Pickle is NOT a security boundary — a snapshot file grants code execution to
+# whoever reads it, but the kernel already runs model code (bash-equivalent
+# trust), so the file stays inside the user's own state directory.
+
+
+_SNAPSHOT_VERSION = 1
+_RESTORE_NOTICE_LIMIT = 12
+
+
+def _is_snapshot_spec(value: Any) -> bool:
+    if not isinstance(value, dict):
+        return False
+    path = value.get("path")
+    max_bytes = value.get("maxBytes")
+    max_entry = value.get("maxEntryBytes")
+    return (
+        isinstance(path, str)
+        and bool(path)
+        and isinstance(max_bytes, int)
+        and max_bytes > 0
+        and isinstance(max_entry, int)
+        and max_entry > 0
+    )
+
+
+def _pack_class(cls: type) -> dict:
+    base_payloads = []
+    for base in cls.__bases__:
+        base_payloads.append(pickle.dumps(base, protocol=pickle.HIGHEST_PROTOCOL))
+    members: dict[str, dict] = {}
+    skip = {"__dict__", "__weakref__", "__module__", "__qualname__", "__doc__", "__slots__"}
+    for key, value in list(cls.__dict__.items()):
+        if key in skip:
+            continue
+        if isinstance(value, staticmethod):
+            members[key] = {"kind": "staticmethod", "func": _pack_value(value.__func__)}
+        elif isinstance(value, classmethod):
+            members[key] = {"kind": "classmethod", "func": _pack_value(value.__func__)}
+        elif isinstance(value, property):
+            raise TypeError("property members are not snapshot-supported")
+        else:
+            members[key] = _pack_value(value)
+    return {"kind": "class", "name": cls.__name__, "bases": base_payloads, "members": members}
+
+
+def _pack_value(value: Any) -> dict:
+    """One namespace entry as a snapshot record. Raises when it cannot be saved."""
+    if isinstance(value, types.ModuleType):
+        return {"kind": "module", "name": value.__name__}
+    if isinstance(value, (types.BuiltinFunctionType, types.BuiltinMethodType)):
+        module_name = getattr(value, "__module__", None)
+        qualname = getattr(value, "__qualname__", getattr(value, "__name__", None))
+        if isinstance(module_name, str) and isinstance(qualname, str):
+            return {"kind": "builtin", "module": module_name, "qualname": qualname}
+        raise TypeError("builtin without importable identity cannot be snapshotted")
+    if isinstance(value, type):
+        return _pack_class(value)
+    if isinstance(value, types.FunctionType):
+        # Imported functions/classes pickle by reference; __main__-defined
+        # callables do not, so fall back to by-value (code + defaults + cells).
+        try:
+            return {"kind": "ref", "payload": pickle.dumps(value, protocol=pickle.HIGHEST_PROTOCOL)}
+        except Exception:
+            pass
+        closure = value.__closure__ or ()
+        # Code objects are not picklable, so the bytecode travels as marshal
+        # bytes (same-interpreter restarts guarantee a compatible marshal
+        # format; a cross-version restore fails per-name and is reported).
+        return {
+            "kind": "function",
+            "name": value.__name__,
+            "qualname": getattr(value, "__qualname__", value.__name__),
+            "code": marshal.dumps(value.__code__),
+            "defaults": value.__defaults__,
+            "kwdefaults": value.__kwdefaults__,
+            "closure": [cell.cell_contents for cell in closure],
+        }
+    return {"kind": "data", "payload": pickle.dumps(value, protocol=pickle.HIGHEST_PROTOCOL)}
+
+
+def _rebuild_function(record: dict) -> Any:
+    code = marshal.loads(record["code"])
+    defaults = record.get("defaults")
+    closure_values = record.get("closure")
+    cells = None
+    if isinstance(closure_values, list):
+        cells = tuple(types.CellType(value) for value in closure_values)
+    fn = types.FunctionType(code, _STATE.user_ns, record.get("name") or "<lambda>", defaults, cells)
+    kwdefaults = record.get("kwdefaults")
+    if kwdefaults is not None:
+        fn.__kwdefaults__ = kwdefaults
+    qualname = record.get("qualname")
+    if isinstance(qualname, str):
+        fn.__qualname__ = qualname
+    fn.__module__ = "__main__"
+    return fn
+
+
+def _rebuild_class(record: dict) -> Any:
+    bases = tuple(pickle.loads(payload) for payload in record["bases"])
+    members: dict[str, Any] = {}
+    for key, member in record["members"].items():
+        kind = member.get("kind")
+        if kind == "staticmethod":
+            members[key] = staticmethod(_unpack_value(member["func"]))
+        elif kind == "classmethod":
+            members[key] = classmethod(_unpack_value(member["func"]))
+        else:
+            members[key] = _unpack_value(member)
+    cls = type(record["name"], bases, members)
+    cls.__module__ = "__main__"
+    return cls
+
+
+def _unpack_value(record: dict) -> Any:
+    kind = record.get("kind")
+    if kind == "module":
+        return importlib.import_module(record["name"])
+    if kind == "builtin":
+        target = importlib.import_module(record["module"])
+        for part in record["qualname"].split("."):
+            target = getattr(target, part)
+        return target
+    if kind in ("data", "ref"):
+        return pickle.loads(record["payload"])
+    if kind == "function":
+        return _rebuild_function(record)
+    if kind == "class":
+        return _rebuild_class(record)
+    raise ValueError(f"unknown snapshot record kind {kind!r}")
+
+
+def _collect_entries(spec: dict) -> tuple[dict, list[str]]:
+    max_bytes = spec["maxBytes"]
+    max_entry = spec["maxEntryBytes"]
+    entries: dict[str, dict] = {}
+    skipped: list[str] = []
+    total = 0
+    for name, value in list(_STATE.user_ns.items()):
+        if name.startswith("__") or name in _IPYTHON_SKIP:
+            continue
+        try:
+            record = _pack_value(value)
+            size = len(pickle.dumps(record, protocol=pickle.HIGHEST_PROTOCOL))
+        except Exception:
+            skipped.append(name)
+            continue
+        if size > max_entry or total + size > max_bytes:
+            skipped.append(name)
+            continue
+        entries[name] = record
+        total += size
+    return entries, skipped
+
+
+def _save_snapshot(spec: dict) -> None:
+    """Write the current namespace atomically; a failure never fails the run."""
+    path = spec["path"]
+    tmp = ""
+    try:
+        os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
+        entries, skipped = _collect_entries(spec)
+        doc = {"version": _SNAPSHOT_VERSION, "savedAt": time.time(), "entries": entries, "lost": skipped}
+        payload = zlib.compress(pickle.dumps(doc, protocol=pickle.HIGHEST_PROTOCOL))
+        tmp = path + ".tmp"
+        with open(tmp, "wb") as handle:
+            handle.write(payload)
+        os.replace(tmp, path)
+    except BaseException:
+        try:
+            if tmp:
+                os.unlink(tmp)
+        except OSError:
+            pass
+
+
+def _restore_snapshot(spec: dict, rid: str) -> None:
+    """Restore the last saved namespace once; report revived and lost names."""
+    path = spec["path"]
+    if not os.path.exists(path):
+        return
+    try:
+        with open(path, "rb") as handle:
+            doc = pickle.loads(zlib.decompress(handle.read()))
+        if not isinstance(doc, dict) or doc.get("version") != _SNAPSHOT_VERSION:
+            raise ValueError("unsupported snapshot version")
+        entries = doc.get("entries")
+        if not isinstance(entries, dict):
+            raise ValueError("snapshot entries missing")
+    except BaseException as exc:  # noqa: BLE001 - a bad snapshot must not wedge the kernel
+        _emit({"type": "log", "id": rid, "text": f"[dsh-kernels] snapshot unreadable (restore skipped): {exc}"})
+        return
+    restored: list[str] = []
+    lost = [name for name in doc.get("lost", []) if isinstance(name, str)]
+    for name, record in entries.items():
+        try:
+            _STATE.user_ns[name] = _unpack_value(record)
+            restored.append(name)
+        except BaseException:
+            lost.append(name)
+    notice = f"[dsh-kernels] restored {len(restored)} names from snapshot"
+    if lost:
+        shown = ", ".join(lost[:_RESTORE_NOTICE_LIMIT])
+        if len(lost) > _RESTORE_NOTICE_LIMIT:
+            shown += ", ..."
+        notice += f" (could not restore: {shown})"
+    _emit({"type": "log", "id": rid, "text": notice})
+
+
 def _install_idle_sigint() -> None:
     """SIGINT (host interrupt/escalation) interrupts the active run.
 
@@ -545,18 +899,29 @@ async def _handle_request_async(req: dict) -> None:
     namespaces = req.get("namespaces")
     if not isinstance(namespaces, list):
         namespaces = []
+    # Namespace persistence: restore once per process (on the first exec that
+    # carries a spec), then remember the spec so the run's success can persist.
+    snapshot = req.get("snapshot")
+    _STATE.snapshot_spec = snapshot if _is_snapshot_spec(snapshot) else None
+    if _STATE.snapshot_spec is not None and not _STATE.restored_once:
+        _STATE.restored_once = True
+        _restore_snapshot(_STATE.snapshot_spec, rid)
     _STATE.cancel_requested = False
     try:
         await _run_cell(code, rid, namespaces)
     except asyncio.CancelledError:
         _STATE.cancel_requested = False
         _finish_run(rid, status="error", cancelled=True)
+    finally:
+        if _STATE.snapshot_spec is not None and _STATE.last_status == "ok":
+            _save_snapshot(_STATE.snapshot_spec)
 
 
 async def _main_async() -> None:
     sys.stdout = _StreamProxy("stdout")
     sys.stderr = _StreamProxy("stderr")
     _install_idle_sigint()
+    _maybe_init_ipython()
     _start_capture_drain()
 
     stdin = sys.__stdin__

package/dist/python/runner.js.map

@@ -1 +1 @@
-{"version":3,"file":"runner.js","sourceRoot":"","sources":["../../src/python/runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6kBtC,CAAA"}
+{"version":3,"file":"runner.js","sourceRoot":"","sources":["../../src/python/runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA07BtC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hy-sde-org/dsh-code-runtime-kernels",
-  "version": "0.1.2-rc.1",
+  "version": "0.1.5-rc.1",
   "description": "The run_kernel_code tool for DeepSeek Harness: persistent Python and JavaScript kernels (a long-lived python3/node subprocess per session, sharing a core host driver) — a standalone plugin with no upstream harness changes required.",
   "type": "module",
   "main": "./dist/index.js",
@@ -32,7 +32,8 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/hy-sde/dsh-code-runtime-kernels.git"
+    "url": "git+https://github.com/hy-sde/dsh-plugins.git",
+    "directory": "dsh-code-runtime-kernels/packages/code-runtime-kernels"
   },
   "license": "MIT",
   "dsh": {
@@ -45,29 +46,29 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-code-runtime": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-invariants": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-session": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-spill": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-timeout": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-tools": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-util-values": "^0.1.2-rc.1"
+    "@deepseek-ai/dsh-code-runtime": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-invariants": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-session": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-spill": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-timeout": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-tools": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-util-values": "^0.1.5-rc.1"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-code-runtime": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-invariants": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-session": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-spill": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-system-prompt": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-timeout": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-tools": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-code-runtime": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-invariants": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-session": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-spill": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-timeout": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-tools": "^0.1.5-rc.1",
     "@deepseek-ai/schemastery": "3.18.1",
     "@types/node": "^24.13.3",
     "typescript": "^5.9.3",
     "vitest": "^3.2.7",
-    "@deepseek-ai/dsh-llm": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-util-values": "^0.1.2-rc.1"
+    "@deepseek-ai/dsh-llm": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-util-values": "^0.1.5-rc.1"
   },
   "keywords": [
     "deepseek",