@whalent/agent 0.3.263 → 0.3.265

package/dist/jupyter_sidecar.py

@@ -19,6 +19,7 @@ import traceback
 from typing import Any
 
 from jupyter_client import KernelManager
+from jupyter_client.kernelspec import KernelSpec
 
 
 WRITE_LOCK = threading.Lock()
@@ -75,10 +76,19 @@ def start_kernel() -> dict[str, Any]:
             return safe_status()
         STATE = "starting"
         manager = KernelManager()
-        # The sidecar itself runs under the selected interpreter. Explicitly
-        # pin ipykernel to the same executable instead of trusting a global spec.
-        manager.kernel_cmd = [sys.executable, "-m", "ipykernel_launcher", "-f", "{connection_file}"]
-        manager.start_kernel()
+        # The sidecar itself runs under the selected interpreter. Pin ipykernel
+        # to the same executable via an explicit KernelSpec: assigning
+        # `manager.kernel_cmd` is a silent no-op on jupyter_client >= 7 (the
+        # trait is gone), while `_kernel_spec` is the cache slot behind the
+        # KernelManager.kernel_spec property and keeps its meaning on 5.x-8.x.
+        manager._kernel_spec = KernelSpec(
+            argv=[sys.executable, "-m", "ipykernel_launcher", "-f", "{connection_file}"],
+            display_name="Whalent (pinned)",
+            language="python",
+        )
+        # Kernel stdout/stderr go to the sidecar's stderr so raw fd writes from
+        # user code can never corrupt the NDJSON protocol on stdout.
+        manager.start_kernel(stdout=sys.stderr, stderr=sys.stderr)
         client = manager.client()
         client.start_channels()
         client.wait_for_ready(timeout=30)
@@ -127,16 +137,21 @@ def output_from_message(message: dict[str, Any]) -> dict[str, Any] | None:
 
 def execute_worker(request_id: str, cell_id: str, code: str, timeout_seconds: float) -> None:
     global STATE, CURRENT_CELL
+    generation = GENERATION
     try:
         start_kernel()
         with KERNEL_LOCK:
+            # Capture the generation this execute belongs to (start_kernel may
+            # have revived a dead kernel and bumped it); every frame below is
+            # stamped with it so the daemon can fence stale generations.
+            generation = GENERATION
             client = KC
             if client is None:
                 raise RuntimeError("kernel client unavailable")
             msg_id = client.execute(code, stop_on_error=True, allow_stdin=False)
-        STATE = "busy"
-        CURRENT_CELL = cell_id
-        emit({"type": "execution.started", "request_id": request_id, "cell_id": cell_id, **safe_status()})
+            STATE = "busy"
+            CURRENT_CELL = cell_id
+        emit({"type": "execution.started", "request_id": request_id, "cell_id": cell_id, **safe_status(), "generation": generation})
         deadline = time.monotonic() + timeout_seconds
         execution_count = None
         shell_done = False
@@ -151,9 +166,9 @@ def execute_worker(request_id: str, cell_id: str, code: str, timeout_seconds: fl
                     output = output_from_message(message)
                     if output:
                         if output.get("outputType") == "clear_output":
-                            emit({"type": "output.clear", "cell_id": cell_id, "wait": output.get("wait", False)})
+                            emit({"type": "output.clear", "cell_id": cell_id, "generation": generation, "wait": output.get("wait", False)})
                         else:
-                            emit({"type": "output", "cell_id": cell_id, "output": output})
+                            emit({"type": "output", "cell_id": cell_id, "generation": generation, "output": output})
             except queue.Empty:
                 pass
             if not shell_done:
@@ -172,8 +187,10 @@ def execute_worker(request_id: str, cell_id: str, code: str, timeout_seconds: fl
             except Exception:
                 pass
             raise TimeoutError(f"cell execution exceeded {int(timeout_seconds)} seconds")
-        STATE = "idle"
-        CURRENT_CELL = None
+        with KERNEL_LOCK:
+            if CURRENT_CELL == cell_id:
+                STATE = "idle"
+                CURRENT_CELL = None
         emit({
             "type": "execution.reply",
             "request_id": request_id,
@@ -181,10 +198,15 @@ def execute_worker(request_id: str, cell_id: str, code: str, timeout_seconds: fl
             "cell_id": cell_id,
             "execution_count": execution_count,
             **safe_status(),
+            "generation": generation,
         })
     except Exception as exc:
-        STATE = "idle" if KM is not None and KM.is_alive() else "dead"
-        CURRENT_CELL = None
+        # Only release the claim if this worker still owns it: a restart may
+        # already have handed the kernel to a newer execute.
+        with KERNEL_LOCK:
+            if CURRENT_CELL == cell_id:
+                STATE = "idle" if KM is not None and KM.is_alive() else "dead"
+                CURRENT_CELL = None
         emit({
             "type": "execution.reply",
             "request_id": request_id,
@@ -192,9 +214,8 @@ def execute_worker(request_id: str, cell_id: str, code: str, timeout_seconds: fl
             "cell_id": cell_id,
             "error": {"message": str(exc)},
             **safe_status(),
+            "generation": generation,
         })
-    finally:
-        CURRENT_CELL = None
 
 
 def interrupt_kernel() -> dict[str, Any]:
@@ -234,7 +255,7 @@ def shutdown_kernel() -> dict[str, Any]:
 
 
 def handle(message: dict[str, Any]) -> None:
-    global GENERATION
+    global STATE, CURRENT_CELL
     request_id = str(message.get("id", ""))
     method = str(message.get("method", ""))
     params = message.get("params") if isinstance(message.get("params"), dict) else {}
@@ -246,11 +267,24 @@ def handle(message: dict[str, Any]) -> None:
             code = str(params.get("code", ""))
             if not cell_id:
                 raise ValueError("cell_id required")
-            threading.Thread(
-                target=execute_worker,
-                args=(request_id, cell_id, code, max(1.0, min(float(params.get("timeout_seconds", 1800)), 3600.0))),
-                daemon=True,
-            ).start()
+            with KERNEL_LOCK:
+                if CURRENT_CELL is not None:
+                    raise ValueError(f"kernel busy: cell {CURRENT_CELL} still running")
+                # Claim the kernel before the worker thread exists so two
+                # racing execute requests can never drain IOPub concurrently.
+                STATE = "busy"
+                CURRENT_CELL = cell_id
+            try:
+                threading.Thread(
+                    target=execute_worker,
+                    args=(request_id, cell_id, code, max(1.0, min(float(params.get("timeout_seconds", 1800)), 3600.0))),
+                    daemon=True,
+                ).start()
+            except BaseException:
+                with KERNEL_LOCK:
+                    STATE = "idle" if KM is not None and KM.is_alive() else "dead"
+                    CURRENT_CELL = None
+                raise
         elif method == "interrupt":
             reply(request_id, True, interrupt_kernel())
         elif method == "restart":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whalent/agent",
-  "version": "0.3.263",
+  "version": "0.3.265",
   "description": "Stable wrapper for Whalent Agent core runtime",
   "type": "module",
   "main": "dist/index.cjs",
@@ -54,7 +54,7 @@
     "yaml": "^2.4.0"
   },
   "optionalDependencies": {
-    "@whalent/agent-core": "0.3.263",
+    "@whalent/agent-core": "0.3.265",
     "node-pty": "^1.1.0"
   },
   "devDependencies": {