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

langbot_plugin-0.4.5/.github/workflows/test.yml

@@ -0,0 +1,79 @@
+name: Tests
+
+on:
+  push:
+    branches:
+      - main
+      - test-build
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  unit-tests:
+    name: Unit Tests
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+      - name: Set up Python
+        run: uv python install ${{ matrix.python-version }}
+      - name: Run tests with coverage
+        run: |
+          uv run --python ${{ matrix.python-version }} pytest \
+            --ignore=tests/packaging \
+            --cov=langbot_plugin \
+            --cov-report=term-missing \
+            --cov-fail-under=84
+
+  test-lint:
+    name: Lint and Format
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+      - name: Ruff check
+        run: uv run ruff check src tests --output-format=concise
+      - name: Ruff format check
+        run: uv run ruff format --check src tests
+
+  package-smoke:
+    name: Package Smoke
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+      - name: Set up Python
+        run: uv python install 3.12
+      - name: Installed wheel CLI smoke
+        run: uv run --python 3.12 pytest -q tests/packaging
+
+  scoped-type-check:
+    name: Scoped Type Check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+      - name: Mypy stable protocol modules
+        run: |
+          uv run mypy \
+            src/langbot_plugin/entities/io \
+            src/langbot_plugin/runtime/plugin/logbuffer.py \
+            src/langbot_plugin/utils/platform.py

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "langbot-plugin"
-version = "0.4.3"
+version = "0.4.5"
 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.5}/src/langbot_plugin/api/entities/builtin/provider/message.py

@@ -13,12 +13,23 @@ class FunctionCall(pydantic.BaseModel):
 
 
 class ToolCall(pydantic.BaseModel):
+    """Tool call from LLM.
+
+    The `provider_specific_fields` dict carries provider-specific metadata
+    that must be round-tripped between requests and responses. For example,
+    Gemini models require `thought_signature` in function call parts for
+    tool calls to work correctly.
+    """
+
     id: str
 
     type: str
 
     function: FunctionCall
 
+    provider_specific_fields: typing.Optional[dict[str, typing.Any]] = None
+    """Provider-specific fields (e.g., Gemini thought_signature) to round-trip."""
+
 
 class ImageURLContentObject(pydantic.BaseModel):
     url: str
@@ -79,7 +90,13 @@ class ContentElement(pydantic.BaseModel):
 
 
 class Message(pydantic.BaseModel):
-    """Message for AI"""
+    """Message for AI.
+
+    The `provider_specific_fields` dict carries provider-specific metadata
+    that must be round-tripped between requests and responses. For example,
+    Gemini models require `thought_signatures` to be preserved across
+    conversation turns for tool calls to work correctly.
+    """
 
     role: str  # user, system, assistant, tool, command, plugin
     """Role of the message"""
@@ -95,6 +112,12 @@ class Message(pydantic.BaseModel):
 
     tool_call_id: typing.Optional[str] = None
 
+    resp_message_id: typing.Optional[str] = None
+    """Response message ID for tracking"""
+
+    provider_specific_fields: typing.Optional[dict[str, typing.Any]] = None
+    """Provider-specific fields (e.g., Gemini thought_signatures) to round-trip."""
+
     def readable_str(self) -> str:
         if self.content is not None:
             return (
@@ -188,6 +211,9 @@ class MessageChunk(pydantic.BaseModel):
     msg_sequence: int = 0
     """消息迭代次数"""
 
+    provider_specific_fields: typing.Optional[dict[str, typing.Any]] = None
+    """Provider-specific fields (e.g., Gemini thought_signatures) to round-trip."""
+
     def readable_str(self) -> str:
         if self.content is not None:
             return (
@@ -262,3 +288,43 @@ class ToolCallChunk(pydantic.BaseModel):
 
     function: FunctionCall
     """函数调用"""
+
+    provider_specific_fields: typing.Optional[dict[str, typing.Any]] = None
+    """Provider-specific fields (e.g., Gemini thought_signature) to round-trip."""
+
+
+class LLMTokenUsage(pydantic.BaseModel):
+    """Token usage returned by an LLM provider.
+
+    The standard OpenAI-compatible counters are normalized when available.
+    Provider-specific fields such as prompt/completion token details or cache
+    counters are preserved as extra fields.
+    """
+
+    prompt_tokens: int | None = None
+    completion_tokens: int | None = None
+    total_tokens: int | None = None
+
+    model_config = pydantic.ConfigDict(extra="allow")
+
+
+class LLMInvokeResult(pydantic.BaseModel):
+    """Non-streaming LLM invoke result with optional provider usage."""
+
+    message: Message
+    usage: LLMTokenUsage | None = None
+
+    model_config = pydantic.ConfigDict(extra="forbid")
+
+
+class LLMStreamEvent(pydantic.BaseModel):
+    """Streaming LLM event.
+
+    Most events carry a message chunk. A final provider usage event may carry
+    usage without a chunk when the upstream API reports usage after completion.
+    """
+
+    chunk: MessageChunk | None = None
+    usage: LLMTokenUsage | None = None
+
+    model_config = pydantic.ConfigDict(extra="forbid")

{langbot_plugin-0.4.3 → langbot_plugin-0.4.5}/src/langbot_plugin/api/proxies/langbot_api.py

@@ -84,22 +84,96 @@ class LangBotAPIProxy:
         timeout: float | None = None,
     ) -> provider_message.Message:
         """Invoke an LLM model"""
+        result = await self.invoke_llm_with_usage(
+            llm_model_uuid=llm_model_uuid,
+            messages=messages,
+            funcs=funcs,
+            extra_args=extra_args,
+            timeout=timeout,
+        )
+        return result.message
+
+    async def invoke_llm_with_usage(
+        self,
+        llm_model_uuid: str,
+        messages: list[provider_message.Message],
+        funcs: list[resource_tool.LLMTool] = [],
+        extra_args: dict[str, Any] = {},
+        timeout: float | None = None,
+    ) -> provider_message.LLMInvokeResult:
+        """Invoke an LLM model and return the message plus optional provider usage."""
         effective_timeout = timeout if timeout is not None else 120.0
-        resp = (
-            await self.plugin_runtime_handler.call_action(
-                PluginToRuntimeAction.INVOKE_LLM,
-                {
-                    "llm_model_uuid": llm_model_uuid,
-                    "messages": [m.model_dump() for m in messages],
-                    "funcs": [f.model_dump() for f in funcs],
-                    "extra_args": extra_args,
-                    "timeout": effective_timeout,
-                },
-                timeout=effective_timeout,
-            )
-        )["message"]
+        resp = await self.plugin_runtime_handler.call_action(
+            PluginToRuntimeAction.INVOKE_LLM,
+            {
+                "llm_model_uuid": llm_model_uuid,
+                "messages": [m.model_dump() for m in messages],
+                "funcs": [f.model_dump() for f in funcs],
+                "extra_args": extra_args,
+                "timeout": effective_timeout,
+            },
+            timeout=effective_timeout,
+        )
 
-        return provider_message.Message.model_validate(resp)
+        return provider_message.LLMInvokeResult.model_validate(
+            {
+                "message": resp["message"],
+                "usage": resp.get("usage") if isinstance(resp, dict) else None,
+            }
+        )
+
+    async def invoke_llm_stream(
+        self,
+        llm_model_uuid: str,
+        messages: list[provider_message.Message],
+        funcs: list[resource_tool.LLMTool] = [],
+        extra_args: dict[str, Any] = {},
+    ):
+        """Invoke an LLM model with streaming response
+
+        Args:
+            llm_model_uuid: The UUID of the LLM model to use
+            messages: List of conversation messages
+            funcs: List of tools available to the LLM
+            extra_args: Extra arguments for the LLM provider
+
+        Yields:
+            MessageChunk: Streamed message chunks from the LLM
+        """
+        async for event in self.invoke_llm_stream_events(
+            llm_model_uuid=llm_model_uuid,
+            messages=messages,
+            funcs=funcs,
+            extra_args=extra_args,
+        ):
+            if event.chunk is not None:
+                yield event.chunk
+
+    async def invoke_llm_stream_events(
+        self,
+        llm_model_uuid: str,
+        messages: list[provider_message.Message],
+        funcs: list[resource_tool.LLMTool] = [],
+        extra_args: dict[str, Any] = {},
+    ):
+        """Invoke an LLM model and yield chunks plus optional final usage events."""
+        async for chunk_data in self.plugin_runtime_handler.call_action_generator(
+            PluginToRuntimeAction.INVOKE_LLM_STREAM,
+            {
+                "llm_model_uuid": llm_model_uuid,
+                "messages": [m.model_dump() for m in messages],
+                "funcs": [f.model_dump() for f in funcs],
+                "extra_args": extra_args,
+            },
+        ):
+            event_data: dict[str, Any] = {}
+            if isinstance(chunk_data, dict) and "chunk" in chunk_data:
+                event_data["chunk"] = chunk_data["chunk"]
+            if isinstance(chunk_data, dict) and "usage" in chunk_data:
+                event_data["usage"] = chunk_data["usage"]
+            if not event_data:
+                event_data["chunk"] = chunk_data["chunk"]
+            yield provider_message.LLMStreamEvent.model_validate(event_data)
 
     async def set_plugin_storage(self, key: str, value: bytes) -> None:
         """Set a plugin storage value"""
@@ -284,6 +358,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.5}/src/langbot_plugin/box/__init__.py

@@ -2,4 +2,4 @@
 
 from .client import BoxRuntimeClient, ActionRPCBoxClient
 
-__all__ = ['BoxRuntimeClient', 'ActionRPCBoxClient']
+__all__ = ["BoxRuntimeClient", "ActionRPCBoxClient"]