langbot-plugin 0.7.6__tar.gz → 0.7.8__tar.gz

{langbot_plugin-0.7.6 → langbot_plugin-0.7.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: langbot-plugin
-Version: 0.7.6
+Version: 0.7.8
 Summary: This package contains the SDK, CLI for building plugins for LangBot, plus the runtime for hosting LangBot plugins
 Project-URL: Homepage, https://langbot.app
 Project-URL: Repository, https://github.com/langbot-app/langbot-plugin-sdk

{langbot_plugin-0.7.6 → langbot_plugin-0.7.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langbot-plugin"
-version = "0.7.6"
+version = "0.7.8"
 description = "This package contains the SDK, CLI for building plugins for LangBot, plus the runtime for hosting LangBot plugins"
 readme = "README.md"
 authors = [

{langbot_plugin-0.7.6 → langbot_plugin-0.7.8}/src/langbot_plugin/runtime/app.py

@@ -23,6 +23,8 @@ from langbot_plugin.runtime.bounded_executor import (
     configure_bounded_default_executor_from_env,
 )
 from langbot_plugin.runtime.event_loop_monitor import EventLoopLagMonitor
+from langbot_plugin.runtime import ops_metrics as ops_metrics_module
+from langbot_plugin.version import __version__ as runtime_version
 
 from langbot_plugin.runtime.security import (
     PLUGIN_DEBUG_KEY_HEADER,
@@ -110,8 +112,18 @@ class RuntimeApplication:
     def _health_snapshot(self) -> dict[str, object]:
         """Return public aggregate health without credentials or tenant IDs."""
 
+        ops_metrics = getattr(self.context.plugin_mgr, "ops_metrics", None)
+        process = ops_metrics_module.sample_process_resources() if ops_metrics else {}
+        runtime: dict[str, object] = {
+            "version": runtime_version,
+            "profile": self.context.runtime_profile or "unknown",
+        }
+        if ops_metrics is not None:
+            runtime["uptime_seconds"] = ops_metrics.uptime_seconds
+        runtime.update(process)
         return {
             "live": not self._closing,
+            "runtime": runtime,
             "resources": self.context.get_runtime_resource_stats(),
         }
 

{langbot_plugin-0.7.6 → langbot_plugin-0.7.8}/src/langbot_plugin/runtime/context.py

@@ -61,7 +61,12 @@ class RuntimeContext:
         self.workspace_debug_tokens = WorkspaceDebugTokenStore()
 
     def get_runtime_resource_stats(self) -> dict[str, Any]:
-        """Return aggregate O(1) counters safe for public health probes."""
+        """Return aggregate O(1) counters safe for public health probes.
+
+        The Cloud ops dashboard and the soak gate poll this payload, so every
+        value stays process-wide: no installation UUID, Workspace UUID, plugin
+        identity or artifact digest is ever reported here.
+        """
 
         plugin_manager = self.plugin_mgr
         handlers = getattr(
@@ -75,11 +80,91 @@ class RuntimeContext:
             "starting": 0,
             "failed": 0,
             "disabled": 0,
+            # Unknown lifecycle states are counted instead of dropped, so a new
+            # state can never silently disappear from the health payload.
+            "other": 0,
         }
+        installations_by_mode: dict[str, int] = {}
         for runtime in getattr(plugin_manager, "_installations", {}).values():
             state = str(getattr(runtime, "state", "disabled"))
-            if state in installation_state_counts:
-                installation_state_counts[state] += 1
+            installation_state_counts[
+                state if state in installation_state_counts else "other"
+            ] += 1
+            execution_mode = getattr(
+                getattr(runtime, "execution_mode", None),
+                "value",
+                None,
+            )
+            mode_key = str(execution_mode or "dedicated")
+            installations_by_mode[mode_key] = installations_by_mode.get(mode_key, 0) + 1
+
+        shared_workers = getattr(plugin_manager, "_shared_workers", {})
+        shared_ready = 0
+        shared_draining = 0
+        shared_slots = 0
+        for worker in shared_workers.values():
+            worker_slots = getattr(worker, "slots", {})
+            shared_slots += len(worker_slots)
+            ready_event = getattr(worker, "ready_event", None)
+            if ready_event is not None and ready_event.is_set():
+                shared_ready += 1
+            if getattr(worker, "draining", False):
+                shared_draining += 1
+
+        ops_metrics = getattr(plugin_manager, "ops_metrics", None)
+        worker_policy = self.worker_policy
+        shared_pool: dict[str, Any] = {
+            "workers": len(shared_workers),
+            "capacity": (
+                int(getattr(worker_policy, "max_workers", 0)) if worker_policy else 0
+            ),
+            "ready": shared_ready,
+            "draining": shared_draining,
+            "slots": shared_slots,
+        }
+        if ops_metrics is not None:
+            counters = ops_metrics.snapshot()
+            shared_pool.update(
+                {
+                    "processes_started_total": counters[
+                        "shared_worker_processes_started_total"
+                    ],
+                    "registrations_total": counters[
+                        "shared_worker_registrations_total"
+                    ],
+                    "launch_failures_total": counters[
+                        "shared_worker_launch_failures_total"
+                    ],
+                    "transport_timeouts_total": counters[
+                        "shared_worker_transport_timeouts_total"
+                    ],
+                    "capacity_rejections_total": counters[
+                        "shared_worker_capacity_rejections_total"
+                    ],
+                    "stops_total": counters["shared_worker_stops_total"],
+                    "slot_attach_total": counters["shared_slot_attach_total"],
+                    "slot_attach_success_total": counters[
+                        "shared_slot_attach_success_total"
+                    ],
+                    "slot_attach_failures_total": counters[
+                        "shared_slot_attach_failures_total"
+                    ],
+                    "slot_attach_timeouts_total": counters[
+                        "shared_slot_attach_timeouts_total"
+                    ],
+                    "slot_detach_total": counters["shared_slot_detach_total"],
+                }
+            )
+
+        # Expired registration capabilities are pruned before counting, so the
+        # gauge reflects capabilities that can still be redeemed.
+        prune_registrations = getattr(
+            plugin_manager,
+            "_prune_expired_registration_capabilities",
+            None,
+        )
+        if callable(prune_registrations):
+            prune_registrations()
 
         return {
             "event_loop": (
@@ -96,6 +181,38 @@ class RuntimeContext:
             ),
             "installation_runtimes": len(getattr(plugin_manager, "_installations", ())),
             "installation_states": installation_state_counts,
+            "installations_by_mode": installations_by_mode,
+            "installation_watermarks": len(
+                getattr(self, "_installation_watermarks", {})
+            ),
+            "shared_pool": shared_pool,
+            "dependency_environment": (
+                {
+                    "cache_hits_total": ops_metrics.dependency_cache_hits_total,
+                    "misses_total": ops_metrics.dependency_cache_misses_total,
+                    "failures_total": ops_metrics.dependency_prepare_failures_total,
+                    "prepare_seconds_total": (
+                        ops_metrics.dependency_prepare_seconds_total
+                    ),
+                    "prepare_seconds_last": ops_metrics.dependency_prepare_seconds_last,
+                }
+                if ops_metrics is not None
+                else {}
+            ),
+            "restart_backoff": (
+                {
+                    "shared_current_seconds": ops_metrics.shared_backoff_current_seconds,
+                    "shared_total_seconds": ops_metrics.shared_backoff_total_seconds,
+                    "dedicated_current_seconds": (
+                        ops_metrics.dedicated_backoff_current_seconds
+                    ),
+                    "dedicated_total_seconds": (
+                        ops_metrics.dedicated_backoff_total_seconds
+                    ),
+                }
+                if ops_metrics is not None
+                else {}
+            ),
             "pending_registrations": len(
                 getattr(plugin_manager, "_pending_registrations", ())
             ),

langbot_plugin-0.7.8/src/langbot_plugin/runtime/ops_metrics.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+import os
+import time
+from typing import Any
+
+
+def sample_process_resources() -> dict[str, int | float]:
+    """Return this process' pid, RSS and CPU time, or ``{}`` off Linux.
+
+    ``/proc`` is read on demand: the probe endpoint is polled by the Cloud ops
+    dashboard and by the soak gate, so sampling stays out of the hot path and no
+    background task is added.
+    """
+
+    if not hasattr(os, "sysconf"):
+        return {}
+
+    try:
+        with open("/proc/self/statm", "r", encoding="ascii") as handle:
+            resident_pages = int(handle.read().split()[1])
+        page_size = int(os.sysconf("SC_PAGE_SIZE"))
+    except (OSError, ValueError, IndexError):
+        return {}
+
+    snapshot: dict[str, int | float] = {
+        "pid": os.getpid(),
+        "rss_bytes": resident_pages * page_size,
+    }
+    try:
+        with open("/proc/self/stat", "rb") as handle:
+            raw = handle.read()
+        # ``comm`` may contain spaces and parentheses, so only the fields after
+        # the final ')' are positional: utime/stime are fields 14 and 15.
+        tail = raw[raw.rindex(b")") + 2 :].split()
+        clock_ticks = int(os.sysconf("SC_CLK_TCK"))
+        snapshot["cpu_seconds"] = (int(tail[11]) + int(tail[12])) / clock_ticks
+    except (OSError, ValueError, IndexError):
+        pass
+    return snapshot
+
+
+class RuntimeOpsMetrics:
+    """Process-lifetime counters for the Cloud Plugin Runtime ops dashboard.
+
+    Every value is an aggregate over the whole Runtime process. No
+    installation UUID, Workspace UUID, plugin identity or artifact digest is
+    ever recorded here, which keeps the payload safe for the unauthenticated
+    ``/healthz`` probe that the Cloud ops dashboard and the soak gate poll.
+
+    Counters are incremented on lifecycle paths that already exist; nothing in
+    this module starts a task, timer, or background sampler.
+    """
+
+    __slots__ = (
+        "started_at",
+        "shared_processes_started_total",
+        "shared_registrations_total",
+        "shared_launch_failures_total",
+        "shared_transport_timeouts_total",
+        "shared_capacity_rejections_total",
+        "shared_stops_total",
+        "shared_slot_attach_total",
+        "shared_slot_attach_success_total",
+        "shared_slot_attach_failures_total",
+        "shared_slot_attach_timeouts_total",
+        "shared_slot_detach_total",
+        "shared_backoff_current_seconds",
+        "shared_backoff_total_seconds",
+        "dedicated_backoff_current_seconds",
+        "dedicated_backoff_total_seconds",
+        "dependency_cache_hits_total",
+        "dependency_cache_misses_total",
+        "dependency_prepare_failures_total",
+        "dependency_prepare_seconds_total",
+        "dependency_prepare_seconds_last",
+    )
+
+    def __init__(self) -> None:
+        self.started_at = time.monotonic()
+        self.shared_processes_started_total = 0
+        self.shared_registrations_total = 0
+        self.shared_launch_failures_total = 0
+        self.shared_transport_timeouts_total = 0
+        self.shared_capacity_rejections_total = 0
+        self.shared_stops_total = 0
+        self.shared_slot_attach_total = 0
+        self.shared_slot_attach_success_total = 0
+        self.shared_slot_attach_failures_total = 0
+        self.shared_slot_attach_timeouts_total = 0
+        self.shared_slot_detach_total = 0
+        self.shared_backoff_current_seconds = 0.0
+        self.shared_backoff_total_seconds = 0.0
+        self.dedicated_backoff_current_seconds = 0.0
+        self.dedicated_backoff_total_seconds = 0.0
+        self.dependency_cache_hits_total = 0
+        self.dependency_cache_misses_total = 0
+        self.dependency_prepare_failures_total = 0
+        self.dependency_prepare_seconds_total = 0.0
+        self.dependency_prepare_seconds_last = 0.0
+
+    @property
+    def uptime_seconds(self) -> float:
+        return max(time.monotonic() - self.started_at, 0.0)
+
+    def record_shared_backoff(self, delay_seconds: float) -> None:
+        """Record one shared-worker restart delay before it is slept off."""
+
+        delay = max(float(delay_seconds), 0.0)
+        self.shared_backoff_current_seconds = delay
+        self.shared_backoff_total_seconds += delay
+
+    def record_dedicated_backoff(self, delay_seconds: float) -> None:
+        """Record one dedicated-worker restart delay before it is slept off."""
+
+        delay = max(float(delay_seconds), 0.0)
+        self.dedicated_backoff_current_seconds = delay
+        self.dedicated_backoff_total_seconds += delay
+
+    def clear_shared_backoff(self) -> None:
+        self.shared_backoff_current_seconds = 0.0
+
+    def clear_dedicated_backoff(self) -> None:
+        self.dedicated_backoff_current_seconds = 0.0
+
+    def snapshot(self) -> dict[str, Any]:
+        """Return identity-free counters and gauges."""
+
+        return {
+            "started_at_monotonic": self.started_at,
+            "uptime_seconds": self.uptime_seconds,
+            "shared_worker_processes_started_total": (
+                self.shared_processes_started_total
+            ),
+            "shared_worker_registrations_total": self.shared_registrations_total,
+            "shared_worker_launch_failures_total": self.shared_launch_failures_total,
+            "shared_worker_transport_timeouts_total": (
+                self.shared_transport_timeouts_total
+            ),
+            "shared_worker_capacity_rejections_total": (
+                self.shared_capacity_rejections_total
+            ),
+            "shared_worker_stops_total": self.shared_stops_total,
+            "shared_slot_attach_total": self.shared_slot_attach_total,
+            "shared_slot_attach_success_total": self.shared_slot_attach_success_total,
+            "shared_slot_attach_failures_total": (
+                self.shared_slot_attach_failures_total
+            ),
+            "shared_slot_attach_timeouts_total": (
+                self.shared_slot_attach_timeouts_total
+            ),
+            "shared_slot_detach_total": self.shared_slot_detach_total,
+            "shared_backoff_current_seconds": self.shared_backoff_current_seconds,
+            "shared_backoff_total_seconds": self.shared_backoff_total_seconds,
+            "dedicated_backoff_current_seconds": self.dedicated_backoff_current_seconds,
+            "dedicated_backoff_total_seconds": self.dedicated_backoff_total_seconds,
+            "dependency_environment_cache_hits_total": (
+                self.dependency_cache_hits_total
+            ),
+            "dependency_environment_cache_misses_total": (
+                self.dependency_cache_misses_total
+            ),
+            "dependency_environment_prepare_failures_total": (
+                self.dependency_prepare_failures_total
+            ),
+            "dependency_environment_prepare_seconds_total": (
+                self.dependency_prepare_seconds_total
+            ),
+            "dependency_environment_prepare_seconds_last": (
+                self.dependency_prepare_seconds_last
+            ),
+        }

{langbot_plugin-0.7.6 → langbot_plugin-0.7.8}/src/langbot_plugin/runtime/plugin/dependency_environment.py

@@ -10,6 +10,8 @@ import re
 import shutil
 import stat
 import tempfile
+import time
+import typing
 import weakref
 from collections.abc import Awaitable, Callable, Iterator, Sequence
 from dataclasses import dataclass
@@ -120,9 +122,15 @@ DependencyInstaller = Callable[
 class PluginDependencyEnvironmentStore:
     """Atomically prepare and publish immutable per-artifact dependency trees."""
 
-    def __init__(self, base_path: str | os.PathLike = "data/plugin-runtime"):
+    def __init__(
+        self,
+        base_path: str | os.PathLike = "data/plugin-runtime",
+        *,
+        metrics: typing.Any | None = None,
+    ):
         self.base_path = pathlib.Path(base_path)
         self.environments_path = self.base_path / "environments" / "sha256"
+        self.metrics = metrics
         self._prepare_locks: weakref.WeakValueDictionary[str, asyncio.Lock] = (
             weakref.WeakValueDictionary()
         )
@@ -152,20 +160,42 @@ class PluginDependencyEnvironmentStore:
 
         ready = self.get_ready(digest, expected=expected)
         if ready is not None:
+            self._record_cache_hit()
             return ready
 
         lock = self._prepare_locks.setdefault(digest, asyncio.Lock())
         async with lock:
             ready = self.get_ready(digest, expected=expected)
             if ready is not None:
+                self._record_cache_hit()
                 return ready
-            return await self._prepare_locked(
-                artifact,
-                digest=digest,
-                expected=expected,
-                requirements=requirements,
-                installer=installer,
-            )
+            self._record_cache_miss()
+            started_at = time.monotonic()
+            try:
+                return await self._prepare_locked(
+                    artifact,
+                    digest=digest,
+                    expected=expected,
+                    requirements=requirements,
+                    installer=installer,
+                )
+            except BaseException:
+                if self.metrics is not None:
+                    self.metrics.dependency_prepare_failures_total += 1
+                raise
+            finally:
+                elapsed = max(time.monotonic() - started_at, 0.0)
+                if self.metrics is not None:
+                    self.metrics.dependency_prepare_seconds_total += elapsed
+                    self.metrics.dependency_prepare_seconds_last = elapsed
+
+    def _record_cache_hit(self) -> None:
+        if self.metrics is not None:
+            self.metrics.dependency_cache_hits_total += 1
+
+    def _record_cache_miss(self) -> None:
+        if self.metrics is not None:
+            self.metrics.dependency_cache_misses_total += 1
 
     def get_ready(
         self,

{langbot_plugin-0.7.6 → langbot_plugin-0.7.8}/src/langbot_plugin/runtime/plugin/mgr.py

@@ -32,6 +32,7 @@ from langbot_plugin.runtime.plugin import container as runtime_plugin_container
 from langbot_plugin.runtime.io.handlers import plugin as runtime_plugin_handler_cls
 from langbot_plugin.runtime import context as context_module
 from langbot_plugin.runtime import bounded_executor
+from langbot_plugin.runtime import ops_metrics as ops_metrics_module
 from langbot_plugin.api.entities.context import EventContext
 from langbot_plugin.api.definition.components.manifest import ComponentManifest
 from langbot_plugin.api.definition.components.tool.tool import Tool
@@ -250,8 +251,10 @@ class PluginManager:
         self._reconcile_operation_lock = asyncio.Lock()
         self._installation_lifecycle_limiter: asyncio.Semaphore | None = None
         self.artifact_store = PluginArtifactStore()
+        self.ops_metrics = ops_metrics_module.RuntimeOpsMetrics()
         self.dependency_environment_store = PluginDependencyEnvironmentStore(
-            self.artifact_store.base_path
+            self.artifact_store.base_path,
+            metrics=self.ops_metrics,
         )
         self.worker_launcher = PluginWorkerLauncher()
         self.restart_coordinator = PluginRestartCoordinator()
@@ -1099,7 +1102,10 @@ class PluginManager:
                     # construction; dependency state must follow that same
                     # Runtime-owned volume.
                     self.dependency_environment_store = (
-                        PluginDependencyEnvironmentStore(self.artifact_store.base_path)
+                        PluginDependencyEnvironmentStore(
+                            self.artifact_store.base_path,
+                            metrics=self.ops_metrics,
+                        )
                     )
                 try:
                     current.dependency_environment = (
@@ -1379,6 +1385,7 @@ class PluginManager:
             if policy is None:
                 raise ValueError("Plugin worker policy is unavailable")
             if len(self._shared_workers) >= policy.max_workers:
+                self.ops_metrics.shared_capacity_rejections_total += 1
                 raise RuntimeError("Shared plugin worker capacity reached")
             worker = SharedPluginWorkerRuntime(
                 artifact=runtime.artifact,
@@ -1451,6 +1458,7 @@ class PluginManager:
                     await permit.abandon()
                 raise
             except Exception as exc:
+                self.ops_metrics.shared_launch_failures_total += 1
                 self._record_shared_worker_failure(worker, exc)
                 logger.exception("Shared plugin worker failed: %s", digest)
             if (
@@ -1466,7 +1474,10 @@ class PluginManager:
             if uptime >= _PLUGIN_STABLE_WINDOW_SEC:
                 delay = _PLUGIN_RESTART_INITIAL_DELAY_SEC
             worker.ready_event.clear()
-            await asyncio.sleep(delay * random.uniform(0.8, 1.2))
+            restart_delay = delay * random.uniform(0.8, 1.2)
+            self.ops_metrics.record_shared_backoff(restart_delay)
+            await asyncio.sleep(restart_delay)
+            self.ops_metrics.clear_shared_backoff()
             delay = min(delay * 2, _PLUGIN_RESTART_MAX_DELAY_SEC)
 
     async def _run_shared_worker_attempt(
@@ -1493,6 +1504,7 @@ class PluginManager:
                     raise RuntimeError(
                         "Shared plugin worker exited before registration"
                     )
+                self.ops_metrics.shared_transport_timeouts_total += 1
                 raise TimeoutError(
                     "Shared plugin worker did not register within "
                     f"{_SHARED_TRANSPORT_READY_TIMEOUT_SEC:.0f} seconds"
@@ -1571,6 +1583,7 @@ class PluginManager:
         task = asyncio.create_task(self._initialize_shared_slot(runtime, handler))
         worker.attach_tasks[runtime.binding] = task
         self.plugin_run_tasks.append(task)
+        self.ops_metrics.shared_slot_attach_total += 1
 
         def attach_done(completed: asyncio.Task[None]) -> None:
             if worker.attach_tasks.get(runtime.binding) is completed:
@@ -1597,6 +1610,7 @@ class PluginManager:
                     runtime.state = "failed"
                     runtime.error_code = "slot_attach_failed"
                     runtime.error_message = str(exc) or type(exc).__name__
+                self.ops_metrics.shared_slot_attach_failures_total += 1
                 logger.error(
                     "Shared plugin slot attach failed: %s",
                     runtime.binding.installation_uuid,
@@ -1626,6 +1640,7 @@ class PluginManager:
                     timeout=_SHARED_SLOT_ATTACH_TIMEOUT_SEC,
                 )
         except TimeoutError as exc:
+            self.ops_metrics.shared_slot_attach_timeouts_total += 1
             raise TimeoutError(
                 "Shared plugin slot did not initialize within "
                 f"{_SHARED_SLOT_ATTACH_TIMEOUT_SEC:.0f} seconds"
@@ -1715,6 +1730,7 @@ class PluginManager:
         runtime.error_code = None
         runtime.error_message = None
         runtime.ready_event.set()
+        self.ops_metrics.shared_slot_attach_success_total += 1
 
     async def _detach_shared_worker_slot(
         self,
@@ -1733,6 +1749,7 @@ class PluginManager:
                 with contextlib.suppress(Exception):
                     await handler.detach_plugin_slot(runtime.binding)
             worker.slots.pop(runtime.binding, None)
+            self.ops_metrics.shared_slot_detach_total += 1
             if handler is not None:
                 handler.set_shared_pool_bindings(worker.artifact.digest, worker.slots)
             runtime.shared_worker = None
@@ -1752,6 +1769,7 @@ class PluginManager:
                         self._shared_workers.pop(worker.artifact.digest, None)
 
     async def _stop_shared_worker(self, worker: SharedPluginWorkerRuntime) -> None:
+        self.ops_metrics.shared_stops_total += 1
         handler = worker.plugin_handler
         if handler is not None:
             handler.cancel_inflight_messages()
@@ -1883,7 +1901,9 @@ class PluginManager:
                 binding.installation_uuid,
                 restart_delay,
             )
+            self.ops_metrics.record_dedicated_backoff(restart_delay)
             await asyncio.sleep(restart_delay)
+            self.ops_metrics.clear_dedicated_backoff()
             delay = min(delay * 2, _PLUGIN_RESTART_MAX_DELAY_SEC)
             attempt_number += 1
 
@@ -2017,6 +2037,7 @@ class PluginManager:
                     dependency_environment=worker.dependency_environment,
                 )
             )
+            self.ops_metrics.shared_processes_started_total += 1
             worker.controller = controller
 
             async def new_plugin_connection_callback(connection: Connection):
@@ -2700,6 +2721,7 @@ class PluginManager:
                 # take the lifecycle lock separately and revalidate identity.
                 worker.pending_plugin_handler = None
                 worker.plugin_handler = handler
+                self.ops_metrics.shared_registrations_total += 1
                 attach_runtimes = []
                 for slot_runtime in tuple(worker.slots.values()):
                     if (

langbot_plugin-0.7.8/src/langbot_plugin/version.py

@@ -0,0 +1 @@
+__version__ = "0.7.7"

{langbot_plugin-0.7.6 → langbot_plugin-0.7.8}/tests/packaging/test_release_metadata.py

@@ -11,5 +11,5 @@ def test_stable_release_metadata_is_consistent() -> None:
         (root / "src/langbot_plugin/version.py").read_text(encoding="utf-8").strip()
     )
 
-    assert project["project"]["version"] == "0.7.6"
-    assert source_version == '__version__ = "0.7.6"'
+    assert project["project"]["version"] == "0.7.7"
+    assert source_version == '__version__ = "0.7.7"'

{langbot_plugin-0.7.6 → langbot_plugin-0.7.8}/tests/runtime/io/handlers/test_control_handler.py

@@ -450,21 +450,18 @@ async def test_control_handler_get_debug_info_returns_workspace_token():
     assert len(response["data"]["plugin_debug_key"]) >= 32
     assert response["data"]["expires_at"].endswith("Z")
     assert response["data"]["ws_debug_port"] == 5401
-    assert response["data"]["resources"] == {
-        "event_loop": {},
-        "blocking_executor": {},
-        "plugin_handlers": 0,
-        "legacy_supervisors": 0,
-        "installation_runtimes": 0,
-        "installation_states": {
-            "running": 0,
-            "starting": 0,
-            "failed": 0,
-            "disabled": 0,
-        },
-        "pending_registrations": 0,
-        "restart_coordinator": {"configured": False},
+    resources = response["data"]["resources"]
+    assert resources["installation_states"] == {
+        "running": 0,
+        "starting": 0,
+        "failed": 0,
+        "disabled": 0,
+        "other": 0,
     }
+    assert resources["shared_pool"]["workers"] == 0
+    assert resources["shared_pool"]["slots"] == 0
+    assert resources["restart_coordinator"] == {"configured": False}
+    assert "workspace-a" not in str(resources)
 
 
 async def test_control_handler_rejects_tenant_action_without_complete_binding():