langbot-plugin 0.7.9__tar.gz → 0.7.11__tar.gz

{langbot_plugin-0.7.9 → langbot_plugin-0.7.11}/ARCHITECTURE.md

@@ -97,6 +97,27 @@ Subcommand implementations live under `cli/commands/`, `cli/run/`, and `cli/gen/
 
 ## Action RPC Protocol
 
+Streaming callers may send `stream_flow_control: 1` in the request envelope.
+Supporting senders number data responses with `stream_index` starting at 1 and
+allow eight unacknowledged frames per stream. After processing four frames, the
+caller sends `__stream_ack` with the original `seq_id` and cumulative `index`,
+using the original immutable installation context. The sender validates the
+context and index before returning credit. ACK admission has its own bounded
+capacity, separate from business actions and cancellation/heartbeat capacity.
+Only that stream's producer waits for credit; the connection router never waits
+on a consumer queue. Forwarding hops negotiate independently.
+
+Each streamed frame is limited to 1 MiB of serialized UTF-8 and each receiving
+buffer to 128 frames / 8 MiB. Oversize or legacy overflow is a terminal error,
+never a silently dropped delta. Older senders ignore the optional request field;
+without `stream_index`, callers send no ACKs and retain bounded legacy routing.
+Older callers omit the field, so new senders retain legacy push behavior.
+This compatibility does not provide backpressure on legacy hops; all hops must
+be upgraded for end-to-end flow control. Unfinished/failed/closed consumers send
+best-effort scoped cancellation, and producers explicitly close their iterators.
+The wire timeout bounds idle reads and ACK waits, not arbitrary time spent by
+application code processing a yielded value.
+
 The runtime protocol is a bidirectional action RPC protocol over stdio or WebSocket. It is implemented by `runtime/io/handler.py` and data models under `entities/io/`.
 
 Request shape:

{langbot_plugin-0.7.9 → langbot_plugin-0.7.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: langbot-plugin
-Version: 0.7.9
+Version: 0.7.11
 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.9 → langbot_plugin-0.7.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langbot-plugin"
-version = "0.7.9"
+version = "0.7.11"
 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.9 → langbot_plugin-0.7.11}/src/langbot_plugin/api/definition/abstract/platform/adapter.py

@@ -28,6 +28,10 @@ class AbstractMessagePlatformAdapter(pydantic.BaseModel, metaclass=abc.ABCMeta):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
+    def get_supported_apis(self) -> list[str]:
+        """Expose the message APIs required of every legacy adapter to Agents."""
+        return ["send_message", "reply_message"]
+
     @abc.abstractmethod
     async def send_message(
         self, target_type: str, target_id: str, message: platform_message.MessageChain

{langbot_plugin-0.7.9 → langbot_plugin-0.7.11}/src/langbot_plugin/api/definition/plugin.py

@@ -25,8 +25,9 @@ class BasePlugin(abc.ABC, langbot_api.LangBotAPIProxy):
         return getattr(self, "_legacy_config", {})
 
     @config.setter
-    def config(self, value: dict[str, typing.Any]) -> None:
-        self._legacy_config = dict(value)
+    def config(self, value: dict[str, typing.Any] | None) -> None:
+        # Legacy plugins initialize this attribute to None before runtime binding.
+        self._legacy_config = {} if value is None else dict(value)
 
     def get_config(self) -> dict[str, typing.Any]:
         """Return the active invocation config, or the legacy dedicated config."""

{langbot_plugin-0.7.9 → langbot_plugin-0.7.11}/src/langbot_plugin/api/entities/builtin/platform/events.py

@@ -205,6 +205,9 @@ class EBAEvent(Event):
     Coexists with the legacy MessageEvent hierarchy.
     """
 
+    summary_field: typing.ClassVar[str] = "type"
+    """Existing field path used for display summaries; never serialized."""
+
     type: str
     """Event type identifier, e.g. 'message.received'."""
 
@@ -227,6 +230,8 @@ class EBAEvent(Event):
 class MessageReceivedEvent(EBAEvent):
     """New message received. Replaces legacy FriendMessage / GroupMessage."""
 
+    summary_field: typing.ClassVar[str] = "message_chain"
+
     type: str = "message.received"
 
     message_id: typing.Union[int, str] = ""
@@ -321,6 +326,8 @@ class MessageReceivedEvent(EBAEvent):
 class MessageEditedEvent(EBAEvent):
     """Message was edited."""
 
+    summary_field: typing.ClassVar[str] = "new_content"
+
     type: str = "message.edited"
 
     message_id: typing.Union[int, str] = ""
@@ -342,6 +349,8 @@ class MessageEditedEvent(EBAEvent):
 class MessageDeletedEvent(EBAEvent):
     """Message was deleted / recalled."""
 
+    summary_field: typing.ClassVar[str] = "message_id"
+
     type: str = "message.deleted"
 
     message_id: typing.Union[int, str] = ""
@@ -358,6 +367,8 @@ class MessageDeletedEvent(EBAEvent):
 class MessageReactionEvent(EBAEvent):
     """Message received an emoji reaction."""
 
+    summary_field: typing.ClassVar[str] = "reaction"
+
     type: str = "message.reaction"
 
     message_id: typing.Union[int, str] = ""
@@ -385,6 +396,8 @@ class MessageReactionEvent(EBAEvent):
 class FeedbackReceivedEvent(EBAEvent):
     """User feedback received for a bot response."""
 
+    summary_field: typing.ClassVar[str] = "feedback_content"
+
     type: str = "feedback.received"
 
     feedback_id: str
@@ -432,6 +445,8 @@ class FeedbackReceivedEvent(EBAEvent):
 class MemberJoinedEvent(EBAEvent):
     """New member joined a group."""
 
+    summary_field: typing.ClassVar[str] = "member"
+
     type: str = "group.member_joined"
 
     group: platform_entities.UserGroup = pydantic.Field(
@@ -454,6 +469,8 @@ class MemberJoinedEvent(EBAEvent):
 class MemberLeftEvent(EBAEvent):
     """Member left a group."""
 
+    summary_field: typing.ClassVar[str] = "member"
+
     type: str = "group.member_left"
 
     group: platform_entities.UserGroup = pydantic.Field(
@@ -473,6 +490,8 @@ class MemberLeftEvent(EBAEvent):
 class MemberBannedEvent(EBAEvent):
     """Member was muted / restricted."""
 
+    summary_field: typing.ClassVar[str] = "member"
+
     type: str = "group.member_banned"
 
     group: platform_entities.UserGroup = pydantic.Field(
@@ -489,6 +508,8 @@ class MemberBannedEvent(EBAEvent):
 class GroupInfoUpdatedEvent(EBAEvent):
     """Group info was updated."""
 
+    summary_field: typing.ClassVar[str] = "changed_fields"
+
     type: str = "group.info_updated"
 
     group: platform_entities.UserGroup = pydantic.Field(
@@ -507,6 +528,8 @@ class GroupInfoUpdatedEvent(EBAEvent):
 class FriendRequestReceivedEvent(EBAEvent):
     """Friend request received."""
 
+    summary_field: typing.ClassVar[str] = "message"
+
     type: str = "friend.request_received"
 
     request_id: typing.Union[int, str] = ""
@@ -524,6 +547,8 @@ class FriendRequestReceivedEvent(EBAEvent):
 class FriendAddedEvent(EBAEvent):
     """Friend successfully added."""
 
+    summary_field: typing.ClassVar[str] = "user"
+
     type: str = "friend.added"
 
     user: platform_entities.User = pydantic.Field(
@@ -534,6 +559,8 @@ class FriendAddedEvent(EBAEvent):
 class FriendRemovedEvent(EBAEvent):
     """Friend was removed."""
 
+    summary_field: typing.ClassVar[str] = "user"
+
     type: str = "friend.removed"
 
     user: platform_entities.User = pydantic.Field(
@@ -547,6 +574,8 @@ class FriendRemovedEvent(EBAEvent):
 class BotInvitedToGroupEvent(EBAEvent):
     """Bot was invited to join a group."""
 
+    summary_field: typing.ClassVar[str] = "group"
+
     type: str = "bot.invited_to_group"
 
     group: platform_entities.UserGroup = pydantic.Field(
@@ -561,6 +590,8 @@ class BotInvitedToGroupEvent(EBAEvent):
 class BotRemovedFromGroupEvent(EBAEvent):
     """Bot was removed from a group."""
 
+    summary_field: typing.ClassVar[str] = "group"
+
     type: str = "bot.removed_from_group"
 
     group: platform_entities.UserGroup = pydantic.Field(
@@ -572,6 +603,8 @@ class BotRemovedFromGroupEvent(EBAEvent):
 class BotMutedEvent(EBAEvent):
     """Bot was muted in a group."""
 
+    summary_field: typing.ClassVar[str] = "group"
+
     type: str = "bot.muted"
 
     group: platform_entities.UserGroup = pydantic.Field(
@@ -584,6 +617,8 @@ class BotMutedEvent(EBAEvent):
 class BotUnmutedEvent(EBAEvent):
     """Bot was unmuted in a group."""
 
+    summary_field: typing.ClassVar[str] = "group"
+
     type: str = "bot.unmuted"
 
     group: platform_entities.UserGroup = pydantic.Field(
@@ -601,6 +636,8 @@ class PlatformSpecificEvent(EBAEvent):
     Used when the adapter cannot map an event to a standard type.
     """
 
+    summary_field: typing.ClassVar[str] = "action"
+
     type: str = "platform.specific"
 
     action: str = ""
@@ -610,9 +647,179 @@ class PlatformSpecificEvent(EBAEvent):
     """Event data; structure defined by each adapter."""
 
 
+# ---- WeCom AI Bot Events ----
+
+
+class WecomBotEnterChatEvent(EBAEvent):
+    """User entered an AI bot conversation (not a friend-added event)."""
+
+    summary_field: typing.ClassVar[str] = "chat_id"
+    type: str = "wecombot.enter_chat"
+    user: typing.Optional[platform_entities.User] = None
+    chat_id: str = ""
+    chat_type: platform_entities.ChatType = platform_entities.ChatType.PRIVATE
+    message_id: str = ""
+    data: dict = pydantic.Field(default_factory=dict)
+
+
+class WecomBotTemplateCardEvent(EBAEvent):
+    """User clicked or submitted a non-managed AI bot template card."""
+
+    summary_field: typing.ClassVar[str] = "event_key"
+    type: str = "wecombot.template_card_event"
+    user: typing.Optional[platform_entities.User] = None
+    chat_id: str = ""
+    chat_type: platform_entities.ChatType = platform_entities.ChatType.PRIVATE
+    message_id: str = ""
+    task_id: str = ""
+    event_key: str = ""
+    card_type: str = ""
+    selected_items: list[dict] = pydantic.Field(default_factory=list)
+    data: dict = pydantic.Field(default_factory=dict)
+
+
+class DingTalkCardActionEvent(EBAEvent):
+    """A DingTalk card interaction outside managed input forms."""
+
+    summary_field: typing.ClassVar[str] = "action"
+    type: str = "dingtalk.card_action"
+    user: typing.Optional[platform_entities.User] = None
+    space_id: str = ""
+    card_instance_id: str = ""
+    action: str = ""
+    data: dict = pydantic.Field(default_factory=dict)
+
+
+# ---- WeCom Customer Service Events ----
+
+
+class WecomCSEnterSessionEvent(EBAEvent):
+    """Customer opened a WeCom customer-service conversation."""
+
+    summary_field: typing.ClassVar[str] = "external_userid"
+    type: str = "wecomcs.enter_session"
+    open_kfid: str = ""
+    external_userid: str = ""
+    chat_id: str = ""
+    chat_type: platform_entities.ChatType = platform_entities.ChatType.PRIVATE
+    user: typing.Optional[platform_entities.User] = None
+    data: dict = pydantic.Field(default_factory=dict)
+    scene: str = ""
+    scene_param: str = ""
+    welcome_code: str = ""
+    wechat_channels: dict = pydantic.Field(default_factory=dict)
+
+
+class WecomCSMessageSendFailedEvent(EBAEvent):
+    """WeCom reported that an outgoing customer-service message failed."""
+
+    summary_field: typing.ClassVar[str] = "fail_msgid"
+    type: str = "wecomcs.msg_send_fail"
+    open_kfid: str = ""
+    external_userid: str = ""
+    chat_id: str = ""
+    chat_type: platform_entities.ChatType = platform_entities.ChatType.PRIVATE
+    user: typing.Optional[platform_entities.User] = None
+    data: dict = pydantic.Field(default_factory=dict)
+    fail_msgid: str = ""
+    fail_type: int = 0
+
+
+class WecomCSServicerStatusChangedEvent(EBAEvent):
+    """A WeCom customer-service representative changed availability."""
+
+    summary_field: typing.ClassVar[str] = "servicer_userid"
+    type: str = "wecomcs.servicer_status_change"
+    open_kfid: str = ""
+    external_userid: str = ""
+    chat_id: str = ""
+    chat_type: platform_entities.ChatType = platform_entities.ChatType.PRIVATE
+    user: typing.Optional[platform_entities.User] = None
+    data: dict = pydantic.Field(default_factory=dict)
+    servicer_userid: str = ""
+    status: int = 0
+    stop_type: int = 0
+
+
+class WecomCSSessionStatusChangedEvent(EBAEvent):
+    """A WeCom customer-service conversation was assigned, transferred or closed."""
+
+    summary_field: typing.ClassVar[str] = "external_userid"
+    type: str = "wecomcs.session_status_change"
+    open_kfid: str = ""
+    external_userid: str = ""
+    chat_id: str = ""
+    chat_type: platform_entities.ChatType = platform_entities.ChatType.PRIVATE
+    user: typing.Optional[platform_entities.User] = None
+    data: dict = pydantic.Field(default_factory=dict)
+    change_type: int = 0
+    old_servicer_userid: str = ""
+    new_servicer_userid: str = ""
+    msg_code: str = ""
+
+
+class WecomCSRejectCustomerMessageChangedEvent(EBAEvent):
+    """A representative enabled or disabled rejection of customer messages."""
+
+    summary_field: typing.ClassVar[str] = "external_userid"
+    type: str = "wecomcs.reject_customer_msg_switch_change"
+    open_kfid: str = ""
+    external_userid: str = ""
+    chat_id: str = ""
+    chat_type: platform_entities.ChatType = platform_entities.ChatType.PRIVATE
+    user: typing.Optional[platform_entities.User] = None
+    data: dict = pydantic.Field(default_factory=dict)
+    servicer_userid: str = ""
+    reject_switch: int = 0
+
+
 # ---- Message Send Result ----
 
 
+def event_summary(event: EBAEvent | dict) -> str:
+    """Read only the summary field declared by the event class."""
+    if isinstance(event, EBAEvent):
+        event_type = event.type
+        value = getattr(event, event.summary_field, None)
+    else:
+        event_type = str(event.get("type") or "event")
+        event_class = next(
+            (
+                cls
+                for cls in EBAEvent.__subclasses__()
+                if cls.model_fields["type"].default == event_type
+            ),
+            EBAEvent,
+        )
+        value = event.get(event_class.summary_field)
+
+    def render(value: typing.Any) -> str:
+        if value is None:
+            return ""
+        if isinstance(value, platform_message.MessageChain):
+            return str(value)
+        if isinstance(value, pydantic.BaseModel):
+            value = value.model_dump(mode="json")
+        if isinstance(value, dict):
+            if "root" in value:
+                return render(value["root"])
+            if value.get("type") == "Source":
+                return ""
+            if value.get("type") in {"Plain", "text"}:
+                return str(value.get("text") or "")
+            if "type" in value:
+                return f"[{value['type']}]"
+            return str(
+                value.get("nickname") or value.get("name") or value.get("id") or ""
+            )
+        if isinstance(value, (list, tuple)):
+            separator = "" if any(isinstance(item, dict) for item in value) else ", "
+            return separator.join(render(item) for item in value)
+        return str(value)
+
+    return render(value).strip() or event_type
+
+
 def parse_eba_event(data: dict) -> EBAEvent:
     """Deserialize public EBA event fields without creating plugin-only wrappers."""
     if not isinstance(data, dict) or not isinstance(data.get("type"), str):

{langbot_plugin-0.7.9 → langbot_plugin-0.7.11}/src/langbot_plugin/api/proxies/runner/resources.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from contextlib import aclosing
+
 import base64
 from copy import deepcopy
 from typing import Any
@@ -170,20 +172,23 @@ class AgentRunResourceAPIMixin:
         reasoning_level: ReasoningLevel | None = None,
     ):
         """Invoke an LLM model with streaming, permission validation."""
-        async for event in self.invoke_llm_stream_events(
-            llm_model_uuid=llm_model_uuid,
-            messages=messages,
-            funcs=funcs,
-            extra_args=extra_args,
-            **(
-                {"reasoning_level": reasoning_level}
-                if reasoning_level is not None
-                else {}
-            ),
-            remove_think=remove_think,
-        ):
-            if event.chunk is not None:
-                yield event.chunk
+        async with aclosing(
+            self.invoke_llm_stream_events(
+                llm_model_uuid=llm_model_uuid,
+                messages=messages,
+                funcs=funcs,
+                extra_args=extra_args,
+                **(
+                    {"reasoning_level": reasoning_level}
+                    if reasoning_level is not None
+                    else {}
+                ),
+                remove_think=remove_think,
+            )
+        ) as owned_stream:
+            async for event in owned_stream:
+                if event.chunk is not None:
+                    yield event.chunk
 
     async def invoke_llm_stream_events(
         self,
@@ -211,23 +216,26 @@ class AgentRunResourceAPIMixin:
         }
         if remove_think is not None:
             payload["remove_think"] = remove_think
-        async for chunk_data in self._api.plugin_runtime_handler.call_action_generator(
-            PluginToRuntimeAction.INVOKE_LLM_STREAM,
-            payload,
-            effective_timeout,
-        ):
-            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"] = self._expect_key(
-                    chunk_data,
-                    "chunk",
-                    PluginToRuntimeAction.INVOKE_LLM_STREAM,
-                )
-            yield provider_message.LLMStreamEvent.model_validate(event_data)
+        async with aclosing(
+            self._api.plugin_runtime_handler.call_action_generator(
+                PluginToRuntimeAction.INVOKE_LLM_STREAM,
+                payload,
+                effective_timeout,
+            )
+        ) as owned_stream:
+            async for chunk_data in owned_stream:
+                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"] = self._expect_key(
+                        chunk_data,
+                        "chunk",
+                        PluginToRuntimeAction.INVOKE_LLM_STREAM,
+                    )
+                yield provider_message.LLMStreamEvent.model_validate(event_data)
 
     # ================= Tool APIs (delegated with validation) =================
 

{langbot_plugin-0.7.9 → langbot_plugin-0.7.11}/src/langbot_plugin/box/backend.py

@@ -261,14 +261,15 @@ class CLISandboxBackend(BaseSandboxBackend):
         for key, value in spec.env.items():
             args.extend(["-e", f"{key}={value}"])
 
-        args.extend(
-            [
-                session.backend_session_id,
-                "sh",
-                "-lc",
-                self._build_exec_command(spec.workdir, spec.cmd),
-            ]
-        )
+        command = self._build_exec_command(spec.workdir, spec.cmd)
+        # Attachment manifests can exceed Windows CreateProcess limits (and
+        # POSIX per-argument limits). Keep large scripts out of argv.
+        input_data = None
+        if len(command.encode("utf-8")) > 8192:
+            args.append("-i")
+            input_data = command.encode("utf-8")
+            command = 'exec sh -lc "$(cat)"'
+        args.extend([session.backend_session_id, "sh", "-lc", command])
 
         cmd_preview = spec.cmd.strip()
         if len(cmd_preview) > 400:
@@ -280,8 +281,9 @@ class CLISandboxBackend(BaseSandboxBackend):
             f"env_keys={sorted(spec.env.keys())} cmd={cmd_preview}"
         )
 
+        run_options = {"input_data": input_data} if input_data is not None else {}
         result = await self._run_command(
-            args, timeout_sec=spec.timeout_sec, check=False
+            args, timeout_sec=spec.timeout_sec, check=False, **run_options
         )
         duration_ms = int(
             (dt.datetime.now(dt.timezone.utc) - start).total_seconds() * 1000
@@ -435,18 +437,31 @@ class CLISandboxBackend(BaseSandboxBackend):
         args: list[str],
         timeout_sec: int,
         check: bool,
+        input_data: bytes | None = None,
     ) -> _CommandResult:
         process = await asyncio.create_subprocess_exec(
             *args,
+            stdin=asyncio.subprocess.PIPE if input_data is not None else None,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
         )
         stdout_task = asyncio.create_task(self._read_stream(process.stdout))
         stderr_task = asyncio.create_task(self._read_stream(process.stderr))
 
+        async def feed_and_wait():
+            if input_data is not None:
+                try:
+                    process.stdin.write(input_data)
+                    await process.stdin.drain()
+                except (BrokenPipeError, ConnectionResetError):
+                    pass
+                finally:
+                    process.stdin.close()
+            await process.wait()
+
         timed_out = False
         try:
-            await asyncio.wait_for(process.wait(), timeout=timeout_sec)
+            await asyncio.wait_for(feed_and_wait(), timeout=timeout_sec)
         except asyncio.TimeoutError:
             process.kill()
             timed_out = True

{langbot_plugin-0.7.9 → langbot_plugin-0.7.11}/src/langbot_plugin/box/models.py

@@ -426,6 +426,16 @@ class BoxProfile(pydantic.BaseModel):
 BUILTIN_PROFILES: dict[str, BoxProfile] = {
     "default": BoxProfile(
         name="default",
+        network=BoxNetworkMode.ON,
+        host_path_mode=BoxHostMountMode.READ_WRITE,
+        cpus=1.0,
+        memory_mb=512,
+        pids_limit=128,
+        read_only_rootfs=True,
+        max_timeout_sec=120,
+    ),
+    "offline": BoxProfile(
+        name="offline",
         network=BoxNetworkMode.OFF,
         host_path_mode=BoxHostMountMode.READ_WRITE,
         cpus=1.0,

{langbot_plugin-0.7.9 → langbot_plugin-0.7.11}/src/langbot_plugin/cli/run/handler.py

@@ -18,7 +18,7 @@ from langbot_plugin.runtime.io.handler import Handler
 from langbot_plugin.api.entities import events
 from langbot_plugin.api.definition.components.base import NoneComponent
 from langbot_plugin.api.definition.components.common.event_listener import EventListener
-from langbot_plugin.entities.io.actions.enums import PluginToRuntimeAction
+from langbot_plugin.entities.io.actions.enums import CommonAction, PluginToRuntimeAction
 from langbot_plugin.entities.io.actions.enums import RuntimeToPluginAction
 from langbot_plugin.entities.io.context import InstallationBinding
 from langbot_plugin.api.proxies.invocation import bind_invocation, thaw_config
@@ -255,6 +255,10 @@ class PluginRuntimeHandler(Handler):
                 }
             )
 
+        @self.action(CommonAction.PING)
+        async def ping(data: dict[str, typing.Any]) -> ActionResponse:
+            return ActionResponse.success({"alive": True})
+
         @self.action(RuntimeToPluginAction.GET_PLUGIN_CONTAINER)
         async def get_plugin_container(data: dict[str, typing.Any]) -> ActionResponse:
             return ActionResponse.success(self.plugin_container.model_dump())
@@ -804,6 +808,11 @@ class PluginRuntimeHandler(Handler):
 
             return ActionResponse.success(result.model_dump(mode="json"))
 
+    def _uses_reserved_admission(self, req_data):
+        return req_data.get(
+            "action"
+        ) == CommonAction.PING.value or super()._uses_reserved_admission(req_data)
+
     @property
     def plugin_container(self) -> PluginContainer:
         return self._base_plugin_container
@@ -814,6 +823,9 @@ class PluginRuntimeHandler(Handler):
 
     @contextlib.contextmanager
     def action_invocation_scope(self, action, action_context):
+        if action == CommonAction.PING.value:
+            yield
+            return
         if not isinstance(action_context, InstallationBinding):
             yield
             return

{langbot_plugin-0.7.9 → langbot_plugin-0.7.11}/src/langbot_plugin/entities/io/actions/enums.py

@@ -14,6 +14,7 @@ class CommonAction(ActionType):
     HEARTBEAT = "__heartbeat"
     FILE_CHUNK = "__file_chunk"
     CANCEL_ACTION = "__cancel_action"
+    STREAM_ACK = "__stream_ack"
 
 
 class PluginToRuntimeAction(ActionType):