meshagent-cli 0.35.3__tar.gz → 0.35.4__tar.gz

{meshagent_cli-0.35.3 → meshagent_cli-0.35.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-cli
-Version: 0.35.3
+Version: 0.35.4
 Summary: CLI for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -19,21 +19,21 @@ Requires-Dist: rich~=14.3.0
 Requires-Dist: textual<2.0,>=0.50
 Requires-Dist: prompt-toolkit~=3.0.52
 Provides-Extra: all
-Requires-Dist: meshagent-agents[all]~=0.35.3; extra == "all"
-Requires-Dist: meshagent-api[all]~=0.35.3; extra == "all"
-Requires-Dist: meshagent-computers~=0.35.3; extra == "all"
-Requires-Dist: meshagent-openai~=0.35.3; extra == "all"
-Requires-Dist: meshagent-anthropic~=0.35.3; extra == "all"
-Requires-Dist: meshagent-codex~=0.35.3; extra == "all"
-Requires-Dist: meshagent-mcp~=0.35.3; extra == "all"
-Requires-Dist: meshagent-tools~=0.35.3; extra == "all"
+Requires-Dist: meshagent-agents[all]~=0.35.4; extra == "all"
+Requires-Dist: meshagent-api[all]~=0.35.4; extra == "all"
+Requires-Dist: meshagent-computers~=0.35.4; extra == "all"
+Requires-Dist: meshagent-openai~=0.35.4; extra == "all"
+Requires-Dist: meshagent-anthropic~=0.35.4; extra == "all"
+Requires-Dist: meshagent-codex~=0.35.4; extra == "all"
+Requires-Dist: meshagent-mcp~=0.35.4; extra == "all"
+Requires-Dist: meshagent-tools~=0.35.4; extra == "all"
 Requires-Dist: supabase-auth~=2.28.0; extra == "all"
 Requires-Dist: prompt-toolkit~=3.0.52; extra == "all"
 Provides-Extra: mcp-service
-Requires-Dist: meshagent-agents[all]~=0.35.3; extra == "mcp-service"
-Requires-Dist: meshagent-api~=0.35.3; extra == "mcp-service"
-Requires-Dist: meshagent-mcp~=0.35.3; extra == "mcp-service"
-Requires-Dist: meshagent-tools~=0.35.3; extra == "mcp-service"
+Requires-Dist: meshagent-agents[all]~=0.35.4; extra == "mcp-service"
+Requires-Dist: meshagent-api~=0.35.4; extra == "mcp-service"
+Requires-Dist: meshagent-mcp~=0.35.4; extra == "mcp-service"
+Requires-Dist: meshagent-tools~=0.35.4; extra == "mcp-service"
 Requires-Dist: supabase-auth~=2.28.0; extra == "mcp-service"
 
 # [Meshagent](https://www.meshagent.com)

{meshagent_cli-0.35.3 → meshagent_cli-0.35.4}/meshagent/cli/chatbot.py

@@ -9,6 +9,7 @@ from meshagent.tools import (
     WebFetchTool,
     WebFetchToolkitBuilder,
     ContainerShellTool,
+    ContainerToolkit,
     MemoriesToolkit,
 )
 from meshagent.tools.storage import (
@@ -52,6 +53,7 @@ from meshagent.api import (
 from meshagent.api.helpers import meshagent_base_url, websocket_room_url
 from meshagent.cli import async_typer
 from meshagent.cli.helper import (
+    build_shell_tool,
     build_shell_toolkit_builder,
     cleanup_args,
     cleanup_args_strip_options,
@@ -186,6 +188,14 @@ ShellSetEnvOption = Annotated[
     ),
 ]
 
+RequireAdvancedShellOption = Annotated[
+    Optional[bool],
+    typer.Option(
+        "--require-advanced-shell",
+        help=("Enable the managed container toolkit with start/list/stop/run tools."),
+    ),
+]
+
 WORKING_DIR_HELP = "The default working directory for shell commands"
 
 WorkingDirOption = Annotated[
@@ -527,6 +537,20 @@ def _set_shell_env_vars(*, set_env: Optional[list[str]]) -> dict[str, str]:
     return env
 
 
+def _build_shell_tool_env(
+    *,
+    base_env: dict[str, str],
+    delegate_shell_token: Optional[bool],
+    room: RoomClient,
+) -> dict[str, str]:
+    env = dict(base_env)
+    if delegate_shell_token:
+        env["MESHAGENT_TOKEN"] = room.protocol.token
+        env["OPENAI_API_KEY"] = room.protocol.token
+        env["ANTHROPIC_API_KEY"] = room.protocol.token
+    return env
+
+
 def _resolve_working_dir_option(
     *,
     working_dir: Optional[str],
@@ -565,6 +589,7 @@ def build_chatbot(
     require_image_generation: Optional[str] = None,
     require_local_shell: Optional[str] = None,
     require_shell: Optional[bool] = None,
+    require_advanced_shell: Optional[bool] = None,
     require_apply_patch: Optional[str] = None,
     require_computer_use: Optional[str] = None,
     starting_url: Optional[str] = None,
@@ -707,16 +732,16 @@ def build_chatbot(
             )
 
             self.shell_tool = None
+            self.advanced_shell_toolkit = None
 
         async def start(self, *, room: RoomClient):
             await super().start(room=room)
 
-            env = dict(base_shell_env)
-
-            if delegate_shell_token:
-                env["MESHAGENT_TOKEN"] = self.room.protocol.token
-                env["OPENAI_API_KEY"] = self.room.protocol.token
-                env["ANTHROPIC_API_KEY"] = self.room.protocol.token
+            env = _build_shell_tool_env(
+                base_env=base_shell_env,
+                delegate_shell_token=delegate_shell_token,
+                room=room,
+            )
 
             if require_shell:
                 if supports_openai_shell:
@@ -733,6 +758,7 @@ def build_chatbot(
                     shell_kwargs = {
                         "image": resolved_shell_image,
                         "name": "shell",
+                        "working_dir": working_dir,
                         "env": env,
                     }
                     if shell_tool_mounts is not None:
@@ -740,10 +766,28 @@ def build_chatbot(
 
                     self.shell_tool = ContainerShellTool(**shell_kwargs)
 
+            if require_advanced_shell:
+                self.advanced_shell_toolkit = ContainerToolkit(
+                    working_dir=working_dir,
+                    default_image=resolved_shell_image,
+                    mounts=shell_tool_mounts,
+                    env=env or None,
+                )
+
             if room_rules_path is not None:
                 for p in room_rules_path:
                     await self._load_room_rules(path=p)
 
+        async def stop(self) -> None:
+            room = self._room
+            try:
+                if self.advanced_shell_toolkit is not None and room is not None:
+                    await self.advanced_shell_toolkit.stop_all(room=room)
+            finally:
+                self.advanced_shell_toolkit = None
+                self.shell_tool = None
+                await super().stop()
+
         async def init_session(self):
             from meshagent.cli.helper import init_context_from_spec
 
@@ -854,6 +898,8 @@ def build_chatbot(
 
             if self.shell_tool is not None:
                 add_tool(toolkit_name=self.shell_tool.name, tool=self.shell_tool)
+            if self.advanced_shell_toolkit is not None:
+                add_toolkit(self.advanced_shell_toolkit)
             if require_mcp:
                 raise Exception(
                     "mcp tool cannot be required by cli currently, use 'optional' instead"
@@ -991,7 +1037,7 @@ def build_chatbot(
                     shell_builder_kwargs["mounts"] = shell_tool_mounts
                 providers.append(
                     build_shell_toolkit_builder(
-                        use_openai_shell_tool=supports_openai_shell,
+                        llm_participant=llm_participant,
                         **shell_builder_kwargs,
                     )
                 )
@@ -1044,6 +1090,7 @@ def build_process_agent(
     require_image_generation: Optional[str] = None,
     require_local_shell: Optional[str] = None,
     require_shell: Optional[bool] = None,
+    require_advanced_shell: Optional[bool] = None,
     require_apply_patch: Optional[str] = None,
     require_computer_use: Optional[str] = None,
     starting_url: Optional[str] = None,
@@ -1117,9 +1164,6 @@ def build_process_agent(
 
     is_claude_model = model.startswith("claude-")
     supports_openai_tools = llm_participant is None and not is_claude_model
-    supports_openai_shell = supports_openai_shell_tool(
-        model=model, llm_participant=llm_participant
-    )
     base_shell_env = _copy_shell_env_vars(copy_env=shell_copy_env)
     base_shell_env.update(_set_shell_env_vars(set_env=shell_set_env))
     resolved_shell_image = resolve_shell_image(shell_image)
@@ -1192,7 +1236,8 @@ def build_process_agent(
             self._mail_channels: list[MailChannel] = []
             self._queue_channels: list[QueueChannel] = []
             self._toolkit_channels: list[ToolkitChannel] = []
-            self._shell_tool: ShellTool | ContainerShellTool | None = None
+            self._shell_env: dict[str, str] = dict(base_shell_env)
+            self._advanced_shell_toolkit: ContainerToolkit | None = None
             self._resolved_threading_mode: str | None = None
             if threading_mode != "none":
                 self._resolved_threading_mode = threading_mode
@@ -1272,32 +1317,22 @@ def build_process_agent(
             try:
                 await self.install_requirements()
 
-                env = dict(base_shell_env)
-                if delegate_shell_token:
-                    env["MESHAGENT_TOKEN"] = self.room.protocol.token
-                    env["OPENAI_API_KEY"] = self.room.protocol.token
-                    env["ANTHROPIC_API_KEY"] = self.room.protocol.token
+                env = _build_shell_tool_env(
+                    base_env=base_shell_env,
+                    delegate_shell_token=delegate_shell_token,
+                    room=room,
+                )
 
                 if require_shell:
-                    if supports_openai_shell:
-                        shell_kwargs = {
-                            "working_dir": working_dir,
-                            "config": ShellConfig(name="shell"),
-                            "image": resolved_shell_image,
-                            "env": env,
-                        }
-                        if shell_tool_mounts is not None:
-                            shell_kwargs["mounts"] = shell_tool_mounts
-                        self._shell_tool = ShellTool(**shell_kwargs)
-                    else:
-                        shell_kwargs = {
-                            "image": resolved_shell_image,
-                            "name": "shell",
-                            "env": env,
-                        }
-                        if shell_tool_mounts is not None:
-                            shell_kwargs["mounts"] = shell_tool_mounts
-                        self._shell_tool = ContainerShellTool(**shell_kwargs)
+                    self._shell_env = env
+
+                if require_advanced_shell:
+                    self._advanced_shell_toolkit = ContainerToolkit(
+                        working_dir=working_dir,
+                        default_image=resolved_shell_image,
+                        mounts=shell_tool_mounts,
+                        env=env or None,
+                    )
 
                 if room_rules_path is not None:
                     for room_rules_file in room_rules_path:
@@ -1330,6 +1365,7 @@ def build_process_agent(
                 self._mail_channels = []
                 self._queue_channels = []
                 self._toolkit_channels = []
+                self._advanced_shell_toolkit = None
                 self._room = None
                 raise
 
@@ -1342,7 +1378,14 @@ def build_process_agent(
             self._mail_channels = []
             self._queue_channels = []
             self._toolkit_channels = []
-            await super().stop()
+            room = self._room
+            try:
+                if self._advanced_shell_toolkit is not None and room is not None:
+                    await self._advanced_shell_toolkit.stop_all(room=room)
+            finally:
+                self._advanced_shell_toolkit = None
+                self._shell_env = dict(base_shell_env)
+                await super().stop()
 
         async def init_session(self) -> AgentSessionContext:
             from meshagent.cli.helper import init_context_from_spec
@@ -1447,7 +1490,7 @@ def build_process_agent(
                     shell_builder_kwargs["mounts"] = shell_tool_mounts
                 providers.append(
                     build_shell_toolkit_builder(
-                        use_openai_shell_tool=supports_openai_shell,
+                        llm_participant=llm_participant,
                         **shell_builder_kwargs,
                     )
                 )
@@ -1524,8 +1567,22 @@ def build_process_agent(
                     ),
                 )
 
-            if self._shell_tool is not None:
-                add_tool(toolkit_name=self._shell_tool.name, tool=self._shell_tool)
+            if require_shell:
+                shell_config = ShellConfig(name="shell")
+                add_tool(
+                    toolkit_name=shell_config.name,
+                    tool=build_shell_tool(
+                        model=model,
+                        llm_participant=llm_participant,
+                        config=shell_config,
+                        working_dir=working_dir,
+                        image=resolved_shell_image,
+                        mounts=shell_tool_mounts,
+                        env=self._shell_env,
+                    ),
+                )
+            if self._advanced_shell_toolkit is not None:
+                add_toolkit(self._advanced_shell_toolkit)
 
             if require_mcp:
                 raise Exception(
@@ -1851,6 +1908,7 @@ async def join(
         Optional[bool],
         typer.Option(..., help="Enable function shell tool calling"),
     ] = False,
+    require_advanced_shell: RequireAdvancedShellOption = False,
     require_apply_patch: Annotated[
         Optional[bool],
         typer.Option(..., help="Enable apply patch tool calling"),
@@ -2056,6 +2114,7 @@ async def join(
             require_web_fetch=require_web_fetch,
             require_local_shell=require_local_shell,
             require_shell=require_shell,
+            require_advanced_shell=require_advanced_shell,
             require_image_generation=require_image_generation,
             require_mcp=require_mcp,
             require_storage=require_storage,
@@ -2244,6 +2303,7 @@ async def service(
         Optional[bool],
         typer.Option(..., help="Enable function shell tool calling"),
     ] = False,
+    require_advanced_shell: RequireAdvancedShellOption = False,
     require_apply_patch: Annotated[
         Optional[bool], typer.Option(..., help="Enable apply patch tool")
     ] = False,
@@ -2434,6 +2494,7 @@ async def service(
             require_web_search=require_web_search,
             require_web_fetch=require_web_fetch,
             require_shell=require_shell,
+            require_advanced_shell=require_advanced_shell,
             require_apply_patch=require_apply_patch,
             require_local_shell=require_local_shell,
             require_image_generation=require_image_generation,
@@ -2596,6 +2657,7 @@ async def spec(
         Optional[bool],
         typer.Option(..., help="Enable function shell tool calling"),
     ] = False,
+    require_advanced_shell: RequireAdvancedShellOption = False,
     require_apply_patch: Annotated[
         Optional[bool], typer.Option(..., help="Enable apply patch tool")
     ] = False,
@@ -2776,6 +2838,7 @@ async def spec(
             require_web_search=require_web_search,
             require_web_fetch=require_web_fetch,
             require_shell=require_shell,
+            require_advanced_shell=require_advanced_shell,
             require_apply_patch=require_apply_patch,
             require_local_shell=require_local_shell,
             require_image_generation=require_image_generation,
@@ -2958,6 +3021,7 @@ async def deploy(
         Optional[bool],
         typer.Option(..., help="Enable function shell tool calling"),
     ] = False,
+    require_advanced_shell: RequireAdvancedShellOption = False,
     require_apply_patch: Annotated[
         Optional[bool], typer.Option(..., help="Enable apply patch tool")
     ] = False,
@@ -3145,6 +3209,7 @@ async def deploy(
             require_web_search=require_web_search,
             require_web_fetch=require_web_fetch,
             require_shell=require_shell,
+            require_advanced_shell=require_advanced_shell,
             require_apply_patch=require_apply_patch,
             require_local_shell=require_local_shell,
             require_image_generation=require_image_generation,
@@ -4824,6 +4889,7 @@ async def run(
         Optional[bool],
         typer.Option(..., help="Enable function shell tool calling"),
     ] = False,
+    require_advanced_shell: RequireAdvancedShellOption = False,
     require_apply_patch: Annotated[
         Optional[bool],
         typer.Option(..., help="Enable apply patch tool calling"),
@@ -5053,6 +5119,7 @@ async def run(
             require_web_fetch=require_web_fetch,
             require_local_shell=require_local_shell,
             require_shell=require_shell,
+            require_advanced_shell=require_advanced_shell,
             require_image_generation=require_image_generation,
             require_mcp=require_mcp,
             require_storage=require_storage,

{meshagent_cli-0.35.3 → meshagent_cli-0.35.4}/meshagent/cli/cli.py

@@ -86,18 +86,18 @@ app.add_typer(routes.app, name="route")
 app.add_typer(scheduled_tasks.app, name="scheduled-task")
 app.add_typer(meeting_transcriber.app, name="meeting-transcriber")
 app.add_typer(port.app, name="port")
-app.add_typer(webserver.app, name="webserver")
-app.add_typer(codex.app, name="codex")
+app.add_typer(webserver.app, name="webserver", hidden=True)
+app.add_typer(codex.app, name="codex", hidden=True)
 if not os.getenv("MESHAGENT_CLI_BUILD"):
     app.add_typer(test.app, name="test", hidden=True)
 
 app.add_typer(multi.app, name="multi")
 app.add_typer(voicebot.app, name="voicebot")
-app.add_typer(chatbot.app, name="chatbot")
+app.add_typer(chatbot.app, name="chatbot", hidden=True)
 app.add_typer(process.app, name="process")
-app.add_typer(mailbot.app, name="mailbot")
-app.add_typer(task_runner.app, name="task-runner")
-app.add_typer(worker.app, name="worker")
+app.add_typer(mailbot.app, name="mailbot", hidden=True)
+app.add_typer(task_runner.app, name="task-runner", hidden=True)
+app.add_typer(worker.app, name="worker", hidden=True)
 
 app.add_typer(room.app, name="room")
 app.add_typer(image.app, name="image")

{meshagent_cli-0.35.3 → meshagent_cli-0.35.4}/meshagent/cli/containers.py

@@ -605,7 +605,6 @@ async def exec_container(
         Optional[str],
         typer.Option(..., help="Command to execute in the container (quoted string)"),
     ] = None,
-    tty: Annotated[bool, typer.Option(..., help="Allocate a TTY")] = False,
 ):
     account_client, client = await _with_client(
         project_id=project_id,
@@ -614,16 +613,13 @@ async def exec_container(
     result = 1
 
     try:
-        import termios
         import shlex
 
-        from contextlib import contextmanager
-
         parsed_command = shlex.split(command) if command else None
         container = await client.containers.exec(
             container_id=container_id,
             command=parsed_command,
-            tty=tty,
+            tty=False,
         )
 
         async def write_all(fd, data: bytes) -> None:
@@ -650,17 +646,6 @@ async def exec_container(
             async for output in container.stdout():
                 await write_all(sys.stdout.fileno(), output)
 
-        @contextmanager
-        def raw_mode(fd: int):
-            import tty
-
-            old = termios.tcgetattr(fd)
-            try:
-                tty.setraw(fd)  # immediate bytes
-                yield
-            finally:
-                termios.tcsetattr(fd, termios.TCSADRAIN, old)
-
         async def read_piped_stdin(bufsize: int = 1024):
             while True:
                 chunk = await asyncio.to_thread(sys.stdin.buffer.read, bufsize)
@@ -671,53 +656,11 @@ async def exec_container(
 
                 await container.write(chunk)
 
-        async def read_stdin(bufsize: int = 1024):
-            # If stdin is piped, just read normally (blocking is fine; no TTY semantics)
-            if not sys.stdin.isatty():
-                while True:
-                    chunk = sys.stdin.buffer.read(bufsize)
-                    if not chunk:
-                        return
-                    await container.write(chunk)
-                return
-
-            fd = sys.stdin.fileno()
-
-            # Make reads non-blocking so we never hang shutdown
-            prev_blocking = os.get_blocking(fd)
-            os.set_blocking(fd, False)
-
-            try:
-                with raw_mode(fd):
-                    while True:
-                        try:
-                            chunk = os.read(fd, bufsize)
-                        except BlockingIOError:
-                            # nothing typed yet
-                            await asyncio.sleep(0.01)
-                            continue
-
-                        if chunk == b"":
-                            return
-
-                        # optional: allow Ctrl-C to exit
-                        if chunk == b"\x03":
-                            return
-
-                        await container.write(chunk)
-            finally:
-                os.set_blocking(fd, prev_blocking)
-
-        if not tty and not sys.stdin.isatty():
-            await asyncio.gather(read_stdout(), read_stderr(), read_piped_stdin())
-        else:
-            if not sys.stdin.isatty():
-                print("[red]TTY requested but not a TTY[/red]")
-                raise typer.Exit(-1)
-
-            reader = asyncio.create_task(read_stdin())
+        if sys.stdin.isatty():
+            await container.close_stdin()
             await asyncio.gather(read_stdout(), read_stderr())
-            reader.cancel()
+        else:
+            await asyncio.gather(read_stdout(), read_stderr(), read_piped_stdin())
 
         result = await container.result
     finally:

{meshagent_cli-0.35.3 → meshagent_cli-0.35.4}/meshagent/cli/helper.py

@@ -21,8 +21,13 @@ from meshagent.api.specs.service import (
 from meshagent.agents.context import AgentSessionContext
 from meshagent.api.client import Meshagent, RoomConnectionInfo
 from meshagent.cli import async_typer, auth_async
-from meshagent.openai.tools.responses_adapter import ShellConfig, ShellToolkitBuilder
-from meshagent.tools import ContainerShellTool, Toolkit, ToolkitBuilder
+from meshagent.openai.tools.responses_adapter import ShellConfig, ShellTool
+from meshagent.tools import (
+    ContainerShellTool,
+    ProcessShellTool,
+    Toolkit,
+    ToolkitBuilder,
+)
 from meshagent.tools.container_shell import DEFAULT_CONTAINER_MOUNT_SPEC
 from meshagent.tools.storage import (
     StorageToolLocalMount,
@@ -64,16 +69,56 @@ def supports_openai_shell_tool(
     return llm_participant is None and model.startswith("gpt-")
 
 
-class _ContainerBackedShellToolkitBuilder(ToolkitBuilder):
+def build_shell_tool(
+    *,
+    model: str,
+    llm_participant: Optional[str] = None,
+    config: Optional[ShellConfig] = None,
+    working_dir: Optional[str] = None,
+    image: Optional[str] = DEFAULT_SHELL_IMAGE,
+    mounts: Optional[ContainerMountSpec] = DEFAULT_CONTAINER_MOUNT_SPEC,
+    env: Optional[dict[str, str]] = None,
+) -> ShellTool | ContainerShellTool | ProcessShellTool:
+    if config is None:
+        config = ShellConfig(name="shell")
+
+    if supports_openai_shell_tool(model=model, llm_participant=llm_participant):
+        return ShellTool(
+            config=config,
+            working_dir=working_dir,
+            image=image,
+            mounts=mounts,
+            env=env,
+        )
+
+    if image is None:
+        return ProcessShellTool(
+            name=config.name,
+            working_dir=working_dir,
+            env=env,
+        )
+
+    return ContainerShellTool(
+        name=config.name,
+        working_dir=working_dir,
+        image=image,
+        mounts=mounts,
+        env=env,
+    )
+
+
+class _RuntimeAwareShellToolkitBuilder(ToolkitBuilder):
     def __init__(
         self,
         *,
+        llm_participant: Optional[str] = None,
         working_dir: Optional[str] = None,
         image: Optional[str] = DEFAULT_SHELL_IMAGE,
         mounts: Optional[ContainerMountSpec] = DEFAULT_CONTAINER_MOUNT_SPEC,
         env: Optional[dict[str, str]] = None,
     ) -> None:
         super().__init__(name="shell", type=ShellConfig)
+        self.llm_participant = llm_participant
         self.working_dir = working_dir
         self.image = image
         self.mounts = mounts
@@ -83,13 +128,13 @@ class _ContainerBackedShellToolkitBuilder(ToolkitBuilder):
         self, *, room: RoomClient, model: str, config: ShellConfig
     ) -> Toolkit:
         del room
-        del model
-        del config
         return Toolkit(
             name="shell",
             tools=[
-                ContainerShellTool(
-                    name="shell",
+                build_shell_tool(
+                    model=model,
+                    llm_participant=self.llm_participant,
+                    config=config,
                     working_dir=self.working_dir,
                     image=self.image,
                     mounts=self.mounts,
@@ -101,21 +146,14 @@ class _ContainerBackedShellToolkitBuilder(ToolkitBuilder):
 
 def build_shell_toolkit_builder(
     *,
-    use_openai_shell_tool: bool,
+    llm_participant: Optional[str] = None,
     working_dir: Optional[str] = None,
     image: Optional[str] = DEFAULT_SHELL_IMAGE,
     mounts: Optional[ContainerMountSpec] = DEFAULT_CONTAINER_MOUNT_SPEC,
     env: Optional[dict[str, str]] = None,
 ) -> ToolkitBuilder:
-    if use_openai_shell_tool:
-        return ShellToolkitBuilder(
-            working_dir=working_dir,
-            image=image,
-            mounts=mounts,
-            env=env,
-        )
-
-    return _ContainerBackedShellToolkitBuilder(
+    return _RuntimeAwareShellToolkitBuilder(
+        llm_participant=llm_participant,
         working_dir=working_dir,
         image=image,
         mounts=mounts,