langbot-plugin 0.3.2__tar.gz → 0.3.4__tar.gz

{langbot_plugin-0.3.2 → langbot_plugin-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langbot-plugin
-Version: 0.3.2
+Version: 0.3.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.3.2 → langbot_plugin-0.3.4}/pyproject.toml

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

@@ -81,6 +81,7 @@ class LangBotAPIProxy:
         messages: list[provider_message.Message],
         funcs: list[resource_tool.LLMTool] = [],
         extra_args: dict[str, Any] = {},
+        timeout: float | None = None,
     ) -> provider_message.Message:
         """Invoke an LLM model"""
         resp = (
@@ -92,6 +93,7 @@ class LangBotAPIProxy:
                     "funcs": [f.model_dump() for f in funcs],
                     "extra_args": extra_args,
                 },
+                timeout=timeout if timeout is not None else 15.0,
             )
         )["message"]
 
@@ -262,6 +264,7 @@ class LangBotAPIProxy:
         filters: dict[str, Any] | None = None,
         search_type: str = "vector",
         query_text: str = "",
+        vector_weight: float | None = None,
     ) -> list[dict[str, Any]]:
         """Search similar vectors in Host's vector store.
 
@@ -272,23 +275,27 @@ class LangBotAPIProxy:
             filters: Optional metadata filters.
             search_type: One of 'vector', 'full_text', 'hybrid'.
             query_text: Raw query text, used for full_text and hybrid search.
+            vector_weight: Weight for vector search in hybrid mode (0.0–1.0).
+                ``None`` means use equal weights (backward compatible).
 
         Returns:
             List of search results (dict with id, distance, metadata).
             Some hosts may also include an optional score field, but distance
             is the stable field and lower values mean more similar results.
         """
+        data = {
+            "collection_id": collection_id,
+            "query_vector": query_vector,
+            "top_k": top_k,
+            "filters": filters,
+            "search_type": search_type,
+            "query_text": query_text,
+            "vector_weight": vector_weight,
+        }
         return (
             await self.plugin_runtime_handler.call_action(
                 PluginToRuntimeAction.VECTOR_SEARCH,
-                {
-                    "collection_id": collection_id,
-                    "query_vector": query_vector,
-                    "top_k": top_k,
-                    "filters": filters,
-                    "search_type": search_type,
-                    "query_text": query_text,
-                },
+                data,
                 timeout=30,
             )
         )["results"]
@@ -321,6 +328,36 @@ class LangBotAPIProxy:
             )
         )["count"]
 
+    async def vector_list(
+        self,
+        collection_id: str,
+        filters: dict[str, Any] | None = None,
+        limit: int = 20,
+        offset: int = 0,
+    ) -> dict[str, Any]:
+        """List vectors from Host's vector store by metadata filter.
+
+        Args:
+            collection_id: Target collection ID.
+            filters: Optional metadata filters.
+            limit: Maximum number of items to return.
+            offset: Number of items to skip for pagination.
+
+        Returns:
+            Dict with 'items' (list of dicts with id, document, metadata)
+            and 'total' (total count matching the filter, best-effort).
+        """
+        return await self.plugin_runtime_handler.call_action(
+            PluginToRuntimeAction.VECTOR_LIST,
+            {
+                "collection_id": collection_id,
+                "filters": filters,
+                "limit": limit,
+                "offset": offset,
+            },
+            timeout=30,
+        )
+
     async def get_knowledge_file_stream(self, storage_path: str) -> bytes:
         """Get file content from Host's storage.
 
@@ -340,6 +377,62 @@ class LangBotAPIProxy:
         await self.plugin_runtime_handler.delete_local_file(file_key)
         return file_bytes
 
+    # ================= Knowledge Base APIs =================
+
+    async def list_knowledge_bases(self) -> list[dict[str, Any]]:
+        """List all knowledge bases available in the LangBot instance.
+
+        Unlike query-based ``list_pipeline_knowledge_bases``, this API is
+        globally available and not restricted to a specific pipeline's
+        configured knowledge bases.
+
+        Returns:
+            List of dicts, each containing:
+            - uuid: Knowledge base UUID
+            - name: Knowledge base name
+            - description: Knowledge base description
+        """
+        return (
+            await self.plugin_runtime_handler.call_action(
+                PluginToRuntimeAction.LIST_KNOWLEDGE_BASES, {}
+            )
+        )["knowledge_bases"]
+
+    async def retrieve_knowledge(
+        self,
+        kb_id: str,
+        query_text: str,
+        top_k: int = 5,
+        filters: dict[str, Any] | None = None,
+    ) -> list[dict[str, Any]]:
+        """Retrieve relevant documents from any knowledge base.
+
+        Unlike query-based ``retrieve_knowledge``, this API is globally
+        available and can access any knowledge base without pipeline
+        restrictions.
+
+        Args:
+            kb_id: Knowledge base UUID
+            query_text: Search query text
+            top_k: Number of results to return (default: 5)
+            filters: Optional metadata filters for retrieval
+
+        Returns:
+            List of retrieval result entries.
+        """
+        return (
+            await self.plugin_runtime_handler.call_action(
+                PluginToRuntimeAction.RETRIEVE_KNOWLEDGE,
+                {
+                    "kb_id": kb_id,
+                    "query_text": query_text,
+                    "top_k": top_k,
+                    "filters": filters or {},
+                },
+                timeout=30,
+            )
+        )["results"]
+
     # ================= Parser Capability APIs =================
 
     async def list_parsers(self, mime_type: str | None = None) -> list[dict[str, Any]]:

{langbot_plugin-0.3.2 → langbot_plugin-0.3.4}/src/langbot_plugin/cli/commands/runplugin.py

@@ -6,6 +6,7 @@ import dotenv
 import logging
 
 from langbot_plugin.utils.discover.engine import ComponentDiscoveryEngine
+from langbot_plugin.utils.log import configure_process_logging
 from langbot_plugin.cli.run.controller import PluginRuntimeController
 from langbot_plugin.cli.i18n import cli_print
 
@@ -66,12 +67,7 @@ async def arun_plugin_process(stdio: bool = False, prod_mode: bool = False, plug
 
 
 def run_plugin_process(stdio: bool = False, prod_mode: bool = False, plugin_debug_key: str = "") -> None:
-    # Configure logging for plugin process
-    logging.basicConfig(
-        level=logging.INFO,
-        format='[%(asctime)s.%(msecs)03d] (PluginProcess) %(filename)s (%(lineno)d) - [%(levelname)s] : %(message)s',
-        datefmt='%Y-%m-%d %H:%M:%S'
-    )
+    configure_process_logging()
 
     try:
         asyncio.run(arun_plugin_process(stdio, prod_mode, plugin_debug_key))

{langbot_plugin-0.3.2 → langbot_plugin-0.3.4}/src/langbot_plugin/entities/io/actions/enums.py

@@ -62,12 +62,17 @@ class PluginToRuntimeAction(ActionType):
     VECTOR_UPSERT = "vector_upsert"
     VECTOR_SEARCH = "vector_search"
     VECTOR_DELETE = "vector_delete"
+    VECTOR_LIST = "vector_list"
     GET_KNOWLEDEGE_FILE_STREAM = "get_knowledge_file_stream"
 
     LIST_PARSERS = "list_parsers"
     INVOKE_PARSER = "invoke_parser"
 
-    """Knowledge Base Query APIs (query-based)"""
+    """Knowledge Base APIs (global, unrestricted)"""
+    LIST_KNOWLEDGE_BASES = "list_knowledge_bases"
+    RETRIEVE_KNOWLEDGE = "retrieve_knowledge"
+
+    """Knowledge Base Query APIs (query-based, pipeline-scoped)"""
     LIST_PIPELINE_KNOWLEDGE_BASES = "list_pipeline_knowledge_bases"
     RETRIEVE_KNOWLEDGE_BASE = "retrieve_knowledge_base"
 

{langbot_plugin-0.3.2 → langbot_plugin-0.3.4}/src/langbot_plugin/runtime/app.py

@@ -17,6 +17,7 @@ from langbot_plugin.runtime.io.connection import Connection
 from langbot_plugin.runtime.plugin import mgr as plugin_mgr_cls
 from langbot_plugin.runtime import context
 from langbot_plugin.runtime.settings import settings
+from langbot_plugin.utils.log import configure_process_logging
 
 logger = logging.getLogger(__name__)
 
@@ -125,13 +126,8 @@ class RuntimeApplication:
 
 
 def main(args: argparse.Namespace):
-    # Configure logging for runtime
-    logging.basicConfig(
-        level=logging.INFO,
-        format='[%(asctime)s.%(msecs)03d] %(filename)s (%(lineno)d) - [%(levelname)s] : %(message)s',
-        datefmt='%Y-%m-%d %H:%M:%S'
-    )
-    
+    configure_process_logging()
+
     app = RuntimeApplication(args)
 
     try:

{langbot_plugin-0.3.2 → langbot_plugin-0.3.4}/src/langbot_plugin/runtime/io/handlers/plugin.py

@@ -208,11 +208,16 @@ class PluginConnectionHandler(handler.Handler):
 
         @self.action(PluginToRuntimeAction.INVOKE_LLM)
         async def invoke_llm(data: dict[str, Any]) -> handler.ActionResponse:
+            timeout = data.pop("timeout", 15.0)
+            if not isinstance(timeout, (int, float)) or timeout <= 0:
+                timeout = 15.0
+
             result = await self.context.control_handler.call_action(
                 PluginToRuntimeAction.INVOKE_LLM,
                 {
                     **data,
                 },
+                timeout=float(timeout),
             )
             return handler.ActionResponse.success(result)
 
@@ -296,6 +301,23 @@ class PluginConnectionHandler(handler.Handler):
 
         # ================= Knowledge Base Query Handlers (Plugin -> Runtime -> Host) =================
 
+        @self.action(PluginToRuntimeAction.LIST_KNOWLEDGE_BASES)
+        async def list_knowledge_bases(data: dict[str, Any]) -> handler.ActionResponse:
+            result = await self.context.control_handler.call_action(
+                PluginToRuntimeAction.LIST_KNOWLEDGE_BASES,
+                data,
+            )
+            return handler.ActionResponse.success(result)
+
+        @self.action(PluginToRuntimeAction.RETRIEVE_KNOWLEDGE)
+        async def retrieve_knowledge(data: dict[str, Any]) -> handler.ActionResponse:
+            result = await self.context.control_handler.call_action(
+                PluginToRuntimeAction.RETRIEVE_KNOWLEDGE,
+                data,
+                timeout=30,
+            )
+            return handler.ActionResponse.success(result)
+
         @self.action(PluginToRuntimeAction.LIST_PIPELINE_KNOWLEDGE_BASES)
         async def list_pipeline_knowledge_bases(data: dict[str, Any]) -> handler.ActionResponse:
             result = await self.context.control_handler.call_action(

langbot_plugin-0.3.4/src/langbot_plugin/utils/log.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import logging
+from typing import TextIO
+
+DEFAULT_LOG_DATEFMT = "%m-%d %H:%M:%S"
+_BASE_LOG_FORMAT = "[%(asctime)s.%(msecs)03d] %(filename)s (%(lineno)d) - [%(levelname)s] : %(message)s"
+_PREFIXED_LOG_FORMAT = (
+    "[%(asctime)s.%(msecs)03d] ({process_name}) %(filename)s (%(lineno)d) - [%(levelname)s] : %(message)s"
+)
+
+
+def build_process_log_format(process_name: str | None = None) -> str:
+    if process_name:
+        return _PREFIXED_LOG_FORMAT.format(process_name=process_name)
+    return _BASE_LOG_FORMAT
+
+
+def configure_process_logging(
+    *,
+    level: int = logging.INFO,
+    process_name: str | None = None,
+    stream: TextIO | None = None,
+) -> None:
+    """Configure a consistent log format for standalone SDK entrypoints."""
+    logging.basicConfig(
+        level=level,
+        format=build_process_log_format(process_name),
+        datefmt=DEFAULT_LOG_DATEFMT,
+        stream=stream,
+        force=True,
+    )

langbot_plugin-0.3.4/src/langbot_plugin/version.py

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

langbot_plugin-0.3.4/tests/test_log.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import io
+import logging
+import re
+
+from langbot_plugin.utils.log import build_process_log_format, configure_process_logging
+
+
+def test_build_process_log_format_supports_optional_prefix():
+    assert build_process_log_format() == "[%(asctime)s.%(msecs)03d] %(filename)s (%(lineno)d) - [%(levelname)s] : %(message)s"
+    assert (
+        build_process_log_format("BoxRuntime")
+        == "[%(asctime)s.%(msecs)03d] (BoxRuntime) %(filename)s (%(lineno)d) - [%(levelname)s] : %(message)s"
+    )
+
+
+def test_configure_process_logging_uses_unified_formatter():
+    stream = io.StringIO()
+    logger = logging.getLogger("langbot_plugin.tests.log")
+
+    configure_process_logging(stream=stream)
+    logger.info("hello logging")
+
+    output = stream.getvalue().strip()
+    assert re.match(
+        r"^\[\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}\] test_log\.py \(\d+\) - \[INFO\] : hello logging$",
+        output,
+    )

langbot_plugin-0.3.2/src/langbot_plugin/version.py

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