langbot-plugin 0.6.20__tar.gz → 0.7.0__tar.gz

{langbot_plugin-0.6.20 → langbot_plugin-0.7.0}/ARCHITECTURE.md

@@ -53,8 +53,9 @@ Plugin-facing APIs live under `src/langbot_plugin/api/`.
 - `definition/plugin.py` defines `BasePlugin`.
 - `definition/components/` defines component base classes.
 - `definition/components/manifest.py` defines component manifest models. Plugin
-  manifests may set `execution.sharedRuntime: shared-runtime-v1`; omission keeps
-  the dedicated-runtime profile.
+  manifests may set `execution.sharedRuntime: shared-runtime-v1` together with
+  `execution.componentModel: stateless-v1`; omission keeps the legacy dedicated
+  object model.
 - `certification.py` defines optional ZIP-comment certification envelopes. It
   canonicalizes envelope JSON, normalizes the ZIP digest by removing the comment,
   and verifies the signed manifest identity and runtime profile without changing
@@ -176,9 +177,10 @@ worker immediately; stale or cross-Workspace transitions fail closed.
 Dedicated enabled installations remain owned by installation-scoped
 Supervisors. A certified shared worker is keyed by the raw artifact digest and
 currently has pool size one: the first slot attach starts it and the last slot
-detach stops it. Installations sharing that process retain separate
-`BasePlugin`, component, config, Host authority, and lifecycle slots. Updating
-one slot reinitializes that slot without restarting siblings. Revision and
+detach stops it. Installations sharing that process use one `BasePlugin` and one instance of each
+component. Lightweight slots retain immutable config snapshots, Host authority,
+revision and task ownership. Invocation-local context selects the slot; config
+updates replace that snapshot without recreating components. Revision and
 generation fencing remove the exact stale slot, cancel its in-flight actions,
 and prevent background calls after detach.
 

{langbot_plugin-0.6.20 → langbot_plugin-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: langbot-plugin
-Version: 0.6.20
+Version: 0.7.0
 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.20 → langbot_plugin-0.7.0}/docs/certified-plugins.md

@@ -12,22 +12,24 @@ execution:
     path: main.py
     attr: Plugin
   sharedRuntime: shared-runtime-v1
+  componentModel: stateless-v1
 ```
 
-If `execution.sharedRuntime` is absent, the manifest remains a dedicated-runtime manifest. Any other value is rejected by the SDK manifest model and by certification verification.
+If `execution.sharedRuntime` is absent, the manifest remains a dedicated-runtime manifest. `shared-runtime-v1` requires `componentModel: stateless-v1`; this declares the [stateless singleton component contract](stateless-components.md). Legacy per-installation object behavior remains compatible on dedicated workers but is not certifiable.
 
 ## Envelope format
 
-The envelope is compact, sorted UTF-8 JSON in the ZIP comment. The supported schema is `certified-plugin-envelope-v1` with exactly these fields:
+The envelope is compact, sorted UTF-8 JSON in the ZIP comment. New stateless certificates use `certified-plugin-envelope-v2` with exactly these fields. Legacy v1 envelopes remain readable and verifiable, but have no signed `component_model` and cannot authorize shared singleton placement.
 
 ```json
 {
-  "schema": "certified-plugin-envelope-v1",
+  "schema": "certified-plugin-envelope-v2",
   "key_id": "issuer-key-id",
   "plugin_id": {"author": "publisher", "name": "plugin"},
   "version": "1.2.3",
   "digest": "lowercase-sha256-hex",
   "shared_runtime": "shared-runtime-v1",
+  "component_model": "stateless-v1",
   "signature": "base64-signature"
 }
 ```
@@ -51,7 +53,7 @@ if result.status != "valid":
     raise ValueError(result.status)
 ```
 
-Verification binds the envelope's `plugin_id.author`, `plugin_id.name`, `version`, normalized digest, and `shared_runtime` to `manifest.yaml`.
+Verification binds the envelope's `plugin_id.author`, `plugin_id.name`, `version`, normalized digest, `shared_runtime`, and `component_model` to `manifest.yaml`.
 
 ## Verification statuses
 

langbot_plugin-0.7.0/docs/stateless-components.md

@@ -0,0 +1,59 @@
+# Stateless component model (`stateless-v1`)
+
+Certified cross-tenant plugins use one `BasePlugin` object and one object for every declared component manifest per artifact-digest worker. Multiple declared components of the same kind therefore have distinct shared objects. Installation attachments are lightweight immutable contexts; they do not create another plugin/component object graph.
+
+## Manifest declaration
+
+```yaml
+execution:
+  python:
+    path: main.py
+    attr: Plugin
+  sharedRuntime: shared-runtime-v1
+  componentModel: stateless-v1
+```
+
+`sharedRuntime` without `componentModel: stateless-v1` is not eligible for certification. Legacy source and unsigned packages remain compatible with the dedicated path. OSS may downgrade an untrusted or legacy certificate to dedicated according to its admission policy; Cloud may reject it before installation.
+
+## Programming contract
+
+- Treat `BasePlugin` and every component object as process-wide singletons.
+- Keep `initialize()` process-scoped. It runs once per worker, not once per installation.
+- On `BasePlugin`, read installation configuration with `self.get_config()`. In a component, use `self.get_plugin_config()` or `self.plugin.get_config()`.
+- Do not copy configuration, credentials, Workspace IDs, request data, or installation identity into instance fields or module globals.
+- Do not mutate the returned configuration. Runtime installs an immutable snapshot for each invocation; `get_config()` returns a compatibility copy.
+- Use SDK Host APIs for tenant storage, credentials, files, logging, models, tools, and RAG. Authority comes from the task-local `InstallationBinding`.
+- If identity is needed, call `get_installation_binding()` during an invocation. Do not retain it after the call returns.
+- Components must be re-entrant: invocations from different Workspaces may overlap on the same object.
+- Tenant-bearing background work is forbidden in `stateless-v1` until the SDK exposes an explicit ownership and revocation API. Do not create tenant-bearing threads or detached tasks in `initialize()` or an invocation.
+- Process-level caches may contain only public/artifact-level data. Tenant caches must include the full installation binding and be explicitly released on revocation.
+
+This contract deliberately matches a future serverless execution model: component methods depend on input plus invocation context, while tenant state remains in Host services. The current release still uses long-lived workers; it does not provide a serverless deployment mode.
+
+## Example
+
+```python
+class LookupTool(Tool):
+    async def initialize(self) -> None:
+        # Process-wide initialization only.
+        self.http = StatelessHTTPTransport()
+
+    async def call(self, params, **kwargs):
+        config = self.get_plugin_config()
+        # Fetch secrets through Host APIs in the current invocation.
+        return await self.http.lookup(config["endpoint"], params)
+```
+
+Do not write:
+
+```python
+async def initialize(self):
+    self.endpoint = self.plugin.config["endpoint"]
+    self.api_key = self.plugin.config["api_key"]
+```
+
+Shared initialization has no tenant config, so this captures empty/stale data or fails. Any attempt to retain invocation config on the shared object is a certification blocker.
+
+## Compatibility
+
+Legacy source and unsigned packages keep the dedicated worker and existing object/config semantics. In OSS, certificate failures may downgrade to dedicated according to admission policy; Cloud may reject an ineligible package before storage. The stateless rules are an opt-in certification contract. Adding only the manifest fields is insufficient: source review and concurrency tests must prove the implementation follows the contract.

{langbot_plugin-0.6.20 → langbot_plugin-0.7.0}/local_e2e/registration_fanin.py

@@ -144,8 +144,10 @@ async def parent() -> None:
                     process.stdin,
                     process=process,
                     reserve_first_message_decode=True,
+                    reserve_first_message_send=True,
                 ),
                 context,
+                certified_shared_stdio=True,
             )
             # Isolate codec admission from manager ownership details.
             handler.actions[PluginToRuntimeAction.REGISTER_PLUGIN.value] = (

{langbot_plugin-0.6.20 → langbot_plugin-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langbot-plugin"
-version = "0.6.20"
+version = "0.7.0"
 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.0/src/langbot_plugin/api/definition/components/base.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import abc
+import typing
+
+from langbot_plugin.api.definition.plugin import BasePlugin
+from langbot_plugin.api.proxies.invocation import current_binding, current_config
+
+
+class BaseComponent(abc.ABC):
+    """The abstract base class for all components."""
+
+    plugin: BasePlugin
+
+    def __init__(self):
+        pass
+
+    def get_plugin_config(self) -> dict[str, typing.Any]:
+        """Return the task-local installation config for stateless components."""
+
+        handler = getattr(getattr(self, "plugin", None), "plugin_runtime_handler", None)
+        scoped = current_config(handler)
+        if scoped is not None:
+            return dict(scoped)
+        plugin = getattr(self, "plugin", None)
+        return plugin.get_config() if plugin is not None else {}
+
+    def get_installation_binding(self):
+        """Return the active installation without storing tenant state on self."""
+
+        handler = getattr(getattr(self, "plugin", None), "plugin_runtime_handler", None)
+        return current_binding(handler)
+
+    async def initialize(self) -> None:
+        pass
+
+
+class NoneComponent(BaseComponent):
+    """The component that does nothing, just acts as a placeholder."""
+
+    def __init__(self):
+        super().__init__()
+
+    async def initialize(self) -> None:
+        pass

{langbot_plugin-0.6.20 → langbot_plugin-0.7.0}/src/langbot_plugin/api/definition/components/manifest.py

@@ -128,6 +128,12 @@ class Execution(pydantic.BaseModel):
     )
     """Certified shared runtime profile; absent manifests use a dedicated runtime."""
 
+    component_model: typing.Literal["stateless-v1"] | None = pydantic.Field(
+        default=None,
+        alias="componentModel",
+    )
+    """Singleton, task-local component contract required for certification."""
+
     @pydantic.model_validator(mode="before")
     @classmethod
     def _require_supported_shared_runtime_when_present(cls, values: typing.Any):

{langbot_plugin-0.6.20 → langbot_plugin-0.7.0}/src/langbot_plugin/api/definition/components/runner/runner.py

@@ -13,7 +13,11 @@ from langbot_plugin.api.entities.builtin.runner.result import RunnerResult
 from langbot_plugin.api.entities.builtin.platform.events import EBAEvent
 from langbot_plugin.api.proxies.runner.api import RunnerAPIProxy
 from langbot_plugin.api.proxies.runner.tracing import _TracedRunAPI
-from langbot_plugin.api.proxies.invocation import bind_invocation
+from langbot_plugin.api.proxies.invocation import (
+    bind_invocation,
+    current_binding,
+    current_config,
+)
 
 
 class Runner(BaseComponent):
@@ -40,6 +44,9 @@ class Runner(BaseComponent):
         self._plugin_identity = plugin_identity
 
     def get_plugin_config(self) -> dict[str, Any]:
+        scoped = current_config(self._plugin_runtime_handler)
+        if scoped is not None:
+            return dict(scoped)
         return dict(self._plugin_config)
 
     @property
@@ -118,7 +125,15 @@ class Runner(BaseComponent):
                 await results.put(RunnerResult.run_completed(ctx.run_id))
 
         async def execute_bound():
-            with bind_invocation(self._plugin_runtime_handler, ctx.api):
+            scoped_config = current_config(self._plugin_runtime_handler)
+            with bind_invocation(
+                self._plugin_runtime_handler,
+                ctx.api,
+                config=(
+                    self._plugin_config if scoped_config is None else scoped_config
+                ),
+                binding=current_binding(self._plugin_runtime_handler),
+            ):
                 await execute()
 
         task = asyncio.create_task(execute_bound())

langbot_plugin-0.7.0/src/langbot_plugin/api/definition/plugin.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import abc
+import typing
+
+from langbot_plugin.api.proxies import langbot_api
+from langbot_plugin.api.proxies.invocation import current_binding, current_config
+
+
+class BasePlugin(abc.ABC, langbot_api.LangBotAPIProxy):
+    """The base class for all plugins."""
+
+    _legacy_config: dict[str, typing.Any]
+
+    @property
+    def config(self) -> dict[str, typing.Any]:
+        """Expose task-local config while preserving dedicated plugin behavior."""
+
+        scoped = current_config(getattr(self, "plugin_runtime_handler", None))
+        if scoped is not None:
+            return dict(scoped)
+        return getattr(self, "_legacy_config", {})
+
+    @config.setter
+    def config(self, value: dict[str, typing.Any]) -> None:
+        self._legacy_config = dict(value)
+
+    def get_config(self) -> dict[str, typing.Any]:
+        """Return the active invocation config, or the legacy dedicated config."""
+
+        return self.config
+
+    def get_installation_binding(self):
+        """Return the active certified installation binding, if any."""
+
+        return current_binding(getattr(self, "plugin_runtime_handler", None))
+
+    def __init__(self):
+        self._legacy_config = {}
+
+    async def initialize(self) -> None:
+        pass
+
+    def __del__(self) -> None:
+        pass
+
+
+class NonePlugin(BasePlugin):
+    """The plugin that does nothing, just acts as a placeholder."""
+
+    def __init__(self):
+        super().__init__()

langbot_plugin-0.7.0/src/langbot_plugin/api/proxies/invocation.py

@@ -0,0 +1,155 @@
+"""Task-local API binding shared by plugin and component methods."""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+from contextvars import ContextVar
+from dataclasses import dataclass
+from functools import wraps
+import inspect
+from types import MappingProxyType
+from typing import Any, Mapping
+
+from langbot_plugin.entities.io.context import InstallationBinding
+
+
+def freeze_config(value: Any) -> Any:
+    """Return an immutable invocation snapshot without sharing tenant objects."""
+
+    if isinstance(value, Mapping):
+        return MappingProxyType(
+            {str(key): freeze_config(item) for key, item in value.items()}
+        )
+    if isinstance(value, (list, tuple)):
+        return tuple(freeze_config(item) for item in value)
+    if isinstance(value, (set, frozenset)):
+        return frozenset(freeze_config(item) for item in value)
+    return value
+
+
+def thaw_config(value: Any) -> Any:
+    """Return a recursively JSON-safe copy of an immutable config snapshot."""
+
+    if isinstance(value, Mapping):
+        return {str(key): thaw_config(item) for key, item in value.items()}
+    if isinstance(value, tuple):
+        return [thaw_config(item) for item in value]
+    if isinstance(value, frozenset):
+        return [thaw_config(item) for item in value]
+    return value
+
+
+@dataclass
+class Invocation:
+    handler: Any
+    api: Any
+    config: Mapping[str, Any] | None = None
+    binding: InstallationBinding | None = None
+    active: bool = True
+
+    def require_active(self) -> None:
+        if not self.active:
+            raise RuntimeError("Plugin invocation has ended")
+
+
+_current: ContextVar[Invocation | None] = ContextVar("plugin_invocation", default=None)
+
+
+@contextmanager
+def bind_invocation(
+    handler,
+    api=None,
+    *,
+    config: Mapping[str, Any] | None = None,
+    binding: InstallationBinding | None = None,
+):
+    invocation = Invocation(
+        handler,
+        api,
+        config=freeze_config(config or {}) if config is not None else None,
+        binding=binding,
+    )
+    token = _current.set(invocation)
+    try:
+        yield
+    finally:
+        invocation.active = False
+        _current.reset(token)
+
+
+def current_api(handler):
+    invocation = _current.get()
+    if invocation is None or invocation.handler is not handler:
+        return None
+    if not invocation.active:
+        raise RuntimeError("Runner invocation has ended")
+    return invocation.api
+
+
+def current_invocation(handler=None) -> Invocation | None:
+    """Return the active task-local invocation, rejecting escaped background work."""
+
+    invocation = _current.get()
+    if invocation is None:
+        return None
+    if handler is not None and invocation.handler is not handler:
+        return None
+    if not invocation.active:
+        raise RuntimeError("Plugin invocation has ended")
+    return invocation
+
+
+def invocation_capability(handler=None) -> Invocation | None:
+    """Return the current revocable authority object for outbound boundaries."""
+
+    invocation = _current.get()
+    if invocation is None or (
+        handler is not None and invocation.handler is not handler
+    ):
+        return None
+    invocation.require_active()
+    return invocation
+
+
+def current_config(handler=None) -> Mapping[str, Any] | None:
+    invocation = current_invocation(handler)
+    return None if invocation is None else invocation.config
+
+
+def current_binding(handler=None) -> InstallationBinding | None:
+    invocation = current_invocation(handler)
+    return None if invocation is None else invocation.binding
+
+
+def run_scoped(method):
+    """Use the same public method with the current Runner authorization, if any."""
+    signature = inspect.signature(method)
+
+    def target(instance, args, kwargs):
+        api = current_api(instance.plugin_runtime_handler)
+        if api is None:
+            return method, (instance, *args), kwargs
+        bound = signature.bind(instance, *args, **kwargs)
+        arguments = dict(bound.arguments)
+        arguments.pop("self")
+        if method.__name__ == "call_tool":
+            arguments.pop("session", None)
+            arguments.pop("query_id", None)
+        return getattr(api, method.__name__), (), arguments
+
+    if inspect.isasyncgenfunction(method):
+
+        @wraps(method)
+        async def stream(self, *args, **kwargs):
+            fn, positional, named = target(self, args, kwargs)
+            async for item in fn(*positional, **named):
+                yield item
+
+        return stream
+
+    @wraps(method)
+    async def call(self, *args, **kwargs):
+        fn, positional, named = target(self, args, kwargs)
+        return await fn(*positional, **named)
+
+    return call

{langbot_plugin-0.6.20 → langbot_plugin-0.7.0}/src/langbot_plugin/api/proxies/langbot_api.py

@@ -79,6 +79,7 @@ class LangBotAPIProxy:
             )
         )["version"]
 
+    @run_scoped
     async def get_bots(self) -> list[str]:
         """Get all bots"""
         return (
@@ -87,6 +88,7 @@ class LangBotAPIProxy:
             )
         )["bots"]
 
+    @run_scoped
     async def get_bot_info(self, bot_uuid: str) -> dict[str, Any]:
         """Get a bot info"""
         return (
@@ -343,6 +345,7 @@ class LangBotAPIProxy:
             PluginToRuntimeAction.DELETE_WORKSPACE_STORAGE, {"key": key}
         )
 
+    @run_scoped
     async def get_config_file(self, file_key: str) -> bytes:
         """Get a config file by file key
 
@@ -360,6 +363,7 @@ class LangBotAPIProxy:
 
         return base64.b64decode(resp)
 
+    @run_scoped
     async def list_plugins_manifest(self) -> list[str]:
         """List all plugins"""
         return (
@@ -368,6 +372,7 @@ class LangBotAPIProxy:
             )
         )["plugins"]
 
+    @run_scoped
     async def list_commands(self) -> list[str]:
         """List all commands"""
         return (
@@ -510,6 +515,7 @@ class LangBotAPIProxy:
             )
         )["results"]
 
+    @run_scoped
     async def vector_upsert(
         self,
         collection_id: str,
@@ -542,6 +548,7 @@ class LangBotAPIProxy:
             timeout=60,
         )
 
+    @run_scoped
     async def vector_search(
         self,
         collection_id: str,
@@ -586,6 +593,7 @@ class LangBotAPIProxy:
             )
         )["results"]
 
+    @run_scoped
     async def vector_delete(
         self,
         collection_id: str,
@@ -614,6 +622,7 @@ class LangBotAPIProxy:
             )
         )["count"]
 
+    @run_scoped
     async def vector_list(
         self,
         collection_id: str,
@@ -644,6 +653,7 @@ class LangBotAPIProxy:
             timeout=30,
         )
 
+    @run_scoped
     async def get_knowledge_file_stream(self, storage_path: str) -> bytes:
         """Get file content from Host's storage.
 
@@ -723,6 +733,7 @@ class LangBotAPIProxy:
 
     # ================= Parser Capability APIs =================
 
+    @run_scoped
     async def list_parsers(self, mime_type: str | None = None) -> list[dict[str, Any]]:
         """List available Parser plugins.
 
@@ -739,6 +750,7 @@ class LangBotAPIProxy:
             )
         )["parsers"]
 
+    @run_scoped
     async def invoke_parser(
         self,
         plugin_author: str,

{langbot_plugin-0.6.20 → langbot_plugin-0.7.0}/src/langbot_plugin/box/e2b_backend.py

@@ -6,6 +6,7 @@ import json
 import logging
 import os
 import posixpath
+import re
 import shlex
 
 from .backend import BaseSandboxBackend, _MAX_RAW_OUTPUT_BYTES
@@ -95,7 +96,7 @@ def _adapt_path_for_e2b(path: str) -> str:
 
 def _rewrite_command_paths_for_e2b(command: str) -> str:
     """Rewrite LangBot's logical /workspace paths for E2B's real writable path."""
-    return command.replace("/workspace", E2B_WORKSPACE_DIR)
+    return re.sub(r"(?<![\w.-])/workspace(?=$|/|[^\w.-])", E2B_WORKSPACE_DIR, command)
 
 
 class E2BSandboxBackend(BaseSandboxBackend):

{langbot_plugin-0.6.20 → langbot_plugin-0.7.0}/src/langbot_plugin/box/host_backend.py

@@ -13,7 +13,7 @@ import signal
 import tempfile
 import uuid
 
-from .backend import BaseSandboxBackend, _CommandResult, _MAX_RAW_OUTPUT_BYTES
+from .backend import BaseSandboxBackend, _CommandResult
 from .errors import BoxError, BoxValidationError
 from .models import (
     BoxExecutionResult,
@@ -357,39 +357,6 @@ class HostProcessBackend(BaseSandboxBackend):
                 pass
             await process.wait()
 
-    @staticmethod
-    async def _read_stream(
-        stream: asyncio.StreamReader | None,
-        limit: int = _MAX_RAW_OUTPUT_BYTES,
-    ) -> tuple[bytes, int]:
-        if stream is None:
-            return b"", 0
-        chunks = bytearray()
-        total_size = 0
-        while True:
-            chunk = await stream.read(65536)
-            if not chunk:
-                break
-            total_size += len(chunk)
-            remaining = limit - len(chunks)
-            if remaining > 0:
-                chunks.extend(chunk[:remaining])
-        return bytes(chunks), total_size
-
-    @staticmethod
-    def _clip_captured_bytes(
-        data: bytes,
-        total_size: int,
-        limit: int = _MAX_RAW_OUTPUT_BYTES,
-    ) -> str:
-        text = data.decode("utf-8", errors="replace").strip()
-        if total_size > limit:
-            text += (
-                f"\n... [raw output clipped at {limit} bytes, "
-                f"{total_size - limit} bytes discarded]"
-            )
-        return text
-
     @staticmethod
     def _preview(command: str) -> str:
         command = command.strip()

{langbot_plugin-0.6.20 → langbot_plugin-0.7.0}/src/langbot_plugin/box/nsjail_backend.py

@@ -15,7 +15,7 @@ from typing import Any
 
 from langbot_plugin.runtime import bounded_executor
 
-from .backend import BaseSandboxBackend, _CommandResult, _MAX_RAW_OUTPUT_BYTES
+from .backend import BaseSandboxBackend, _CommandResult
 from .models import (
     BoxExecutionResult,
     BoxExecutionStatus,
@@ -945,33 +945,3 @@ class NsjailBackend(BaseSandboxBackend):
                 self.logger.info(f"Killed orphaned nsjail process {pid}")
             except (OSError, ValueError):
                 continue
-
-    @staticmethod
-    def _clip_captured_bytes(
-        data: bytes, total_size: int, limit: int = _MAX_RAW_OUTPUT_BYTES
-    ) -> str:
-        text = data.decode("utf-8", errors="replace").strip()
-        if total_size > limit:
-            text += f"\n... [raw output clipped at {limit} bytes, {total_size - limit} bytes discarded]"
-        return text
-
-    @staticmethod
-    async def _read_stream(
-        stream: asyncio.StreamReader | None,
-        limit: int = _MAX_RAW_OUTPUT_BYTES,
-    ) -> tuple[bytes, int]:
-        if stream is None:
-            return b"", 0
-
-        chunks = bytearray()
-        total_size = 0
-        while True:
-            chunk = await stream.read(65536)
-            if not chunk:
-                break
-            total_size += len(chunk)
-            remaining = limit - len(chunks)
-            if remaining > 0:
-                chunks.extend(chunk[:remaining])
-
-        return bytes(chunks), total_size