langbot-plugin 0.4.3__tar.gz → 0.4.4__tar.gz

{langbot_plugin-0.4.3 → langbot_plugin-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langbot-plugin
-Version: 0.4.3
+Version: 0.4.4
 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.4.3 → langbot_plugin-0.4.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langbot-plugin"
-version = "0.4.3"
+version = "0.4.4"
 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.4.3 → langbot_plugin-0.4.4}/src/langbot_plugin/api/proxies/langbot_api.py

@@ -284,6 +284,43 @@ class LangBotAPIProxy:
             )
         )["vectors"]
 
+    async def invoke_rerank(
+        self,
+        rerank_model_uuid: str,
+        query: str,
+        documents: list[str],
+        top_k: int | None = None,
+        extra_args: dict[str, Any] | None = None,
+        timeout: float = 60.0,
+    ) -> list[dict[str, Any]]:
+        """Rerank documents using Host's rerank model.
+
+        Args:
+            rerank_model_uuid: The UUID of the rerank model to use.
+            query: Query text used to score document relevance.
+            documents: Candidate document texts to rerank.
+            top_k: Optional number of scored results to return.
+            extra_args: Optional provider-specific arguments.
+            timeout: Request timeout in seconds.
+
+        Returns:
+            List of score dicts, usually containing ``index`` and
+            ``relevance_score``.
+        """
+        return (
+            await self.plugin_runtime_handler.call_action(
+                PluginToRuntimeAction.INVOKE_RERANK,
+                {
+                    "rerank_model_uuid": rerank_model_uuid,
+                    "query": query,
+                    "documents": documents,
+                    "top_k": top_k,
+                    "extra_args": extra_args or {},
+                },
+                timeout=timeout,
+            )
+        )["results"]
+
     async def vector_upsert(
         self,
         collection_id: str,

{langbot_plugin-0.4.3 → langbot_plugin-0.4.4}/src/langbot_plugin/entities/io/actions/enums.py

@@ -61,6 +61,7 @@ class PluginToRuntimeAction(ActionType):
     CALL_TOOL = "call_tool"
 
     INVOKE_EMBEDDING = "invoke_embedding"
+    INVOKE_RERANK = "invoke_rerank"
     VECTOR_UPSERT = "vector_upsert"
     VECTOR_SEARCH = "vector_search"
     VECTOR_DELETE = "vector_delete"
@@ -111,6 +112,7 @@ class LangBotToRuntimeAction(ActionType):
     GET_PLUGIN_INFO = "get_plugin_info"
     GET_PLUGIN_ICON = "get_plugin_icon"
     GET_PLUGIN_README = "get_plugin_readme"
+    GET_PLUGIN_LOGS = "get_plugin_logs"
     GET_PLUGIN_ASSETS_FILE = "get_plugin_assets_file"
     INSTALL_PLUGIN = "install_plugin"
     RESTART_PLUGIN = "restart_plugin"

{langbot_plugin-0.4.3 → langbot_plugin-0.4.4}/src/langbot_plugin/runtime/io/controllers/stdio/client.py

@@ -34,6 +34,9 @@ class StdioClientController(Controller):
             *self.args,
             stdin=asyncio.subprocess.PIPE,
             stdout=asyncio.subprocess.PIPE,
+            # Capture stderr (where the plugin's Python `logging` output goes)
+            # so the runtime can buffer per-plugin logs for the detail page.
+            stderr=asyncio.subprocess.PIPE,
             env=self.env,
             cwd=self.working_dir,
         )

{langbot_plugin-0.4.3 → langbot_plugin-0.4.4}/src/langbot_plugin/runtime/io/handlers/control.py

@@ -106,6 +106,17 @@ class ControlConnectionHandler(handler.Handler):
             else:
                 return handler.ActionResponse.success({"readme_file_key": None})
 
+        @self.action(LangBotToRuntimeAction.GET_PLUGIN_LOGS)
+        async def get_plugin_logs(data: dict[str, Any]) -> handler.ActionResponse:
+            author = data["plugin_author"]
+            plugin_name = data["plugin_name"]
+            limit = int(data.get("limit", 200))
+            level = data.get("level") or None
+            logs = await self.context.plugin_mgr.get_plugin_logs(
+                author, plugin_name, limit=limit, level=level
+            )
+            return handler.ActionResponse.success({"logs": logs})
+
         @self.action(LangBotToRuntimeAction.GET_PLUGIN_ASSETS_FILE)
         async def get_plugin_assets_file(
             data: dict[str, Any],

{langbot_plugin-0.4.3 → langbot_plugin-0.4.4}/src/langbot_plugin/runtime/io/handlers/plugin.py

@@ -13,6 +13,7 @@ from langbot_plugin.entities.io.actions.enums import (
 from langbot_plugin.runtime import context as context_module
 import asyncio
 from langbot_plugin.runtime.settings import settings as runtime_settings
+from langbot_plugin.runtime.plugin.logbuffer import PluginLogBuffer
 
 logger = logging.getLogger(__name__)
 
@@ -31,6 +32,9 @@ class PluginConnectionHandler(handler.Handler):
     stdio_process: asyncio.subprocess.Process | None = None
     """The stdio process of the plugin."""
 
+    log_buffer: PluginLogBuffer
+    """Ring buffer holding recent log lines (from the plugin's stderr)."""
+
     subprocess_on_windows_task: asyncio.Task | None = None
     """The task for the subprocess on Windows."""
 
@@ -59,6 +63,15 @@ class PluginConnectionHandler(handler.Handler):
         self.debug_plugin = debug_plugin
         self.stdio_process = stdio_process
 
+        # Capture the plugin subprocess's stderr (Python `logging` output) into
+        # a per-plugin ring buffer so LangBot can show logs on the detail page.
+        self.log_buffer = PluginLogBuffer()
+        if (
+            self.stdio_process is not None
+            and self.stdio_process.stderr is not None
+        ):
+            self.log_buffer.start_reader(self.stdio_process.stderr)
+
         @self.action(PluginToRuntimeAction.REGISTER_PLUGIN)
         async def register_plugin(data: dict[str, Any]) -> handler.ActionResponse:
 
@@ -232,6 +245,17 @@ class PluginConnectionHandler(handler.Handler):
             )
             return handler.ActionResponse.success(result)
 
+        @self.action(PluginToRuntimeAction.INVOKE_RERANK)
+        async def invoke_rerank(data: dict[str, Any]) -> handler.ActionResponse:
+            result = await self.context.control_handler.call_action(
+                PluginToRuntimeAction.INVOKE_RERANK,
+                {
+                    **data,
+                },
+                timeout=60,
+            )
+            return handler.ActionResponse.success(result)
+
         # ================= RAG Capability Handlers (Plugin -> Runtime -> Host) =================
 
         async def _proxy_rag_action(

langbot_plugin-0.4.4/src/langbot_plugin/runtime/plugin/logbuffer.py

@@ -0,0 +1,125 @@
+# Plugin log buffer: captures a plugin subprocess's stderr (where Python
+# `logging` output is emitted) into a bounded in-memory ring buffer so that
+# LangBot can display per-plugin logs on the plugin detail page.
+
+from __future__ import annotations
+
+import asyncio
+import collections
+import logging
+import re
+import time
+import typing
+
+logger = logging.getLogger(__name__)
+
+# Matches the standard SDK log line produced by
+# `langbot_plugin.utils.log.configure_process_logging`, e.g.:
+#   [06-13 10:30:00.123] main.py (45) - [INFO] : This is an info message
+# We only need the level here; the rest is kept verbatim as the message text.
+_LEVEL_RE = re.compile(r"^\[[^\]]+\]\s.*?-\s\[(?P<level>[A-Z]+)\]\s:\s")
+
+# Known logging level names, used to validate the parsed token.
+_KNOWN_LEVELS = {"DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"}
+
+# Default ring-buffer capacity (number of log lines retained per plugin).
+DEFAULT_MAX_LINES = 1000
+
+
+class PluginLogBuffer:
+    """A bounded ring buffer holding recent log lines for a single plugin.
+
+    Each entry is a dict: {"ts": float, "level": str, "text": str}.
+    `level` is best-effort parsed from the line; continuation lines (e.g.
+    multi-line tracebacks) inherit the previous entry's level.
+    """
+
+    def __init__(self, max_lines: int = DEFAULT_MAX_LINES) -> None:
+        self._buffer: collections.deque[dict[str, typing.Any]] = collections.deque(
+            maxlen=max_lines
+        )
+        self._last_level: str = "INFO"
+        self._reader_task: asyncio.Task | None = None
+
+    def add_line(self, raw_line: str) -> None:
+        """Parse and append a single raw stderr line to the buffer."""
+        text = raw_line.rstrip("\n").rstrip("\r")
+        if text.strip() == "":
+            return
+
+        match = _LEVEL_RE.match(text)
+        if match:
+            level = match.group("level")
+            if level not in _KNOWN_LEVELS:
+                level = self._last_level
+            else:
+                self._last_level = level
+        else:
+            # Continuation line (traceback / multi-line message): inherit level.
+            level = self._last_level
+
+        self._buffer.append(
+            {
+                "ts": time.time(),
+                "level": level,
+                "text": text,
+            }
+        )
+
+    def get_logs(
+        self,
+        limit: int = 200,
+        level: str | None = None,
+    ) -> list[dict[str, typing.Any]]:
+        """Return the most recent log entries.
+
+        Args:
+            limit: Max number of entries to return (most recent first-in-order).
+            level: Optional minimum level filter (e.g. "WARNING" returns
+                WARNING/ERROR/CRITICAL only). None returns all levels.
+        """
+        entries = list(self._buffer)
+
+        if level:
+            min_no = logging.getLevelName(level)
+            if isinstance(min_no, int):
+                entries = [
+                    e
+                    for e in entries
+                    if _level_no(e["level"]) >= min_no
+                ]
+
+        if limit and limit > 0:
+            entries = entries[-limit:]
+
+        return entries
+
+    def clear(self) -> None:
+        self._buffer.clear()
+
+    async def attach_stream(self, stream: asyncio.StreamReader) -> None:
+        """Continuously read lines from a stream into the buffer until EOF."""
+        try:
+            while True:
+                line_bytes = await stream.readline()
+                if not line_bytes:
+                    break
+                self.add_line(line_bytes.decode("utf-8", errors="replace"))
+        except Exception as e:  # noqa: BLE001 - reader must never crash the runtime
+            logger.debug(f"Plugin log stream reader stopped: {e}")
+
+    def start_reader(self, stream: asyncio.StreamReader) -> None:
+        """Spawn a background task reading the given stream into the buffer."""
+        if self._reader_task is not None and not self._reader_task.done():
+            return
+        self._reader_task = asyncio.create_task(self.attach_stream(stream))
+
+    def stop_reader(self) -> None:
+        if self._reader_task is not None and not self._reader_task.done():
+            self._reader_task.cancel()
+        self._reader_task = None
+
+
+def _level_no(level_name: str) -> int:
+    no = logging.getLevelName(level_name)
+    return no if isinstance(no, int) else logging.INFO

{langbot_plugin-0.4.3 → langbot_plugin-0.4.4}/src/langbot_plugin/runtime/plugin/mgr.py

@@ -729,6 +729,27 @@ class PluginManager:
 
         return b""
 
+    async def get_plugin_logs(
+        self,
+        plugin_author: str,
+        plugin_name: str,
+        limit: int = 200,
+        level: str | None = None,
+    ) -> list[dict[str, typing.Any]]:
+        """Return recent log entries captured from the plugin's stderr.
+
+        Each entry: {"ts": float, "level": str, "text": str}.
+        Returns an empty list if the plugin is not running.
+        """
+        plugin = self.find_plugin(plugin_author, plugin_name)
+        if plugin is not None and plugin._runtime_plugin_handler is not None:
+            log_buffer = getattr(
+                plugin._runtime_plugin_handler, "log_buffer", None
+            )
+            if log_buffer is not None:
+                return log_buffer.get_logs(limit=limit, level=level)
+        return []
+
     async def get_plugin_assets_file(
         self, plugin_author: str, plugin_name: str, file_key: str
     ) -> tuple[bytes, str]:

{langbot_plugin-0.4.3 → langbot_plugin-0.4.4}/tests/api/proxies/test_langbot_api.py

@@ -146,6 +146,9 @@ async def test_tool_and_rag_helpers_preserve_payload_contracts():
             PluginToRuntimeAction.GET_TOOL_DETAIL: {"tool": {"name": "tool"}},
             PluginToRuntimeAction.CALL_TOOL: {"tool_response": {"ok": True}},
             PluginToRuntimeAction.INVOKE_EMBEDDING: {"vectors": [[0.1]]},
+            PluginToRuntimeAction.INVOKE_RERANK: {
+                "results": [{"index": 0, "relevance_score": 0.9}]
+            },
             PluginToRuntimeAction.VECTOR_SEARCH: {"results": [{"id": "1"}]},
             PluginToRuntimeAction.VECTOR_DELETE: {"count": 2},
             PluginToRuntimeAction.VECTOR_LIST: {"items": [], "total": 0},
@@ -161,6 +164,9 @@ async def test_tool_and_rag_helpers_preserve_payload_contracts():
     assert await proxy.get_tool_detail("tool") == {"name": "tool"}
     assert await proxy.call_tool("tool", {"q": 1}, {"s": 1}, 7) == {"ok": True}
     assert await proxy.invoke_embedding("embed", ["hi"]) == [[0.1]]
+    assert await proxy.invoke_rerank(
+        "rerank", "query", ["doc"], top_k=1, extra_args={"return_documents": False}
+    ) == [{"index": 0, "relevance_score": 0.9}]
     await proxy.vector_upsert("c", [[0.1]], ["id"], documents=["doc"])
     assert await proxy.vector_search("c", [0.1], filters={"a": 1}) == [{"id": "1"}]
     assert await proxy.vector_delete("c", file_ids=["f"]) == 2
@@ -174,6 +180,18 @@ async def test_tool_and_rag_helpers_preserve_payload_contracts():
     assert call_tool_call[1]["tool_parameters"] == {"q": 1}
     assert call_tool_call[2] == 180
 
+    rerank_call = [
+        call for call in handler.calls if call[0] is PluginToRuntimeAction.INVOKE_RERANK
+    ][0]
+    assert rerank_call[1] == {
+        "rerank_model_uuid": "rerank",
+        "query": "query",
+        "documents": ["doc"],
+        "top_k": 1,
+        "extra_args": {"return_documents": False},
+    }
+    assert rerank_call[2] == 60.0
+
 
 @pytest.mark.asyncio
 async def test_get_knowledge_file_stream_reads_and_deletes_local_chunk_file():

langbot_plugin-0.4.4/tests/test_plugin_logbuffer.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import asyncio
+
+from langbot_plugin.runtime.plugin.logbuffer import PluginLogBuffer
+
+
+def test_parses_standard_log_line_level():
+    buf = PluginLogBuffer()
+    buf.add_line(
+        "[06-13 10:30:00.123] main.py (45) - [INFO] : hello world"
+    )
+    logs = buf.get_logs()
+    assert len(logs) == 1
+    assert logs[0]["level"] == "INFO"
+    assert logs[0]["text"].endswith("hello world")
+
+
+def test_continuation_line_inherits_level():
+    buf = PluginLogBuffer()
+    buf.add_line(
+        "[06-13 10:30:00.123] main.py (45) - [ERROR] : boom"
+    )
+    buf.add_line("Traceback (most recent call last):")
+    buf.add_line('  File "x.py", line 1, in <module>')
+    logs = buf.get_logs()
+    assert len(logs) == 3
+    assert all(e["level"] == "ERROR" for e in logs)
+
+
+def test_level_filter():
+    buf = PluginLogBuffer()
+    buf.add_line("[06-13 10:30:00.1] a.py (1) - [INFO] : i")
+    buf.add_line("[06-13 10:30:00.2] a.py (2) - [WARNING] : w")
+    buf.add_line("[06-13 10:30:00.3] a.py (3) - [ERROR] : e")
+    warn_and_up = buf.get_logs(level="WARNING")
+    assert [e["level"] for e in warn_and_up] == ["WARNING", "ERROR"]
+
+
+def test_ring_buffer_cap():
+    buf = PluginLogBuffer(max_lines=5)
+    for i in range(20):
+        buf.add_line(f"[06-13 10:30:00.1] a.py (1) - [INFO] : line {i}")
+    logs = buf.get_logs(limit=100)
+    assert len(logs) == 5
+    assert logs[-1]["text"].endswith("line 19")
+
+
+def test_limit():
+    buf = PluginLogBuffer()
+    for i in range(50):
+        buf.add_line(f"[06-13 10:30:00.1] a.py (1) - [INFO] : line {i}")
+    logs = buf.get_logs(limit=10)
+    assert len(logs) == 10
+    assert logs[-1]["text"].endswith("line 49")
+
+
+def test_empty_lines_skipped():
+    buf = PluginLogBuffer()
+    buf.add_line("")
+    buf.add_line("   \n")
+    assert buf.get_logs() == []
+
+
+def test_attach_stream_reads_to_eof():
+    async def run():
+        reader = asyncio.StreamReader()
+        reader.feed_data(
+            b"[06-13 10:30:00.1] a.py (1) - [INFO] : streamed\n"
+        )
+        reader.feed_eof()
+        buf = PluginLogBuffer()
+        await buf.attach_stream(reader)
+        return buf.get_logs()
+
+    logs = asyncio.run(run())
+    assert len(logs) == 1
+    assert logs[0]["text"].endswith("streamed")