langbot-plugin 0.6.6__tar.gz → 0.6.8__tar.gz

{langbot_plugin-0.6.6 → langbot_plugin-0.6.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: langbot-plugin
-Version: 0.6.6
+Version: 0.6.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.6.6 → langbot_plugin-0.6.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langbot-plugin"
-version = "0.6.6"
+version = "0.6.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.6.6 → langbot_plugin-0.6.8}/src/langbot_plugin/runtime/plugin/mgr.py

@@ -1997,7 +1997,6 @@ class PluginManager:
                 ):
                     await connection.close()
                     return
-                worker.plugin_handler = plugin_handler
                 self.plugin_handlers.append(plugin_handler)
                 try:
                     await plugin_handler.run()
@@ -2606,7 +2605,7 @@ class PluginManager:
                     raise ValueError(
                         "Shared plugin worker desired state is unavailable"
                     )
-                attach_tasks: list[asyncio.Task[None]] = []
+                attach_runtimes: list[PluginInstallationRuntime] = []
                 async with worker.lifecycle_lock:
                     if (
                         self._shared_workers.get(registration.shared_pool_digest)
@@ -2626,12 +2625,10 @@ class PluginManager:
                             )
                         ):
                             slot_runtime.plugin_handler = handler
-                            task = self._schedule_shared_slot_attach(slot_runtime)
-                            if task is not None:
-                                attach_tasks.append(task)
+                            attach_runtimes.append(slot_runtime)
                     worker.transport_registered_event.set()
-                if attach_tasks:
-                    await asyncio.gather(*attach_tasks, return_exceptions=True)
+                for slot_runtime in attach_runtimes:
+                    self._schedule_shared_slot_attach(slot_runtime)
                 self._refresh_shared_worker_ready(worker)
                 return
             if installation_binding is not None:

langbot_plugin-0.6.8/src/langbot_plugin/version.py

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

{langbot_plugin-0.6.6 → langbot_plugin-0.6.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.6.6"
-    assert source_version == '__version__ = "0.6.6"'
+    assert project["project"]["version"] == "0.6.8"
+    assert source_version == '__version__ = "0.6.8"'

{langbot_plugin-0.6.6 → langbot_plugin-0.6.8}/tests/runtime/plugin/test_installation_manager.py

@@ -144,7 +144,7 @@ async def _drain_plugin_tasks(manager: PluginManager) -> None:
             tasks = tuple(task for task in manager.plugin_run_tasks if not task.done())
             if not tasks:
                 return
-        await asyncio.gather(*tasks)
+        await asyncio.gather(*tasks, return_exceptions=True)
 
 
 async def test_manager_indexes_same_artifact_installations_by_complete_binding(
@@ -453,6 +453,7 @@ async def test_failed_sole_shared_slot_retries_with_registered_handler(
         container.model_dump(),
         registration_capability=capability,
     )
+    await _drain_plugin_tasks(manager)
 
     assert runtime.state == "failed"
     assert runtime.error_code == "slot_attach_failed"
@@ -556,6 +557,7 @@ async def test_failed_shared_slot_retry_keeps_healthy_sibling_and_worker(
         container.model_dump(),
         registration_capability=capability,
     )
+    await _drain_plugin_tasks(manager)
     healthy_container = runtime_a.plugin_container
 
     assert runtime_a.state == "running"
@@ -879,6 +881,8 @@ async def test_shared_registration_waits_for_validated_slot_before_running(
     )
     await asyncio.wait_for(validation_started.wait(), timeout=1)
 
+    assert registration.done()
+    assert registration.exception() is None
     assert runtime.state == "starting"
     assert runtime.plugin_container is None
     assert not runtime.ready_event.is_set()
@@ -886,6 +890,7 @@ async def test_shared_registration_waits_for_validated_slot_before_running(
 
     release_validation.set()
     await registration
+    await _drain_plugin_tasks(manager)
     assert runtime.state == "running"
     assert runtime.plugin_container is not None
     assert runtime.ready_event.is_set()
@@ -980,6 +985,7 @@ async def test_shared_registration_reports_mixed_slot_attach_results(
         base_container.model_dump(),
         registration_capability=capability,
     )
+    await _drain_plugin_tasks(manager)
 
     runtime_a = manager.installation_runtimes[binding_a]
     runtime_b = manager.installation_runtimes[binding_b]
@@ -1070,6 +1076,7 @@ async def test_shared_slot_uninitialized_container_is_failed(tmp_path, monkeypat
         container.model_dump(),
         registration_capability=capability,
     )
+    await _drain_plugin_tasks(manager)
 
     assert runtime.state == "failed"
     assert runtime.error_code == "slot_attach_failed"
@@ -2060,6 +2067,116 @@ async def test_installation_worker_ready_timeout_cancels_hung_process(
     assert cancelled.is_set()
 
 
+async def test_shared_connection_does_not_claim_registration_before_capability_validation(
+    tmp_path,
+    monkeypatch,
+):
+    _, manager = _manager(tmp_path)
+    package = _package()
+    digest = hashlib.sha256(package).hexdigest()
+    binding = _binding("installation-a", digest, workspace_uuid="workspace-a")
+    monkeypatch.setattr(
+        manager.worker_launcher,
+        "prepare_dependency_environment",
+        _prepare_environment,
+    )
+    monkeypatch.setattr(manager, "_schedule_shared_worker", lambda _worker: None)
+    await manager.apply_plugin_installation(
+        binding,
+        artifact_package=package,
+        execution_mode=PluginExecutionMode.SHARED_CERTIFIED,
+    )
+    worker = manager.installation_runtimes[binding].shared_worker
+    assert worker is not None
+
+    class FakeConnection:
+        async def close(self):
+            return None
+
+    class FakeHandler:
+        async def run(self):
+            await asyncio.Event().wait()
+
+    handler = FakeHandler()
+    callback_started = asyncio.Event()
+
+    class CapturingController:
+        process = None
+
+        async def run(self, callback):
+            task = asyncio.create_task(callback(FakeConnection()))
+            callback_started.set()
+            try:
+                await task
+            finally:
+                if not task.done():
+                    task.cancel()
+                    await asyncio.gather(task, return_exceptions=True)
+
+        async def close(self):
+            return None
+
+    monkeypatch.setattr(
+        manager.worker_launcher,
+        "create_shared_pool_controller",
+        lambda _spec: CapturingController(),
+    )
+    monkeypatch.setattr(
+        manager_module.runtime_plugin_handler_cls,
+        "PluginConnectionHandler",
+        lambda *args, **kwargs: handler,
+    )
+
+    launch = asyncio.create_task(manager._launch_shared_worker(worker))
+    await asyncio.wait_for(callback_started.wait(), timeout=1)
+    await asyncio.sleep(0)
+
+    assert worker.plugin_handler is None
+    assert handler in manager.plugin_handlers
+
+    launch.cancel()
+    await asyncio.gather(launch, return_exceptions=True)
+
+
+async def test_shared_registration_failure_does_not_clear_new_worker_handler(
+    tmp_path,
+    monkeypatch,
+):
+    _, manager = _manager(tmp_path)
+    package = _package()
+    digest = hashlib.sha256(package).hexdigest()
+    binding = _binding("installation-a", digest, workspace_uuid="workspace-a")
+    monkeypatch.setattr(
+        manager.worker_launcher,
+        "prepare_dependency_environment",
+        _prepare_environment,
+    )
+    monkeypatch.setattr(manager, "_schedule_shared_worker", lambda _worker: None)
+    await manager.apply_plugin_installation(
+        binding,
+        artifact_package=package,
+        execution_mode=PluginExecutionMode.SHARED_CERTIFIED,
+    )
+    worker = manager.installation_runtimes[binding].shared_worker
+    assert worker is not None
+
+    class OldHandler:
+        pass
+
+    class NewHandler:
+        pass
+
+    old_handler = OldHandler()
+    new_handler = NewHandler()
+    worker.plugin_handler = new_handler
+    manager.plugin_handlers.extend([old_handler, new_handler])
+
+    await manager.remove_plugin_handler(old_handler)
+
+    assert worker.plugin_handler is new_handler
+    assert new_handler in manager.plugin_handlers
+
+
 async def test_shared_worker_ready_timeout_cancels_hung_controller_and_records_failure(
     tmp_path,
     monkeypatch,

langbot_plugin-0.6.6/src/langbot_plugin/version.py

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