@agentunion/kite 1.2.0 → 1.3.1

package/extensions/channels/acp_channel/server.py

@@ -1,8 +1,6 @@
 """
-ACP Channel HTTP server.
-Exposes /health and /status endpoints.
-Connects to Event Hub via WebSocket for event publishing and subscription.
-Sends periodic heartbeat to Registry and test events to Event Hub.
+ACP Channel WebSocket client.
+Connects to Kernel via WebSocket JSON-RPC 2.0 for event publishing and subscription.
 """
 
 import asyncio
@@ -11,127 +9,101 @@ import time
 import uuid
 from datetime import datetime, timezone
 
-import httpx
 import websockets
-from fastapi import FastAPI
 
 
 class AcpChannelServer:
 
-    def __init__(self, token: str = "", registry_url: str = "",
-                 event_hub_ws: str = "", boot_t0: float = 0):
+    def __init__(self, token: str = "", kernel_port: int = 0, boot_t0: float = 0):
         self.token = token
-        self.registry_url = registry_url
-        self.event_hub_ws = event_hub_ws
+        self.kernel_port = kernel_port
         self.boot_t0 = boot_t0
         self._ws_task: asyncio.Task | None = None
-        self._heartbeat_task: asyncio.Task | None = None
         self._test_task: asyncio.Task | None = None
         self._ws: object | None = None
         self._ready_sent = False
         self._shutting_down = False
-        self._uvicorn_server = None  # set by entry.py for graceful shutdown
         self._start_time = time.time()
-        self.app = self._create_app()
-
-    def _create_app(self) -> FastAPI:
-        app = FastAPI(title="Kite ACP Channel", docs_url=None, redoc_url=None)
-        server = self
-
-        @app.on_event("startup")
-        async def _startup():
-            server._heartbeat_task = asyncio.create_task(server._heartbeat_loop())
-            if server.event_hub_ws:
-                server._ws_task = asyncio.create_task(server._ws_loop())
-            server._test_task = asyncio.create_task(server._test_event_loop())
-
-        @app.on_event("shutdown")
-        async def _shutdown():
-            if server._heartbeat_task:
-                server._heartbeat_task.cancel()
-            if server._ws_task:
-                server._ws_task.cancel()
-            if server._test_task:
-                server._test_task.cancel()
-            if server._ws:
-                await server._ws.close()
-            print("[acp_channel] Shutdown complete")
-
-        @app.get("/health")
-        async def health():
-            return {
-                "status": "healthy",
-                "details": {
-                    "event_hub_connected": server._ws is not None,
-                    "uptime_seconds": round(time.time() - server._start_time),
-                },
-            }
 
-        @app.get("/status")
-        async def status():
-            return {
-                "module": "acp_channel",
-                "status": "running",
-                "event_hub_connected": server._ws is not None,
-                "uptime_seconds": round(time.time() - server._start_time),
-            }
+    async def run(self):
+        """Main entry point: start WebSocket loop and test event loop."""
+        if self.kernel_port:
+            self._ws_task = asyncio.create_task(self._ws_loop())
+        self._test_task = asyncio.create_task(self._test_event_loop())
+
+        # Wait for tasks to complete
+        tasks = [t for t in [self._ws_task, self._test_task] if t]
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
 
-        return app
+        print("[acp_channel] Shutdown complete")
 
-    # ── Event Hub WebSocket client ──
+    # ── Kernel WebSocket client ──
 
     async def _ws_loop(self):
-        """Connect to Event Hub, subscribe, and listen. Reconnect on failure."""
-        retry_delay = 0.5  # start with 0.5s
-        max_delay = 30  # cap at 30s
+        """Connect to Kernel, subscribe, register, and listen. Reconnect on failure."""
+        retry_delay = 0.5
+        max_delay = 30
         while not self._shutting_down:
             try:
                 await self._ws_connect()
             except asyncio.CancelledError:
                 return
-                retry_delay = 0.5  # reset on successful connection
             except Exception as e:
-                print(f"[acp_channel] Event Hub connection error: {e}, retrying in {retry_delay:.1f}s")
+                print(f"[acp_channel] Kernel connection error: {e}, retrying in {retry_delay:.1f}s")
             self._ws = None
             if self._shutting_down:
                 return
             await asyncio.sleep(retry_delay)
-            retry_delay = min(retry_delay * 2, max_delay)  # exponential backoff
+            retry_delay = min(retry_delay * 2, max_delay)
 
     async def _ws_connect(self):
-        """Single WebSocket session: connect, subscribe, receive loop."""
-        url = f"{self.event_hub_ws}?token={self.token}&id=acp_channel"
-        print(f"[acp_channel] WS connecting to {self.event_hub_ws}")
+        """Single WebSocket session: connect, subscribe, register, ready, receive loop."""
+        url = f"ws://127.0.0.1:{self.kernel_port}/ws?token={self.token}&id=acp_channel"
+        print(f"[acp_channel] Connecting to Kernel (port {self.kernel_port})")
         async with websockets.connect(url, open_timeout=3, ping_interval=None, ping_timeout=None, close_timeout=10) as ws:
             self._ws = ws
             elapsed = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
             elapsed_str = f" ({elapsed:.1f}s)" if elapsed else ""
-            print(f"[acp_channel] Connected to Event Hub{elapsed_str}")
+            print(f"[acp_channel] Connected to Kernel{elapsed_str}")
 
-            # Subscribe to module lifecycle events + shutdown
-            await ws.send(json.dumps({
-                "type": "subscribe",
+            # Step 1: Subscribe to events (先订阅)
+            await self._rpc_call(ws, "event.subscribe", {
                 "events": ["module.started", "module.stopped", "module.shutdown"],
-            }))
+            })
+
+            # Step 2: Register to Kernel (再注册)
+            await self._rpc_call(ws, "registry.register", {
+                "module_id": "acp_channel",
+                "module_type": "channel",
+                "name": "ACP Channel",
+                "events_publish": {
+                    "acp_channel.test": {},
+                },
+                "events_subscribe": [
+                    "module.started",
+                    "module.stopped",
+                    "module.shutdown",
+                ],
+            })
 
-            # Send module.ready (once) so Launcher knows we're up
+            # Step 3: Publish module.ready (once)
             if not self._ready_sent:
-                ready_msg = {
-                    "type": "event",
+                await self._rpc_call(ws, "event.publish", {
                     "event_id": str(uuid.uuid4()),
                     "event": "module.ready",
-                    "source": "acp_channel",
-                    "timestamp": datetime.now(timezone.utc).isoformat(),
                     "data": {
                         "module_id": "acp_channel",
                         "graceful_shutdown": True,
                     },
-                }
-                await ws.send(json.dumps(ready_msg))
+                })
                 self._ready_sent = True
                 elapsed = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
                 elapsed_str = f" ({elapsed:.1f}s)" if elapsed else ""
-                print(f"[acp_channel] module.ready sent{elapsed_str}")
+                print(f"[acp_channel] module.ready published{elapsed_str}")
+
+            # Reset retry delay on successful connection
+            retry_delay = 0.5
 
             # Receive loop
             async for raw in ws:
@@ -141,18 +113,22 @@ class AcpChannelServer:
                     continue
 
                 try:
-                    msg_type = msg.get("type", "")
-                    if msg_type == "event":
-                        event_name = msg.get("event", "")
+                    has_method = "method" in msg
+                    has_id = "id" in msg
+
+                    if has_method and not has_id:
+                        # JSON-RPC Notification (event delivery)
+                        params = msg.get("params", {})
+                        event_name = params.get("event", "")
                         if event_name == "module.shutdown":
-                            target = (msg.get("data") if isinstance(msg.get("data"), dict) else {}).get("module_id", "")
+                            data = params.get("data", {})
+                            target = data.get("module_id", "")
                             if target == "acp_channel":
                                 await self._handle_shutdown(ws)
                                 return
-                    elif msg_type == "ack":
-                        pass  # publish confirmed
-                    elif msg_type == "error":
-                        print(f"[acp_channel] Event Hub error: {msg.get('message')}")
+                    elif not has_method and has_id:
+                        # JSON-RPC Response (to our RPC calls)
+                        pass
                 except Exception as e:
                     print(f"[acp_channel] 事件处理异常（已忽略）: {e}")
 
@@ -162,64 +138,49 @@ class AcpChannelServer:
         self._shutting_down = True
 
         # Step 1: Send ack
-        await self._publish_event({
+        await self._rpc_call(ws, "event.publish", {
+            "event_id": str(uuid.uuid4()),
             "event": "module.shutdown.ack",
             "data": {"module_id": "acp_channel", "estimated_cleanup": 2},
         })
         print("[acp_channel] shutdown ack sent")
 
         # Step 2: Cleanup (cancel background tasks)
-        if self._heartbeat_task:
-            self._heartbeat_task.cancel()
         if self._test_task:
             self._test_task.cancel()
 
         # Step 3: Send ready (before closing WS!)
-        await self._publish_event({
+        await self._rpc_call(ws, "event.publish", {
+            "event_id": str(uuid.uuid4()),
             "event": "module.shutdown.ready",
             "data": {"module_id": "acp_channel"},
         })
-        print("[acp_channel] Shutdown complete")
+        print("[acp_channel] Shutdown ready sent")
 
-        # Step 4: Trigger uvicorn exit (WS will close when uvicorn shuts down)
-        if self._uvicorn_server:
-            self._uvicorn_server.should_exit = True
+        # Step 4: Exit process
+        import sys
+        sys.exit(0)
+
+    async def _rpc_call(self, ws, method: str, params: dict = None):
+        """Send a JSON-RPC 2.0 request."""
+        msg = {"jsonrpc": "2.0", "id": str(uuid.uuid4()), "method": method}
+        if params:
+            msg["params"] = params
+        await ws.send(json.dumps(msg))
 
     async def _publish_event(self, event: dict):
-        """Publish an event to Event Hub via WebSocket."""
+        """Publish an event via JSON-RPC event.publish."""
         if not self._ws:
             return
-        msg = {
-            "type": "event",
-            "event_id": str(uuid.uuid4()),
-            "event": event.get("event", ""),
-            "source": "acp_channel",
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "data": event.get("data", {}),
-        }
         try:
-            await self._ws.send(json.dumps(msg))
+            await self._rpc_call(self._ws, "event.publish", {
+                "event_id": str(uuid.uuid4()),
+                "event": event.get("event", ""),
+                "data": event.get("data", {}),
+            })
         except Exception as e:
             print(f"[acp_channel] Failed to publish event: {e}")
 
-    # ── Heartbeat to Registry ──
-
-    async def _heartbeat_loop(self):
-        """Send heartbeat to Registry every 30 seconds."""
-        while True:
-            await asyncio.sleep(30)
-            try:
-                async with httpx.AsyncClient() as client:
-                    await client.post(
-                        f"{self.registry_url}/modules",
-                        json={"action": "heartbeat", "module_id": "acp_channel"},
-                        headers={"Authorization": f"Bearer {self.token}"},
-                        timeout=5,
-                    )
-                print("[acp_channel] heartbeat sent")
-            except Exception:
-                pass
-
     # ── Test event loop ──
 
     async def _test_event_loop(self):

package/extensions/event_hub_bench/entry.py

@@ -1,6 +1,6 @@
 """
 Event Hub Benchmark module entry point.
-Discovers hub via Registry, runs benchmarks, saves results, exits.
+Connects to Kernel via WebSocket JSON-RPC 2.0, runs benchmarks, saves results, exits.
 """
 
 import asyncio
@@ -231,54 +231,10 @@ if module_data:
 _setup_exception_hooks()
 
 
-def _register_to_registry(client: httpx.Client, registry_url: str, token: str):
-    """Register module identity to Registry (events, metadata — no API endpoint)."""
-    payload = {
-        "action": "register",
-        "module_id": "event_hub_bench",
-        "module_type": "tool",
-        "name": "Event Hub Benchmark",
-    }
-    headers = {"Authorization": f"Bearer {token}"}
-    try:
-        resp = client.post(
-            f"{registry_url}/modules",
-            json=payload, headers=headers,
-        )
-        if resp.status_code == 200:
-            print(f"{TAG} Registered to Registry")
-        else:
-            print(f"{TAG} WARNING: Registry returned {resp.status_code}")
-    except Exception as e:
-        print(f"{TAG} WARNING: Registry registration failed: {e}")
-
-
-def _discover_hub(client: httpx.Client, registry_url: str, token: str, timeout: float = 30) -> str | None:
-    """Poll registry until event_hub is found. Returns ws:// URL or None."""
-    headers = {"Authorization": f"Bearer {token}"}
-    deadline = time.time() + timeout
-    while time.time() < deadline:
-        try:
-            resp = client.get(
-                f"{registry_url}/get/event_hub",
-                headers=headers,
-            )
-            if resp.status_code == 200:
-                info = resp.json()
-                ws_url = (info.get("metadata") or {}).get("ws_endpoint")
-                if ws_url:
-                    return ws_url
-        except Exception:
-            pass
-        time.sleep(0.2)
-    return None
-
-
-def _get_hub_stats(ws_url: str) -> dict:
-    """Fetch hub /stats via HTTP (derive from ws:// URL)."""
-    http_url = ws_url.replace("ws://", "http://").rsplit("/ws", 1)[0]
+def _get_kernel_stats(kernel_port: int) -> dict:
+    """Fetch Kernel /stats via HTTP."""
     try:
-        resp = httpx.get(f"{http_url}/stats", timeout=5)
+        resp = httpx.get(f"http://127.0.0.1:{kernel_port}/stats", timeout=5)
         if resp.status_code == 200:
             return resp.json()
     except Exception:
@@ -286,16 +242,14 @@ def _get_hub_stats(ws_url: str) -> dict:
     return {}
 
 
-def _sample_hub_resources(ws_url: str) -> dict:
-    """Sample hub process CPU/memory via psutil. Returns {} if unavailable."""
+def _sample_kernel_resources(kernel_port: int) -> dict:
+    """Sample Kernel process CPU/memory via psutil. Returns {} if unavailable."""
     try:
         import psutil
     except ImportError:
         return {"error": "psutil not installed"}
-    http_url = ws_url.replace("ws://", "http://").rsplit("/ws", 1)[0]
-    port = int(http_url.rsplit(":", 1)[1].split("/")[0])
     for conn in psutil.net_connections(kind="tcp"):
-        if conn.laddr.port == port and conn.status == "LISTEN":
+        if conn.laddr.port == kernel_port and conn.status == "LISTEN":
             try:
                 p = psutil.Process(conn.pid)
                 mem = p.memory_info()
@@ -308,13 +262,13 @@ def _sample_hub_resources(ws_url: str) -> dict:
                 }
             except Exception:
                 pass
-    return {"error": "hub process not found"}
+    return {"error": "kernel process not found"}
 
 
 # ── WebSocket client ──
 
 class WsClient:
-    """Lightweight async WebSocket client for hub benchmarks."""
+    """Lightweight async WebSocket client for Kernel benchmarks (JSON-RPC 2.0)."""
 
     def __init__(self, ws_url: str, token: str, client_id: str):
         self.url = f"{ws_url}?token={token}&id={client_id}"
@@ -325,16 +279,18 @@ class WsClient:
         self.ws = await websockets.connect(self.url, max_size=None)
 
     async def subscribe(self, patterns: list[str]):
-        await self.ws.send(json.dumps({"type": "subscribe", "events": patterns}))
+        msg = {"jsonrpc": "2.0", "id": str(uuid.uuid4()), "method": "event.subscribe", "params": {"events": patterns}}
+        await self.ws.send(json.dumps(msg))
 
     async def publish(self, event_type: str, data: dict) -> str:
         eid = str(uuid.uuid4())
-        await self.ws.send(json.dumps({
-            "type": "event", "event_id": eid, "event": event_type,
-            "source": self.id,
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "data": data,
-        }))
+        msg = {
+            "jsonrpc": "2.0", "id": str(uuid.uuid4()), "method": "event.publish",
+            "params": {
+                "event_id": eid, "event": event_type, "data": data,
+            },
+        }
+        await self.ws.send(json.dumps(msg))
         return eid
 
     async def recv(self, timeout=5.0):
@@ -351,9 +307,10 @@ class WsClient:
 # ── Benchmark runner ──
 
 class BenchRunner:
-    def __init__(self, ws_url: str, token: str):
+    def __init__(self, ws_url: str, token: str, kernel_port: int):
         self.ws_url = ws_url
         self.token = token
+        self.kernel_port = kernel_port
         self.results = {}
 
     async def _make_client(self, name: str) -> WsClient:
@@ -378,7 +335,9 @@ class BenchRunner:
             while not stop.is_set():
                 try:
                     raw = await asyncio.wait_for(sub.ws.recv(), timeout=0.5)
-                    if '"event"' in raw and '"ack"' not in raw:
+                    msg = json.loads(raw)
+                    # JSON-RPC Notification (event): has method, no id
+                    if "method" in msg and "id" not in msg:
                         recvd += 1
                 except Exception:
                     pass
@@ -393,7 +352,7 @@ class BenchRunner:
         recv_task = asyncio.create_task(_recv())
         ack_task = asyncio.create_task(_drain_acks())
 
-        hub_before = (_get_hub_stats(self.ws_url).get("counters") or {})
+        hub_before = (_get_kernel_stats(self.kernel_port).get("counters") or {})
 
         t0 = time.time()
         for i in range(n):
@@ -409,7 +368,7 @@ class BenchRunner:
         await recv_task
         ack_task.cancel()
 
-        hub_after = (_get_hub_stats(self.ws_url).get("counters") or {})
+        hub_after = (_get_kernel_stats(self.kernel_port).get("counters") or {})
 
         await pub.close()
         await sub.close()
@@ -440,9 +399,9 @@ class BenchRunner:
         for i in range(n):
             t0 = time.time()
             await pub.publish("bench.lat.test", {"i": i})
-            await pub.recv(timeout=2)  # ack
+            await pub.recv(timeout=2)  # RPC response
             msg = await sub.recv(timeout=2)
-            if msg and msg.get("type") == "event":
+            if msg and "method" in msg and "id" not in msg:
                 latencies.append((time.time() - t0) * 1000)
 
         await pub.close()
@@ -481,7 +440,8 @@ class BenchRunner:
                 while not stop.is_set():
                     try:
                         raw = await asyncio.wait_for(client.ws.recv(), timeout=0.5)
-                        if '"event"' in raw and '"ack"' not in raw:
+                        msg = json.loads(raw)
+                        if "method" in msg and "id" not in msg:
                             counts[idx] += 1
                     except Exception:
                         pass
@@ -527,13 +487,13 @@ class BenchRunner:
 
     # ── Save results ──
 
-    def save(self, ws_url: str):
+    def save(self):
         os.makedirs(RESULTS_DIR, exist_ok=True)
         now = datetime.now()
         filepath = os.path.join(RESULTS_DIR, now.strftime("%Y-%m-%d_%H-%M-%S") + ".json")
 
-        hub_stats = _get_hub_stats(ws_url)
-        resources = _sample_hub_resources(ws_url)
+        kernel_stats = _get_kernel_stats(self.kernel_port)
+        resources = _sample_kernel_resources(self.kernel_port)
 
         data = {
             "timestamp": now.isoformat(),
@@ -542,7 +502,7 @@ class BenchRunner:
                 "python": platform.python_version(),
             },
             "hub_resources": resources,
-            "hub_counters": hub_stats.get("counters", {}),
+            "hub_counters": kernel_stats.get("counters", {}),
             **self.results,
         }
         with open(filepath, "w", encoding="utf-8") as f:
@@ -551,45 +511,60 @@ class BenchRunner:
 
 
 def _send_ready_event(ws_url: str, token: str):
-    """Send module.ready to Event Hub. Startup phase complete."""
+    """Send module.ready to Kernel via JSON-RPC 2.0. Startup phase complete."""
     try:
         import websockets.sync.client as ws_sync
         url = f"{ws_url}?token={token}&id=event_hub_bench"
         with ws_sync.connect(url, close_timeout=3) as ws:
-            msg = {
-                "type": "event",
-                "event_id": str(uuid.uuid4()),
-                "event": "module.ready",
-                "source": "event_hub_bench",
-                "timestamp": datetime.now(timezone.utc).isoformat(),
-                "data": {"module_id": "event_hub_bench"},
-            }
-            ws.send(json.dumps(msg))
+            # Subscribe (先订阅)
+            ws.send(json.dumps({
+                "jsonrpc": "2.0", "id": str(uuid.uuid4()),
+                "method": "event.subscribe", "params": {"events": []},
+            }))
+            # Register (再注册)
+            ws.send(json.dumps({
+                "jsonrpc": "2.0", "id": str(uuid.uuid4()),
+                "method": "registry.register",
+                "params": {
+                    "module_id": "event_hub_bench",
+                    "module_type": "tool",
+                    "name": "Event Hub Benchmark",
+                },
+            }))
+            # Publish ready
+            ws.send(json.dumps({
+                "jsonrpc": "2.0", "id": str(uuid.uuid4()),
+                "method": "event.publish",
+                "params": {
+                    "event_id": str(uuid.uuid4()),
+                    "event": "module.ready",
+                    "data": {"module_id": "event_hub_bench"},
+                },
+            }))
             time.sleep(0.1)
     except Exception as e:
         print(f"{TAG} WARNING: Could not send module.ready: {e}")
 
 
 def _send_exiting_event(ws_url: str, token: str, reason: str):
-    """Send module.exiting event to Event Hub before exit. Best-effort, non-blocking."""
+    """Send module.exiting event to Kernel via JSON-RPC 2.0 before exit."""
     try:
         import websockets.sync.client as ws_sync
         url = f"{ws_url}?token={token}&id=event_hub_bench"
         with ws_sync.connect(url, close_timeout=3) as ws:
-            msg = {
-                "type": "event",
-                "event_id": str(uuid.uuid4()),
-                "event": "module.exiting",
-                "source": "event_hub_bench",
-                "timestamp": datetime.now(timezone.utc).isoformat(),
-                "data": {
-                    "module_id": "event_hub_bench",
-                    "reason": reason,
-                    "action": "none",
+            ws.send(json.dumps({
+                "jsonrpc": "2.0", "id": str(uuid.uuid4()),
+                "method": "event.publish",
+                "params": {
+                    "event_id": str(uuid.uuid4()),
+                    "event": "module.exiting",
+                    "data": {
+                        "module_id": "event_hub_bench",
+                        "reason": reason,
+                        "action": "none",
+                    },
                 },
-            }
-            ws.send(json.dumps(msg))
-            # Brief wait for delivery
+            }))
             time.sleep(0.3)
     except Exception as e:
         print(f"{TAG} WARNING: Could not send module.exiting: {e}")
@@ -597,12 +572,12 @@ def _send_exiting_event(ws_url: str, token: str, reason: str):
 
 # ── Entry point ──
 
-async def _run(ws_url: str, token: str):
-    bench = BenchRunner(ws_url, token)
+async def _run(ws_url: str, token: str, kernel_port: int):
+    bench = BenchRunner(ws_url, token, kernel_port)
     await bench.bench_throughput()
     await bench.bench_latency()
     await bench.bench_fanout()
-    bench.save(ws_url)
+    bench.save()
 
 
 def main():
@@ -617,29 +592,14 @@ def main():
         pass
 
     # Read registry_port from environment variable
-    registry_port = int(os.environ.get("KITE_REGISTRY_PORT", "0"))
-
-    if not token or not registry_port:
-        print(f"{TAG} ERROR: Missing token or KITE_REGISTRY_PORT")
-        sys.exit(1)
-
-    registry_url = f"http://127.0.0.1:{registry_port}"
-
-    client = httpx.Client(timeout=5)
-
-    # Register to Registry first (identity declaration)
-    _register_to_registry(client, registry_url, token)
-
-    print(f"{TAG} Discovering event_hub via registry...")
-
-    ws_url = _discover_hub(client, registry_url, token)
+    kernel_port = int(os.environ.get("KITE_KERNEL_PORT", "0"))
 
-    client.close()
-    if not ws_url:
-        print(f"{TAG} ERROR: event_hub not found")
+    if not token or not kernel_port:
+        print(f"{TAG} ERROR: Missing token or KITE_KERNEL_PORT")
         sys.exit(1)
 
-    print(f"{TAG} Hub found: {ws_url}")
+    ws_url = f"ws://127.0.0.1:{kernel_port}/ws"
+    print(f"{TAG} Kernel at port {kernel_port}")
 
     # Debug mode required: multiple benchmark clients share one token
     if os.environ.get("KITE_DEBUG") != "1":
@@ -653,7 +613,7 @@ def main():
     # ── Business logic: run benchmarks ──
     print(f"{TAG} Starting benchmarks...")
 
-    asyncio.run(_run(ws_url, token))
+    asyncio.run(_run(ws_url, token, kernel_port))
 
     print(f"{TAG} Benchmarks complete, sending exit intent...")
     _send_exiting_event(ws_url, token, "benchmarks complete")