meshagent-cli 0.7.0__py3-none-any.whl → 0.23.0__py3-none-any.whl

meshagent/cli/chatbot.py

@@ -1,9 +1,16 @@
 import typer
 from rich import print
-from typing import Annotated, Optional
-from meshagent.tools import Toolkit
-from meshagent.tools.storage import StorageToolkitBuilder
+from typing import Annotated, Optional, List
+from meshagent.tools import Toolkit, ToolkitConfig
+from meshagent.tools.storage import StorageToolkitBuilder, StorageToolkitConfig
+from meshagent.tools.datetime import DatetimeToolkit
+from meshagent.tools.uuid import UUIDToolkit
+from meshagent.tools.document_tools import (
+    DocumentAuthoringToolkit,
+    DocumentTypeAuthoringToolkit,
+)
 from meshagent.agents.config import RulesConfig
+from meshagent.agents.widget_schema import widget_schema
 
 from meshagent.cli.common_options import (
     ProjectIdOption,
@@ -15,6 +22,7 @@ from meshagent.api import (
     ParticipantToken,
     ApiScope,
     RoomException,
+    RemoteParticipant,
 )
 from meshagent.api.helpers import meshagent_base_url, websocket_room_url
 from meshagent.cli import async_typer
@@ -23,11 +31,12 @@ from meshagent.cli.helper import (
     resolve_project_id,
     resolve_room,
     resolve_key,
+    cleanup_args,
 )
 
 from meshagent.openai import OpenAIResponsesAdapter
+from meshagent.anthropic import AnthropicOpenAIResponsesStreamAdapter
 
-from typing import List
 from pathlib import Path
 
 from meshagent.openai.tools.responses_adapter import (
@@ -40,13 +49,36 @@ from meshagent.openai.tools.responses_adapter import (
     ApplyPatchConfig,
     ApplyPatchTool,
     ApplyPatchToolkitBuilder,
+    ShellToolkitBuilder,
+    ShellTool,
+    LocalShellToolkitBuilder,
+    LocalShellTool,
+    ImageGenerationConfig,
+    ImageGenerationToolkitBuilder,
+    ImageGenerationTool,
 )
 
+from meshagent.tools.database import DatabaseToolkitBuilder, DatabaseToolkitConfig
+from meshagent.agents.adapter import MessageStreamLLMAdapter
+
 from meshagent.api import RequiredToolkit, RequiredSchema
-from meshagent.api.services import ServiceHost
 import logging
 import os.path
 
+from meshagent.api.specs.service import AgentSpec, ANNOTATION_AGENT_TYPE
+
+from meshagent.cli.host import get_service, run_services, get_deferred, service_specs
+
+import yaml
+
+import shlex
+import sys
+
+import asyncio
+
+
+from meshagent.api.client import ConflictError
+
 logger = logging.getLogger("chatbot")
 
 app = async_typer.AsyncTyper(help="Join a chatbot to a room")
@@ -55,7 +87,6 @@ app = async_typer.AsyncTyper(help="Join a chatbot to a room")
 def build_chatbot(
     *,
     model: str,
-    agent_name: str,
     rule: List[str],
     toolkit: List[str],
     schema: List[str],
@@ -69,30 +100,34 @@ def build_chatbot(
     storage: Optional[str] = None,
     require_image_generation: Optional[str] = None,
     require_local_shell: Optional[str] = None,
-    require_shell: Optional[str] = None,
+    require_shell: Optional[bool] = None,
     require_apply_patch: Optional[str] = None,
     require_computer_use: Optional[str] = None,
     require_web_search: Optional[str] = None,
     require_mcp: Optional[str] = None,
     require_storage: Optional[str] = None,
+    require_table_read: list[str] = None,
+    require_table_write: list[str] = None,
+    require_read_only_storage: Optional[str] = None,
+    require_time: bool = True,
+    require_uuid: bool = False,
     rules_file: Optional[str] = None,
-    room_rules_path: Optional[str] = None,
+    room_rules_path: Optional[list[str]] = None,
+    require_discovery: Optional[str] = None,
+    require_document_authoring: Optional[str] = None,
     working_directory: Optional[str] = None,
+    llm_participant: Optional[str] = None,
+    database_namespace: Optional[list[str]] = None,
+    always_reply: Optional[bool] = None,
+    skill_dirs: Optional[list[str]] = None,
+    shell_image: Optional[str] = None,
+    log_llm_requests: Optional[bool] = None,
+    delegate_shell_token: Optional[bool] = None,
 ):
     from meshagent.agents.chat import ChatBot
 
     from meshagent.tools.storage import StorageToolkit
 
-    from meshagent.agents.chat import (
-        ChatBotThreadOpenAIImageGenerationToolkitBuilder,
-        ChatBotThreadLocalShellToolkitBuilder,
-        ChatBotThreadOpenAIImageGenerationTool,
-        ChatBotThreadLocalShellTool,
-        ChatBotThreadShellTool,
-        ChatBotThreadShellToolkitBuilder,
-        ImageGenerationConfig,
-    )
-
     requirements = []
 
     toolkits = []
@@ -109,44 +144,113 @@ def build_chatbot(
         try:
             with open(Path(os.path.expanduser(rules_file)).resolve(), "r") as f:
                 rules_config = RulesConfig.parse(f.read())
-                rule = rules_config.rules
+                rule.extend(rules_config.rules)
                 client_rules = rules_config.client_rules
 
         except FileNotFoundError:
             print(f"[yellow]rules file not found at {rules_file}[/yellow]")
 
     BaseClass = ChatBot
-    if computer_use:
-        from meshagent.computers.agent import ComputerAgent
-
-        if ComputerAgent is None:
-            raise RuntimeError(
-                "Computer use is enabled, but meshagent.computers is not installed."
-            )
-        BaseClass = ComputerAgent
-        llm_adapter = OpenAIResponsesAdapter(
-            model=model,
-            response_options={
-                "reasoning": {"generate_summary": "concise"},
-                "truncation": "auto",
-            },
+    decision_model = None
+    if llm_participant:
+        llm_adapter = MessageStreamLLMAdapter(
+            participant_name=llm_participant,
         )
     else:
-        llm_adapter = OpenAIResponsesAdapter(
-            model=model,
-        )
+        if computer_use or require_computer_use:
+            llm_adapter = OpenAIResponsesAdapter(
+                model=model,
+                response_options={
+                    "reasoning": {"summary": "concise"},
+                    "truncation": "auto",
+                },
+                log_requests=log_llm_requests,
+            )
+        else:
+            if model.startswith("claude-"):
+                llm_adapter = AnthropicOpenAIResponsesStreamAdapter(
+                    model=model,
+                    log_requests=log_llm_requests,
+                )
+                decision_model = model
+            else:
+                llm_adapter = OpenAIResponsesAdapter(
+                    model=model,
+                    log_requests=log_llm_requests,
+                )
 
     class CustomChatbot(BaseClass):
         def __init__(self):
             super().__init__(
                 llm_adapter=llm_adapter,
-                name=agent_name,
                 requires=requirements,
                 toolkits=toolkits,
                 rules=rule if len(rule) > 0 else None,
                 client_rules=client_rules,
+                always_reply=always_reply,
+                skill_dirs=skill_dirs,
+                decision_model=decision_model,
             )
 
+        async def start(self, *, room: RoomClient):
+            await super().start(room=room)
+
+            if room_rules_path is not None:
+                for p in room_rules_path:
+                    await self._load_room_rules(path=p)
+
+        async def init_chat_context(self):
+            from meshagent.cli.helper import init_context_from_spec
+
+            context = await super().init_chat_context()
+            await init_context_from_spec(context)
+
+            return context
+
+        async def _load_room_rules(
+            self,
+            *,
+            path: str,
+            participant: Optional[RemoteParticipant] = None,
+        ):
+            rules = []
+            try:
+                room_rules = await self.room.storage.download(path=path)
+
+                rules_txt = room_rules.data.decode()
+
+                rules_config = RulesConfig.parse(rules_txt)
+
+                if rules_config.rules is not None:
+                    rules.extend(rules_config.rules)
+
+                if participant is not None:
+                    client = participant.get_attribute("client")
+
+                    if rules_config.client_rules is not None and client is not None:
+                        cr = rules_config.client_rules.get(client)
+                        if cr is not None:
+                            rules.extend(cr)
+
+            except RoomException:
+                try:
+                    logger.info("attempting to initialize rules file")
+                    handle = await self.room.storage.open(path=path, overwrite=False)
+                    await self.room.storage.write(
+                        handle=handle,
+                        data="# Add rules to this file to customize your agent's behavior, lines starting with # will be ignored.\n\n".encode(),
+                    )
+                    await self.room.storage.close(handle=handle)
+
+                except RoomException:
+                    pass
+                logger.info(
+                    f"unable to load rules from {path}, continuing with default rules"
+                )
+                pass
+
+            return rules
+
         async def get_rules(self, *, thread_context, participant):
             rules = await super().get_rules(
                 thread_context=thread_context, participant=participant
@@ -154,43 +258,11 @@ def build_chatbot(
 
             if room_rules_path is not None:
                 for p in room_rules_path:
-                    try:
-                        room_rules = await self.room.storage.download(path=p)
-
-                        rules_txt = room_rules.data.decode()
-
-                        rules_config = RulesConfig.parse(rules_txt)
-
-                        if rules_config.rules is not None:
-                            rules.extend(rules_config.rules)
-
-                        client = participant.get_attribute("client")
-
-                        if rules_config.client_rules is not None and client is not None:
-                            cr = rules_config.client_rules.get(client)
-                            if cr is not None:
-                                rules.extend(cr)
-
-                    except RoomException:
-                        try:
-                            logger.info("attempting to initialize rules file")
-                            handle = await self.room.storage.open(
-                                path=p, overwrite=False
-                            )
-                            await self.room.storage.write(
-                                handle=handle,
-                                data="# Add rules to this file to customize your agent's behavior, lines starting with # will be ignored.\n\n".encode(),
-                            )
-                            await self.room.storage.close(handle=handle)
-
-                        except RoomException:
-                            pass
-                        logger.info(
-                            f"unable to load rules from {room_rules_path}, continuing with default rules"
-                        )
-                        pass
+                    rules.extend(
+                        await self._load_room_rules(path=p, participant=participant)
+                    )
 
-            print(f"using rules {rules}", flush=True)
+            logging.info(f"using rules {rules}")
 
             return rules
 
@@ -199,8 +271,7 @@ def build_chatbot(
 
             if require_image_generation:
                 providers.append(
-                    ChatBotThreadOpenAIImageGenerationTool(
-                        thread_context=thread_context,
+                    ImageGenerationTool(
                         config=ImageGenerationConfig(
                             name="image_generation",
                             partial_images=3,
@@ -210,19 +281,24 @@ def build_chatbot(
 
             if require_local_shell:
                 providers.append(
-                    ChatBotThreadLocalShellTool(
+                    LocalShellTool(
                         working_directory=working_directory,
-                        thread_context=thread_context,
                         config=LocalShellConfig(name="local_shell"),
                     )
                 )
 
+            env = {}
+
+            if delegate_shell_token:
+                env["MESHAGENT_TOKEN"] = self.room.protocol.token
+
             if require_shell:
                 providers.append(
-                    ChatBotThreadShellTool(
-                        thread_context=thread_context,
+                    ShellTool(
                         working_directory=working_directory,
                         config=ShellConfig(name="shell"),
+                        image=shell_image or "python:3.13",
+                        env=env,
                     )
                 )
 
@@ -246,9 +322,80 @@ def build_chatbot(
             if require_storage:
                 providers.extend(StorageToolkit().tools)
 
+            if len(require_table_read) > 0:
+                providers.extend(
+                    (
+                        await DatabaseToolkitBuilder().make(
+                            room=self.room,
+                            model=model,
+                            config=DatabaseToolkitConfig(
+                                tables=require_table_read,
+                                read_only=True,
+                                namespace=database_namespace,
+                            ),
+                        )
+                    ).tools
+                )
+
+            if require_time:
+                providers.extend((DatetimeToolkit()).tools)
+
+            if require_uuid:
+                providers.extend((UUIDToolkit()).tools)
+
+            if len(require_table_write) > 0:
+                providers.extend(
+                    (
+                        await DatabaseToolkitBuilder().make(
+                            room=self.room,
+                            model=model,
+                            config=DatabaseToolkitConfig(
+                                tables=require_table_write,
+                                read_only=False,
+                                namespace=database_namespace,
+                            ),
+                        )
+                    ).tools
+                )
+
+            if require_read_only_storage:
+                providers.extend(StorageToolkit(read_only=True).tools)
+
+            if require_document_authoring:
+                providers.extend(DocumentAuthoringToolkit().tools)
+                providers.extend(
+                    DocumentTypeAuthoringToolkit(
+                        schema=widget_schema, document_type="widget"
+                    ).tools
+                )
+
+            if require_discovery:
+                from meshagent.tools.discovery import DiscoveryToolkit
+
+                providers.extend(DiscoveryToolkit().tools)
+
             tk = await super().get_thread_toolkits(
                 thread_context=thread_context, participant=participant
             )
+
+            if require_computer_use:
+                from meshagent.computers.agent import ComputerToolkit
+
+                def render_screen(image_bytes: bytes):
+                    for participant in thread_context.participants:
+                        self.room.messaging.send_message_nowait(
+                            to=participant,
+                            type="computer_screen",
+                            message={},
+                            attachment=image_bytes,
+                        )
+
+                computer_toolkit = ComputerToolkit(
+                    room=self.room, render_screen=render_screen
+                )
+
+                tk.append(computer_toolkit)
+
             return [
                 *(
                     [Toolkit(name="tools", tools=providers)]
@@ -258,34 +405,27 @@ def build_chatbot(
                 *tk,
             ]
 
-        async def get_thread_toolkit_builders(self, *, thread_context, participant):
+        def get_toolkit_builders(self):
             providers = []
 
             if image_generation:
-                providers.append(
-                    ChatBotThreadOpenAIImageGenerationToolkitBuilder(
-                        thread_context=thread_context
-                    )
-                )
+                providers.append(ImageGenerationToolkitBuilder())
 
             if apply_patch:
-                providers.append(
-                    ApplyPatchToolkitBuilder(thread_context=thread_context)
-                )
+                providers.append(ApplyPatchToolkitBuilder())
 
             if local_shell:
                 providers.append(
-                    ChatBotThreadLocalShellToolkitBuilder(
-                        thread_context=thread_context,
+                    LocalShellToolkitBuilder(
                         working_directory=working_directory,
                     )
                 )
 
             if shell:
                 providers.append(
-                    ChatBotThreadShellToolkitBuilder(
-                        thread_context=thread_context,
+                    ShellToolkitBuilder(
                         working_directory=working_directory,
+                        image=shell_image,
                     )
                 )
 
@@ -304,12 +444,14 @@ def build_chatbot(
 
 
 @app.async_command("join")
-async def make_call(
+async def join(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     role: str = "agent",
-    agent_name: Annotated[str, typer.Option(..., help="Name of the agent to call")],
+    agent_name: Annotated[
+        Optional[str], typer.Option(..., help="Name of the agent to call")
+    ] = None,
     rule: Annotated[List[str], typer.Option("--rule", "-r", help="a system rule")] = [],
     room_rules: Annotated[
         List[str],
@@ -320,17 +462,33 @@ async def make_call(
         ),
     ] = [],
     rules_file: Optional[str] = None,
+    require_toolkit: Annotated[
+        List[str],
+        typer.Option(
+            "--require-toolkit", "-rt", help="the name or url of a required toolkit"
+        ),
+    ] = [],
+    require_schema: Annotated[
+        List[str],
+        typer.Option(
+            "--require-schema", "-rs", help="the name or url of a required schema"
+        ),
+    ] = [],
     toolkit: Annotated[
         List[str],
-        typer.Option("--toolkit", "-t", help="the name or url of a required toolkit"),
+        typer.Option(
+            "--toolkit", "-t", help="the name or url of a required toolkit", hidden=True
+        ),
     ] = [],
     schema: Annotated[
         List[str],
-        typer.Option("--schema", "-s", help="the name or url of a required schema"),
+        typer.Option(
+            "--schema", "-s", help="the name or url of a required schema", hidden=True
+        ),
     ] = [],
     model: Annotated[
         str, typer.Option(..., help="Name of the LLM model to use for the chatbot")
-    ] = "gpt-5.1",
+    ] = "gpt-5.2",
     image_generation: Annotated[
         Optional[str], typer.Option(..., help="Name of an image gen model")
     ] = None,
@@ -359,7 +517,7 @@ async def make_call(
         Optional[bool], typer.Option(..., help="Enable storage toolkit")
     ] = False,
     require_image_generation: Annotated[
-        Optional[str], typer.Option(..., help="Name of an image gen model", hidden=True)
+        Optional[str], typer.Option(..., help="Name of an image gen model")
     ] = None,
     require_computer_use: Annotated[
         Optional[bool],
@@ -371,25 +529,63 @@ async def make_call(
     ] = False,
     require_local_shell: Annotated[
         Optional[bool],
-        typer.Option(..., help="Enable local shell tool calling", hidden=True),
+        typer.Option(..., help="Enable local shell tool calling"),
     ] = False,
     require_shell: Annotated[
         Optional[bool],
-        typer.Option(..., help="Enable function shell tool calling", hidden=True),
+        typer.Option(..., help="Enable function shell tool calling"),
     ] = False,
     require_apply_patch: Annotated[
         Optional[bool],
-        typer.Option(..., help="Enable apply patch tool calling", hidden=True),
+        typer.Option(..., help="Enable apply patch tool calling"),
     ] = False,
     require_web_search: Annotated[
         Optional[bool],
-        typer.Option(..., help="Enable web search tool calling", hidden=True),
+        typer.Option(..., help="Enable web search tool calling"),
     ] = False,
     require_mcp: Annotated[
-        Optional[bool], typer.Option(..., help="Enable mcp tool calling", hidden=True)
+        Optional[bool], typer.Option(..., help="Enable mcp tool calling")
     ] = False,
     require_storage: Annotated[
-        Optional[bool], typer.Option(..., help="Enable storage toolkit", hidden=True)
+        Optional[bool], typer.Option(..., help="Enable storage toolkit")
+    ] = False,
+    database_namespace: Annotated[
+        Optional[str],
+        typer.Option(..., help="Use a specific database namespace"),
+    ] = None,
+    require_table_read: Annotated[
+        list[str],
+        typer.Option(..., help="Enable table read tools for a specific table"),
+    ] = [],
+    require_table_write: Annotated[
+        list[str],
+        typer.Option(..., help="Enable table write tools for a specific table"),
+    ] = [],
+    require_read_only_storage: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable read only storage toolkit"),
+    ] = False,
+    require_time: Annotated[
+        bool,
+        typer.Option(
+            ...,
+            help="Enable time/datetime tools",
+        ),
+    ] = True,
+    require_uuid: Annotated[
+        bool,
+        typer.Option(
+            ...,
+            help="Enable UUID generation tools",
+        ),
+    ] = False,
+    require_document_authoring: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable MeshDocument authoring"),
+    ] = False,
+    require_discovery: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable discovery of agents and tools"),
     ] = False,
     working_directory: Annotated[
         Optional[str],
@@ -399,77 +595,126 @@ async def make_call(
         str,
         typer.Option("--key", help="an api key to sign the token with"),
     ] = None,
+    llm_participant: Annotated[
+        Optional[str],
+        typer.Option(..., help="Delegate LLM interactions to a remote participant"),
+    ] = None,
+    always_reply: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Always reply"),
+    ] = None,
+    skill_dir: Annotated[
+        list[str],
+        typer.Option(..., help="an agent skills directory"),
+    ] = [],
+    shell_image: Annotated[
+        Optional[str],
+        typer.Option(..., help="an image tag to use to run shell commands in"),
+    ] = None,
+    delegate_shell_token: Annotated[
+        Optional[bool],
+        typer.Option(..., help="log all requests to the llm"),
+    ] = False,
+    log_llm_requests: Annotated[
+        Optional[bool],
+        typer.Option(..., help="log all requests to the llm"),
+    ] = False,
 ):
+    if database_namespace is not None:
+        database_namespace = database_namespace.split("::")
+
     key = await resolve_key(project_id=project_id, key=key)
     account_client = await get_client()
     try:
         project_id = await resolve_project_id(project_id=project_id)
         room = resolve_room(room)
 
-        token = ParticipantToken(
-            name=agent_name,
-        )
+        jwt = os.getenv("MESHAGENT_TOKEN")
+        if jwt is None:
+            if agent_name is None:
+                print(
+                    "[bold red]--agent-name must be specified when the MESHAGENT_TOKEN environment variable is not set[/bold red]"
+                )
+                raise typer.Exit(1)
 
-        token.add_api_grant(ApiScope.agent_default())
+            token = ParticipantToken(
+                name=agent_name,
+            )
 
-        token.add_role_grant(role=role)
-        token.add_room_grant(room)
+            token.add_api_grant(ApiScope.agent_default(tunnels=require_computer_use))
 
-        jwt = token.to_jwt(api_key=key)
+            token.add_role_grant(role=role)
+            token.add_room_grant(room)
 
-        print("[bold green]Connecting to room...[/bold green]", flush=True)
-        async with RoomClient(
-            protocol=WebSocketClientProtocol(
-                url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
-                token=jwt,
-            )
-        ) as client:
-            requirements = []
+            jwt = token.to_jwt(api_key=key)
 
-            for t in toolkit:
-                requirements.append(RequiredToolkit(name=t))
+        print("[bold green]Connecting to room...[/bold green]", flush=True)
 
-            for t in schema:
-                requirements.append(RequiredSchema(name=t))
+        CustomChatbot = build_chatbot(
+            computer_use=computer_use,
+            require_computer_use=require_computer_use,
+            model=model,
+            rule=rule,
+            toolkit=require_toolkit + toolkit,
+            schema=require_schema + schema,
+            rules_file=rules_file,
+            local_shell=local_shell,
+            shell=shell,
+            apply_patch=apply_patch,
+            image_generation=image_generation,
+            web_search=web_search,
+            mcp=mcp,
+            storage=storage,
+            require_apply_patch=require_apply_patch,
+            require_web_search=require_web_search,
+            require_local_shell=require_local_shell,
+            require_shell=require_shell,
+            require_image_generation=require_image_generation,
+            require_mcp=require_mcp,
+            require_storage=require_storage,
+            require_table_read=require_table_read,
+            require_table_write=require_table_write,
+            require_read_only_storage=require_read_only_storage,
+            require_time=require_time,
+            require_uuid=require_uuid,
+            room_rules_path=room_rules,
+            require_document_authoring=require_document_authoring,
+            require_discovery=require_discovery,
+            working_directory=working_directory,
+            llm_participant=llm_participant,
+            always_reply=always_reply,
+            database_namespace=database_namespace,
+            skill_dirs=skill_dir,
+            shell_image=shell_image,
+            delegate_shell_token=delegate_shell_token,
+            log_llm_requests=log_llm_requests,
+        )
 
-            CustomChatbot = build_chatbot(
-                computer_use=computer_use,
-                model=model,
-                local_shell=local_shell,
-                shell=shell,
-                apply_patch=apply_patch,
-                agent_name=agent_name,
-                rule=rule,
-                toolkit=toolkit,
-                schema=schema,
-                rules_file=rules_file,
-                image_generation=image_generation,
-                web_search=web_search,
-                mcp=mcp,
-                storage=storage,
-                require_apply_patch=require_apply_patch,
-                require_web_search=require_web_search,
-                require_local_shell=require_local_shell,
-                require_shell=require_shell,
-                require_image_generation=require_image_generation,
-                require_mcp=require_mcp,
-                require_storage=require_storage,
-                room_rules_path=room_rules,
-                working_directory=working_directory,
-            )
+        bot = CustomChatbot()
 
-            bot = CustomChatbot()
+        if get_deferred():
+            from meshagent.cli.host import agents
 
-            await bot.start(room=client)
-            try:
-                print(
-                    f"[bold green]Open the studio to interact with your agent: {meshagent_base_url().replace('api.', 'studio.')}/projects/{project_id}/rooms/{client.room_name}[/bold green]",
-                    flush=True,
+            agents.append((bot, jwt))
+        else:
+            async with RoomClient(
+                protocol=WebSocketClientProtocol(
+                    url=websocket_room_url(
+                        room_name=room, base_url=meshagent_base_url()
+                    ),
+                    token=jwt,
                 )
-                await client.protocol.wait_for_close()
-            except KeyboardInterrupt:
-                await bot.stop()
+            ) as client:
+                await bot.start(room=client)
+                try:
+                    print(
+                        f"[bold green]Open the studio to interact with your agent: {meshagent_base_url().replace('api.', 'studio.')}/projects/{project_id}/rooms/{client.room_name}[/bold green]",
+                        flush=True,
+                    )
+                    await client.protocol.wait_for_close()
 
+                except KeyboardInterrupt:
+                    await bot.stop()
     finally:
         await account_client.close()
 
@@ -488,17 +733,33 @@ async def service(
             help="a path to a rules file within the room that can be used to customize the agent's behavior",
         ),
     ] = [],
+    require_toolkit: Annotated[
+        List[str],
+        typer.Option(
+            "--require-toolkit", "-rt", help="the name or url of a required toolkit"
+        ),
+    ] = [],
+    require_schema: Annotated[
+        List[str],
+        typer.Option(
+            "--require-schema", "-rs", help="the name or url of a required schema"
+        ),
+    ] = [],
     toolkit: Annotated[
         List[str],
-        typer.Option("--toolkit", "-t", help="the name or url of a required toolkit"),
+        typer.Option(
+            "--toolkit", "-t", help="the name or url of a required toolkit", hidden=True
+        ),
     ] = [],
     schema: Annotated[
         List[str],
-        typer.Option("--schema", "-s", help="the name or url of a required schema"),
+        typer.Option(
+            "--schema", "-s", help="the name or url of a required schema", hidden=True
+        ),
     ] = [],
     model: Annotated[
         str, typer.Option(..., help="Name of the LLM model to use for the chatbot")
-    ] = "gpt-5.1",
+    ] = "gpt-5.2",
     image_generation: Annotated[
         Optional[str], typer.Option(..., help="Name of an image gen model")
     ] = None,
@@ -527,7 +788,7 @@ async def service(
         Optional[bool], typer.Option(..., help="Enable storage toolkit")
     ] = False,
     require_image_generation: Annotated[
-        Optional[str], typer.Option(..., help="Name of an image gen model", hidden=True)
+        Optional[str], typer.Option(..., help="Name of an image gen model")
     ] = None,
     require_computer_use: Annotated[
         Optional[bool],
@@ -539,53 +800,136 @@ async def service(
     ] = False,
     require_local_shell: Annotated[
         Optional[bool],
-        typer.Option(..., help="Enable local shell tool calling", hidden=True),
+        typer.Option(..., help="Enable local shell tool calling"),
     ] = False,
     require_shell: Annotated[
         Optional[bool],
-        typer.Option(..., help="Enable function shell tool calling", hidden=True),
+        typer.Option(..., help="Enable function shell tool calling"),
     ] = False,
     require_apply_patch: Annotated[
-        Optional[bool], typer.Option(..., help="Enable apply patch tool", hidden=True)
+        Optional[bool], typer.Option(..., help="Enable apply patch tool")
     ] = False,
     require_web_search: Annotated[
         Optional[bool],
-        typer.Option(..., help="Enable web search tool calling", hidden=True),
+        typer.Option(..., help="Enable web search tool calling"),
     ] = False,
     require_mcp: Annotated[
-        Optional[bool], typer.Option(..., help="Enable mcp tool calling", hidden=True)
+        Optional[bool], typer.Option(..., help="Enable mcp tool calling")
     ] = False,
     require_storage: Annotated[
-        Optional[bool], typer.Option(..., help="Enable storage toolkit", hidden=True)
+        Optional[bool], typer.Option(..., help="Enable storage toolkit")
+    ] = False,
+    database_namespace: Annotated[
+        Optional[str],
+        typer.Option(..., help="Use a specific database namespace"),
+    ] = None,
+    require_table_read: Annotated[
+        list[str],
+        typer.Option(..., help="Enable table read tools for a specific table"),
+    ] = [],
+    require_table_write: Annotated[
+        list[str],
+        typer.Option(..., help="Enable table write tools for a specific table"),
+    ] = [],
+    require_read_only_storage: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable read only storage toolkit"),
+    ] = False,
+    require_time: Annotated[
+        bool,
+        typer.Option(
+            ...,
+            help="Enable time/datetime tools",
+        ),
+    ] = True,
+    require_uuid: Annotated[
+        bool,
+        typer.Option(
+            ...,
+            help="Enable UUID generation tools",
+        ),
     ] = False,
     working_directory: Annotated[
         Optional[str],
         typer.Option(..., help="The default working directory for shell commands"),
     ] = None,
-    host: Annotated[Optional[str], typer.Option()] = None,
-    port: Annotated[Optional[int], typer.Option()] = None,
-    path: Annotated[str, typer.Option()] = "/agent",
+    require_document_authoring: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable document authoring"),
+    ] = False,
+    require_discovery: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable discovery of agents and tools"),
+    ] = False,
+    llm_participant: Annotated[
+        Optional[str],
+        typer.Option(..., help="Delegate LLM interactions to a remote participant"),
+    ] = None,
+    host: Annotated[
+        Optional[str], typer.Option(help="Host to bind the service on")
+    ] = None,
+    port: Annotated[
+        Optional[int], typer.Option(help="Port to bind the service on")
+    ] = None,
+    path: Annotated[
+        Optional[str], typer.Option(help="HTTP path to mount the service at")
+    ] = None,
+    always_reply: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Always reply"),
+    ] = None,
+    skill_dir: Annotated[
+        list[str],
+        typer.Option(..., help="an agent skills directory"),
+    ] = [],
+    shell_image: Annotated[
+        Optional[str],
+        typer.Option(..., help="an image tag to use to run shell commands in"),
+    ] = None,
+    delegate_shell_token: Annotated[
+        Optional[bool],
+        typer.Option(..., help="log all requests to the llm"),
+    ] = False,
+    log_llm_requests: Annotated[
+        Optional[bool],
+        typer.Option(..., help="log all requests to the llm"),
+    ] = False,
 ):
-    print("[bold green]Connecting to room...[/bold green]", flush=True)
+    if database_namespace is not None:
+        database_namespace = database_namespace.split("::")
+
+    service = get_service(host=host, port=port)
+
+    if path is None:
+        path = "/agent"
+        i = 0
+        while service.has_path(path):
+            i += 1
+            path = f"/agent{i}"
+
+    service.agents.append(
+        AgentSpec(name=agent_name, annotations={ANNOTATION_AGENT_TYPE: "ChatBot"})
+    )
 
-    service = ServiceHost(host=host, port=port)
     service.add_path(
+        identity=agent_name,
         path=path,
         cls=build_chatbot(
             computer_use=computer_use,
+            require_computer_use=require_computer_use,
             model=model,
             local_shell=local_shell,
             shell=shell,
             apply_patch=apply_patch,
-            agent_name=agent_name,
             rule=rule,
-            toolkit=toolkit,
-            schema=schema,
+            toolkit=require_toolkit + toolkit,
+            schema=require_schema + schema,
             rules_file=rules_file,
             web_search=web_search,
             image_generation=image_generation,
             mcp=mcp,
             storage=storage,
+            database_namespace=database_namespace,
             require_web_search=require_web_search,
             require_shell=require_shell,
             require_apply_patch=require_apply_patch,
@@ -593,9 +937,1047 @@ async def service(
             require_image_generation=require_image_generation,
             require_mcp=require_mcp,
             require_storage=require_storage,
+            require_table_write=require_table_write,
+            require_table_read=require_table_read,
+            require_read_only_storage=require_read_only_storage,
+            require_time=require_time,
+            require_uuid=require_uuid,
             room_rules_path=room_rules,
             working_directory=working_directory,
+            require_document_authoring=require_document_authoring,
+            require_discovery=require_discovery,
+            llm_participant=llm_participant,
+            always_reply=always_reply,
+            skill_dirs=skill_dir,
+            shell_image=shell_image,
+            delegate_shell_token=delegate_shell_token,
+            log_llm_requests=log_llm_requests,
         ),
     )
 
-    await service.run()
+    if not get_deferred():
+        await run_services()
+
+
+@app.async_command("spec")
+async def spec(
+    *,
+    service_name: Annotated[str, typer.Option("--service-name", help="service name")],
+    service_description: Annotated[
+        Optional[str], typer.Option("--service-description", help="service description")
+    ] = None,
+    service_title: Annotated[
+        Optional[str],
+        typer.Option("--service-title", help="a display name for the service"),
+    ] = None,
+    agent_name: Annotated[str, typer.Option(..., help="Name of the agent to call")],
+    rule: Annotated[List[str], typer.Option("--rule", "-r", help="a system rule")] = [],
+    rules_file: Optional[str] = None,
+    room_rules: Annotated[
+        List[str],
+        typer.Option(
+            "--room-rules",
+            "-rr",
+            help="a path to a rules file within the room that can be used to customize the agent's behavior",
+        ),
+    ] = [],
+    require_toolkit: Annotated[
+        List[str],
+        typer.Option(
+            "--require-toolkit", "-rt", help="the name or url of a required toolkit"
+        ),
+    ] = [],
+    require_schema: Annotated[
+        List[str],
+        typer.Option(
+            "--require-schema", "-rs", help="the name or url of a required schema"
+        ),
+    ] = [],
+    toolkit: Annotated[
+        List[str],
+        typer.Option(
+            "--toolkit", "-t", help="the name or url of a required toolkit", hidden=True
+        ),
+    ] = [],
+    schema: Annotated[
+        List[str],
+        typer.Option(
+            "--schema", "-s", help="the name or url of a required schema", hidden=True
+        ),
+    ] = [],
+    model: Annotated[
+        str, typer.Option(..., help="Name of the LLM model to use for the chatbot")
+    ] = "gpt-5.2",
+    image_generation: Annotated[
+        Optional[str], typer.Option(..., help="Name of an image gen model")
+    ] = None,
+    local_shell: Annotated[
+        Optional[bool], typer.Option(..., help="Enable local shell tool calling")
+    ] = False,
+    shell: Annotated[
+        Optional[bool], typer.Option(..., help="Enable function shell tool calling")
+    ] = False,
+    apply_patch: Annotated[
+        Optional[bool], typer.Option(..., help="Enable apply patch tool")
+    ] = False,
+    computer_use: Annotated[
+        Optional[bool],
+        typer.Option(
+            ..., help="Enable computer use (requires computer-use-preview model)"
+        ),
+    ] = False,
+    web_search: Annotated[
+        Optional[bool], typer.Option(..., help="Enable web search tool calling")
+    ] = False,
+    mcp: Annotated[
+        Optional[bool], typer.Option(..., help="Enable mcp tool calling")
+    ] = False,
+    storage: Annotated[
+        Optional[bool], typer.Option(..., help="Enable storage toolkit")
+    ] = False,
+    require_image_generation: Annotated[
+        Optional[str], typer.Option(..., help="Name of an image gen model")
+    ] = None,
+    require_computer_use: Annotated[
+        Optional[bool],
+        typer.Option(
+            ...,
+            help="Enable computer use (requires computer-use-preview model)",
+            hidden=True,
+        ),
+    ] = False,
+    require_local_shell: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable local shell tool calling"),
+    ] = False,
+    require_shell: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable function shell tool calling"),
+    ] = False,
+    require_apply_patch: Annotated[
+        Optional[bool], typer.Option(..., help="Enable apply patch tool")
+    ] = False,
+    require_web_search: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable web search tool calling"),
+    ] = False,
+    require_mcp: Annotated[
+        Optional[bool], typer.Option(..., help="Enable mcp tool calling")
+    ] = False,
+    require_storage: Annotated[
+        Optional[bool], typer.Option(..., help="Enable storage toolkit")
+    ] = False,
+    database_namespace: Annotated[
+        Optional[str],
+        typer.Option(..., help="Use a specific database namespace"),
+    ] = None,
+    require_table_read: Annotated[
+        list[str],
+        typer.Option(..., help="Enable table read tools for a specific table"),
+    ] = [],
+    require_table_write: Annotated[
+        list[str],
+        typer.Option(..., help="Enable table write tools for a specific table"),
+    ] = [],
+    require_read_only_storage: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable read only storage toolkit"),
+    ] = False,
+    require_time: Annotated[
+        bool,
+        typer.Option(
+            ...,
+            help="Enable time/datetime tools",
+        ),
+    ] = True,
+    require_uuid: Annotated[
+        bool,
+        typer.Option(
+            ...,
+            help="Enable UUID generation tools",
+        ),
+    ] = False,
+    working_directory: Annotated[
+        Optional[str],
+        typer.Option(..., help="The default working directory for shell commands"),
+    ] = None,
+    require_document_authoring: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable document authoring"),
+    ] = False,
+    require_discovery: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable discovery of agents and tools"),
+    ] = False,
+    llm_participant: Annotated[
+        Optional[str],
+        typer.Option(..., help="Delegate LLM interactions to a remote participant"),
+    ] = None,
+    host: Annotated[
+        Optional[str], typer.Option(help="Host to bind the service on")
+    ] = None,
+    port: Annotated[
+        Optional[int], typer.Option(help="Port to bind the service on")
+    ] = None,
+    path: Annotated[
+        Optional[str], typer.Option(help="HTTP path to mount the service at")
+    ] = None,
+    always_reply: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Always reply"),
+    ] = None,
+    skill_dir: Annotated[
+        list[str],
+        typer.Option(..., help="an agent skills directory"),
+    ] = [],
+    shell_image: Annotated[
+        Optional[str],
+        typer.Option(..., help="an image tag to use to run shell commands in"),
+    ] = None,
+    delegate_shell_token: Annotated[
+        Optional[bool],
+        typer.Option(..., help="log all requests to the llm"),
+    ] = False,
+    log_llm_requests: Annotated[
+        Optional[bool],
+        typer.Option(..., help="log all requests to the llm"),
+    ] = False,
+):
+    if database_namespace is not None:
+        database_namespace = database_namespace.split("::")
+
+    service = get_service(host=host, port=port)
+
+    if path is None:
+        path = "/agent"
+        i = 0
+        while service.has_path(path):
+            i += 1
+            path = f"/agent{i}"
+
+    service.agents.append(
+        AgentSpec(name=agent_name, annotations={ANNOTATION_AGENT_TYPE: "ChatBot"})
+    )
+
+    service.add_path(
+        identity=agent_name,
+        path=path,
+        cls=build_chatbot(
+            computer_use=computer_use,
+            require_computer_use=require_computer_use,
+            model=model,
+            local_shell=local_shell,
+            shell=shell,
+            apply_patch=apply_patch,
+            rule=rule,
+            toolkit=require_toolkit + toolkit,
+            schema=require_schema + schema,
+            rules_file=rules_file,
+            web_search=web_search,
+            image_generation=image_generation,
+            mcp=mcp,
+            storage=storage,
+            database_namespace=database_namespace,
+            require_web_search=require_web_search,
+            require_shell=require_shell,
+            require_apply_patch=require_apply_patch,
+            require_local_shell=require_local_shell,
+            require_image_generation=require_image_generation,
+            require_mcp=require_mcp,
+            require_storage=require_storage,
+            require_table_write=require_table_write,
+            require_table_read=require_table_read,
+            require_read_only_storage=require_read_only_storage,
+            require_time=require_time,
+            require_uuid=require_uuid,
+            room_rules_path=room_rules,
+            working_directory=working_directory,
+            require_document_authoring=require_document_authoring,
+            require_discovery=require_discovery,
+            llm_participant=llm_participant,
+            always_reply=always_reply,
+            skill_dirs=skill_dir,
+            shell_image=shell_image,
+            delegate_shell_token=delegate_shell_token,
+            log_llm_requests=log_llm_requests,
+        ),
+    )
+
+    spec = service_specs()[0]
+    spec.metadata.annotations = {
+        "meshagent.service.id": service_name,
+    }
+
+    spec.metadata.name = service_name
+    spec.metadata.description = service_description
+    spec.container.image = (
+        "us-central1-docker.pkg.dev/meshagent-public/images/cli:{SERVER_VERSION}-esgz"
+    )
+    spec.container.command = shlex.join(
+        ["meshagent", "chatbot", "service", *cleanup_args(sys.argv[2:])]
+    )
+
+    print(yaml.dump(spec.model_dump(mode="json", exclude_none=True), sort_keys=False))
+
+
+@app.async_command("deploy")
+async def deploy(
+    *,
+    service_name: Annotated[str, typer.Option("--service-name", help="service name")],
+    service_description: Annotated[
+        Optional[str], typer.Option("--service-description", help="service description")
+    ] = None,
+    service_title: Annotated[
+        Optional[str],
+        typer.Option("--service-title", help="a display name for the service"),
+    ] = None,
+    agent_name: Annotated[str, typer.Option(..., help="Name of the agent to call")],
+    rule: Annotated[List[str], typer.Option("--rule", "-r", help="a system rule")] = [],
+    rules_file: Optional[str] = None,
+    room_rules: Annotated[
+        List[str],
+        typer.Option(
+            "--room-rules",
+            "-rr",
+            help="a path to a rules file within the room that can be used to customize the agent's behavior",
+        ),
+    ] = [],
+    require_toolkit: Annotated[
+        List[str],
+        typer.Option(
+            "--require-toolkit", "-rt", help="the name or url of a required toolkit"
+        ),
+    ] = [],
+    require_schema: Annotated[
+        List[str],
+        typer.Option(
+            "--require-schema", "-rs", help="the name or url of a required schema"
+        ),
+    ] = [],
+    toolkit: Annotated[
+        List[str],
+        typer.Option(
+            "--toolkit", "-t", help="the name or url of a required toolkit", hidden=True
+        ),
+    ] = [],
+    schema: Annotated[
+        List[str],
+        typer.Option(
+            "--schema", "-s", help="the name or url of a required schema", hidden=True
+        ),
+    ] = [],
+    model: Annotated[
+        str, typer.Option(..., help="Name of the LLM model to use for the chatbot")
+    ] = "gpt-5.2",
+    image_generation: Annotated[
+        Optional[str], typer.Option(..., help="Name of an image gen model")
+    ] = None,
+    local_shell: Annotated[
+        Optional[bool], typer.Option(..., help="Enable local shell tool calling")
+    ] = False,
+    shell: Annotated[
+        Optional[bool], typer.Option(..., help="Enable function shell tool calling")
+    ] = False,
+    apply_patch: Annotated[
+        Optional[bool], typer.Option(..., help="Enable apply patch tool")
+    ] = False,
+    computer_use: Annotated[
+        Optional[bool],
+        typer.Option(
+            ..., help="Enable computer use (requires computer-use-preview model)"
+        ),
+    ] = False,
+    web_search: Annotated[
+        Optional[bool], typer.Option(..., help="Enable web search tool calling")
+    ] = False,
+    mcp: Annotated[
+        Optional[bool], typer.Option(..., help="Enable mcp tool calling")
+    ] = False,
+    storage: Annotated[
+        Optional[bool], typer.Option(..., help="Enable storage toolkit")
+    ] = False,
+    require_image_generation: Annotated[
+        Optional[str], typer.Option(..., help="Name of an image gen model")
+    ] = None,
+    require_computer_use: Annotated[
+        Optional[bool],
+        typer.Option(
+            ...,
+            help="Enable computer use (requires computer-use-preview model)",
+            hidden=True,
+        ),
+    ] = False,
+    require_local_shell: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable local shell tool calling"),
+    ] = False,
+    require_shell: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable function shell tool calling"),
+    ] = False,
+    require_apply_patch: Annotated[
+        Optional[bool], typer.Option(..., help="Enable apply patch tool")
+    ] = False,
+    require_web_search: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable web search tool calling"),
+    ] = False,
+    require_mcp: Annotated[
+        Optional[bool], typer.Option(..., help="Enable mcp tool calling")
+    ] = False,
+    require_storage: Annotated[
+        Optional[bool], typer.Option(..., help="Enable storage toolkit")
+    ] = False,
+    database_namespace: Annotated[
+        Optional[str],
+        typer.Option(..., help="Use a specific database namespace"),
+    ] = None,
+    require_table_read: Annotated[
+        list[str],
+        typer.Option(..., help="Enable table read tools for a specific table"),
+    ] = [],
+    require_table_write: Annotated[
+        list[str],
+        typer.Option(..., help="Enable table write tools for a specific table"),
+    ] = [],
+    require_read_only_storage: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable read only storage toolkit"),
+    ] = False,
+    require_time: Annotated[
+        bool,
+        typer.Option(
+            ...,
+            help="Enable time/datetime tools",
+        ),
+    ] = True,
+    require_uuid: Annotated[
+        bool,
+        typer.Option(
+            ...,
+            help="Enable UUID generation tools",
+        ),
+    ] = False,
+    working_directory: Annotated[
+        Optional[str],
+        typer.Option(..., help="The default working directory for shell commands"),
+    ] = None,
+    require_document_authoring: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable document authoring"),
+    ] = False,
+    require_discovery: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable discovery of agents and tools"),
+    ] = False,
+    llm_participant: Annotated[
+        Optional[str],
+        typer.Option(..., help="Delegate LLM interactions to a remote participant"),
+    ] = None,
+    host: Annotated[
+        Optional[str], typer.Option(help="Host to bind the service on")
+    ] = None,
+    port: Annotated[
+        Optional[int], typer.Option(help="Port to bind the service on")
+    ] = None,
+    path: Annotated[
+        Optional[str], typer.Option(help="HTTP path to mount the service at")
+    ] = None,
+    always_reply: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Always reply"),
+    ] = None,
+    skill_dir: Annotated[
+        list[str],
+        typer.Option(..., help="an agent skills directory"),
+    ] = [],
+    shell_image: Annotated[
+        Optional[str],
+        typer.Option(..., help="an image tag to use to run shell commands in"),
+    ] = None,
+    delegate_shell_token: Annotated[
+        Optional[bool],
+        typer.Option(..., help="log all requests to the llm"),
+    ] = False,
+    log_llm_requests: Annotated[
+        Optional[bool],
+        typer.Option(..., help="log all requests to the llm"),
+    ] = False,
+    project_id: ProjectIdOption,
+    room: Annotated[
+        Optional[str],
+        typer.Option("--room", help="The name of a room to create the service for"),
+    ] = None,
+):
+    project_id = await resolve_project_id(project_id=project_id)
+
+    if database_namespace is not None:
+        database_namespace = database_namespace.split("::")
+
+    service = get_service(host=host, port=port)
+
+    if path is None:
+        path = "/agent"
+        i = 0
+        while service.has_path(path):
+            i += 1
+            path = f"/agent{i}"
+
+    service.agents.append(
+        AgentSpec(name=agent_name, annotations={ANNOTATION_AGENT_TYPE: "ChatBot"})
+    )
+
+    service.add_path(
+        identity=agent_name,
+        path=path,
+        cls=build_chatbot(
+            computer_use=computer_use,
+            require_computer_use=require_computer_use,
+            model=model,
+            local_shell=local_shell,
+            shell=shell,
+            apply_patch=apply_patch,
+            rule=rule,
+            toolkit=require_toolkit + toolkit,
+            schema=require_schema + schema,
+            rules_file=rules_file,
+            web_search=web_search,
+            image_generation=image_generation,
+            mcp=mcp,
+            storage=storage,
+            database_namespace=database_namespace,
+            require_web_search=require_web_search,
+            require_shell=require_shell,
+            require_apply_patch=require_apply_patch,
+            require_local_shell=require_local_shell,
+            require_image_generation=require_image_generation,
+            require_mcp=require_mcp,
+            require_storage=require_storage,
+            require_table_write=require_table_write,
+            require_table_read=require_table_read,
+            require_read_only_storage=require_read_only_storage,
+            require_time=require_time,
+            require_uuid=require_uuid,
+            room_rules_path=room_rules,
+            working_directory=working_directory,
+            require_document_authoring=require_document_authoring,
+            require_discovery=require_discovery,
+            llm_participant=llm_participant,
+            always_reply=always_reply,
+            skill_dirs=skill_dir,
+            shell_image=shell_image,
+            delegate_shell_token=delegate_shell_token,
+            log_llm_requests=log_llm_requests,
+        ),
+    )
+
+    spec = service_specs()[0]
+
+    for port in spec.ports:
+        port
+
+    spec.metadata.annotations = {
+        "meshagent.service.id": service_name,
+    }
+
+    spec.metadata.name = service_name
+    spec.metadata.description = service_description
+    spec.container.image = (
+        "us-central1-docker.pkg.dev/meshagent-public/images/cli:{SERVER_VERSION}-esgz"
+    )
+    spec.container.command = shlex.join(
+        ["meshagent", "chatbot", "service", *cleanup_args(sys.argv[2:])]
+    )
+
+    project_id = await resolve_project_id(project_id)
+
+    client = await get_client()
+    try:
+        id = None
+        try:
+            if id is None:
+                if room is None:
+                    services = await client.list_services(project_id=project_id)
+                else:
+                    services = await client.list_room_services(
+                        project_id=project_id, room_name=room
+                    )
+
+                for s in services:
+                    if s.metadata.name == spec.metadata.name:
+                        id = s.id
+
+            if id is None:
+                if room is None:
+                    id = await client.create_service(
+                        project_id=project_id, service=spec
+                    )
+                else:
+                    id = await client.create_room_service(
+                        project_id=project_id, service=spec, room_name=room
+                    )
+
+            else:
+                spec.id = id
+                if room is None:
+                    await client.update_service(
+                        project_id=project_id, service_id=id, service=spec
+                    )
+                else:
+                    await client.update_room_service(
+                        project_id=project_id,
+                        service_id=id,
+                        service=spec,
+                        room_name=room,
+                    )
+
+        except ConflictError:
+            print(f"[red]Service name already in use: {spec.metadata.name}[/red]")
+            raise typer.Exit(code=1)
+        else:
+            print(f"[green]Deployed service:[/] {id}")
+
+    finally:
+        await client.close()
+
+
+async def chat_with(
+    *,
+    participant_name: str,
+    project_id: str,
+    room: str,
+    thread_path: str,
+    message: Optional[str] = None,
+    use_web_search: bool = False,
+    use_image_gen: bool = False,
+    use_storage: bool = False,
+):
+    from prompt_toolkit.shortcuts import PromptSession
+    from prompt_toolkit.key_binding import KeyBindings
+    from meshagent.agents.chat import ChatBotClient
+
+    kb = KeyBindings()
+
+    session = PromptSession("> ", key_bindings=kb)
+
+    account_client = await get_client()
+    try:
+        connection = await account_client.connect_room(project_id=project_id, room=room)
+        async with RoomClient(
+            protocol=WebSocketClientProtocol(
+                url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
+                token=connection.jwt,
+            ),
+        ) as user_client:
+            await user_client.messaging.enable()
+
+            if thread_path is None:
+                thread_path = f".threads/{participant_name}/{user_client.local_participant.get_attribute('name')}.thread"
+
+            async with ChatBotClient(
+                room=user_client,
+                participant_name=participant_name,
+                thread_path=thread_path,
+            ) as chat_client:
+
+                @kb.add("c-l")
+                def _(event):
+                    event.app.renderer.clear()
+                    asyncio.ensure_future(chat_client.clear())
+
+                while True:
+                    user_input = message or await session.prompt_async()
+
+                    if user_input == "/clear":
+                        await chat_client.clear()
+
+                    else:
+                        tools: list[ToolkitConfig] = []
+
+                        if use_web_search:
+                            tools.append(WebSearchConfig())
+
+                        elif use_image_gen:
+                            tools.append(ImageGenerationConfig())
+
+                        elif use_storage:
+                            tools.append(StorageToolkitConfig())
+
+                        await chat_client.send(text=user_input, tools=tools)
+
+                        response = await chat_client.receive()
+
+                        print(response)
+
+                    if message:
+                        break
+
+    except asyncio.CancelledError:
+        pass
+
+    finally:
+        await account_client.close()
+
+
+@app.async_command("run")
+async def run(
+    *,
+    project_id: ProjectIdOption,
+    room: RoomOption,
+    role: str = "agent",
+    agent_name: Annotated[
+        Optional[str], typer.Option(..., help="Name of the agent to call")
+    ] = None,
+    rule: Annotated[List[str], typer.Option("--rule", "-r", help="a system rule")] = [],
+    room_rules: Annotated[
+        List[str],
+        typer.Option(
+            "--room-rules",
+            "-rr",
+            help="a path to a rules file within the room that can be used to customize the agent's behavior",
+        ),
+    ] = [],
+    rules_file: Optional[str] = None,
+    require_toolkit: Annotated[
+        List[str],
+        typer.Option(
+            "--require-toolkit", "-rt", help="the name or url of a required toolkit"
+        ),
+    ] = [],
+    require_schema: Annotated[
+        List[str],
+        typer.Option(
+            "--require-schema", "-rs", help="the name or url of a required schema"
+        ),
+    ] = [],
+    toolkit: Annotated[
+        List[str],
+        typer.Option(
+            "--toolkit", "-t", help="the name or url of a required toolkit", hidden=True
+        ),
+    ] = [],
+    schema: Annotated[
+        List[str],
+        typer.Option(
+            "--schema", "-s", help="the name or url of a required schema", hidden=True
+        ),
+    ] = [],
+    model: Annotated[
+        str, typer.Option(..., help="Name of the LLM model to use for the chatbot")
+    ] = "gpt-5.2",
+    image_generation: Annotated[
+        Optional[str], typer.Option(..., help="Name of an image gen model")
+    ] = None,
+    computer_use: Annotated[
+        Optional[bool],
+        typer.Option(
+            ..., help="Enable computer use (requires computer-use-preview model)"
+        ),
+    ] = False,
+    local_shell: Annotated[
+        Optional[bool], typer.Option(..., help="Enable local shell tool calling")
+    ] = False,
+    shell: Annotated[
+        Optional[bool], typer.Option(..., help="Enable function shell tool calling")
+    ] = False,
+    apply_patch: Annotated[
+        Optional[bool], typer.Option(..., help="Enable apply patch tool")
+    ] = False,
+    web_search: Annotated[
+        Optional[bool], typer.Option(..., help="Enable web search tool calling")
+    ] = False,
+    mcp: Annotated[
+        Optional[bool], typer.Option(..., help="Enable mcp tool calling")
+    ] = False,
+    storage: Annotated[
+        Optional[bool], typer.Option(..., help="Enable storage toolkit")
+    ] = False,
+    require_image_generation: Annotated[
+        Optional[str], typer.Option(..., help="Name of an image gen model")
+    ] = None,
+    require_computer_use: Annotated[
+        Optional[bool],
+        typer.Option(
+            ...,
+            help="Enable computer use (requires computer-use-preview model)",
+            hidden=True,
+        ),
+    ] = False,
+    require_local_shell: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable local shell tool calling"),
+    ] = False,
+    require_shell: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable function shell tool calling"),
+    ] = False,
+    require_apply_patch: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable apply patch tool calling"),
+    ] = False,
+    require_web_search: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable web search tool calling"),
+    ] = False,
+    require_mcp: Annotated[
+        Optional[bool], typer.Option(..., help="Enable mcp tool calling")
+    ] = False,
+    require_storage: Annotated[
+        Optional[bool], typer.Option(..., help="Enable storage toolkit")
+    ] = False,
+    database_namespace: Annotated[
+        Optional[str],
+        typer.Option(..., help="Use a specific database namespace"),
+    ] = None,
+    require_table_read: Annotated[
+        list[str],
+        typer.Option(..., help="Enable table read tools for a specific table"),
+    ] = [],
+    require_table_write: Annotated[
+        list[str],
+        typer.Option(..., help="Enable table write tools for a specific table"),
+    ] = [],
+    require_read_only_storage: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable read only storage toolkit"),
+    ] = False,
+    require_time: Annotated[
+        bool,
+        typer.Option(
+            ...,
+            help="Enable time/datetime tools",
+        ),
+    ] = True,
+    require_uuid: Annotated[
+        bool,
+        typer.Option(
+            ...,
+            help="Enable UUID generation tools",
+        ),
+    ] = False,
+    require_document_authoring: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable MeshDocument authoring"),
+    ] = False,
+    require_discovery: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable discovery of agents and tools"),
+    ] = False,
+    working_directory: Annotated[
+        Optional[str],
+        typer.Option(..., help="The default working directory for shell commands"),
+    ] = None,
+    key: Annotated[
+        str,
+        typer.Option("--key", help="an api key to sign the token with"),
+    ] = None,
+    llm_participant: Annotated[
+        Optional[str],
+        typer.Option(..., help="Delegate LLM interactions to a remote participant"),
+    ] = None,
+    always_reply: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Always reply"),
+    ] = None,
+    skill_dir: Annotated[
+        list[str],
+        typer.Option(..., help="an agent skills directory"),
+    ] = [],
+    shell_image: Annotated[
+        Optional[str],
+        typer.Option(..., help="an image tag to use to run shell commands in"),
+    ] = None,
+    delegate_shell_token: Annotated[
+        Optional[bool],
+        typer.Option(..., help="log all requests to the llm"),
+    ] = False,
+    log_llm_requests: Annotated[
+        Optional[bool],
+        typer.Option(..., help="log all requests to the llm"),
+    ] = False,
+    thread_path: Annotated[
+        Optional[str],
+        typer.Option(..., help="log all requests to the llm"),
+    ] = None,
+    message: Annotated[
+        Optional[str],
+        typer.Option(..., help="the input message to use"),
+    ] = None,
+    use_web_search: Annotated[
+        Optional[bool],
+        typer.Option(..., help="request the web search tool"),
+    ] = None,
+    use_image_gen: Annotated[
+        Optional[bool],
+        typer.Option(..., help="request the image gen tool"),
+    ] = None,
+    use_storage: Annotated[
+        Optional[bool],
+        typer.Option(..., help="request the storage tool"),
+    ] = None,
+):
+    root = logging.getLogger()
+    root.setLevel(logging.ERROR)
+
+    if database_namespace is not None:
+        database_namespace = database_namespace.split("::")
+
+    key = await resolve_key(project_id=project_id, key=key)
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        room = resolve_room(room)
+
+        jwt = os.getenv("MESHAGENT_TOKEN")
+        if jwt is None:
+            if agent_name is None:
+                print(
+                    "[bold red]--agent-name must be specified when the MESHAGENT_TOKEN environment variable is not set[/bold red]"
+                )
+                raise typer.Exit(1)
+
+            token = ParticipantToken(
+                name=agent_name,
+            )
+
+            token.add_api_grant(ApiScope.agent_default(tunnels=require_computer_use))
+
+            token.add_role_grant(role=role)
+            token.add_room_grant(room)
+
+            jwt = token.to_jwt(api_key=key)
+
+        async with RoomClient(
+            protocol=WebSocketClientProtocol(
+                url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
+                token=jwt,
+            )
+        ) as client:
+            CustomChatbot = build_chatbot(
+                computer_use=computer_use,
+                require_computer_use=require_computer_use,
+                model=model,
+                rule=rule,
+                toolkit=require_toolkit + toolkit,
+                schema=require_schema + schema,
+                rules_file=rules_file,
+                local_shell=local_shell,
+                shell=shell,
+                apply_patch=apply_patch,
+                image_generation=image_generation,
+                web_search=web_search,
+                mcp=mcp,
+                storage=storage,
+                require_apply_patch=require_apply_patch,
+                require_web_search=require_web_search,
+                require_local_shell=require_local_shell,
+                require_shell=require_shell,
+                require_image_generation=require_image_generation,
+                require_mcp=require_mcp,
+                require_storage=require_storage,
+                require_table_read=require_table_read,
+                require_table_write=require_table_write,
+                require_read_only_storage=require_read_only_storage,
+                require_time=require_time,
+                require_uuid=require_uuid,
+                room_rules_path=room_rules,
+                require_document_authoring=require_document_authoring,
+                require_discovery=require_discovery,
+                working_directory=working_directory,
+                llm_participant=llm_participant,
+                always_reply=always_reply,
+                database_namespace=database_namespace,
+                skill_dirs=skill_dir,
+                shell_image=shell_image,
+                delegate_shell_token=delegate_shell_token,
+                log_llm_requests=log_llm_requests,
+            )
+
+            bot = CustomChatbot()
+
+            await bot.start(room=client)
+
+            _, pending = await asyncio.wait(
+                [
+                    asyncio.create_task(client.protocol.wait_for_close()),
+                    asyncio.create_task(
+                        chat_with(
+                            participant_name=client.local_participant.get_attribute(
+                                "name"
+                            ),
+                            room=room,
+                            project_id=project_id,
+                            thread_path=thread_path,
+                            message=message,
+                            use_web_search=use_web_search,
+                            use_image_gen=use_image_gen,
+                            use_storage=use_storage,
+                        )
+                    ),
+                ],
+                return_when="FIRST_COMPLETED",
+            )
+
+            for t in pending:
+                t.cancel()
+
+    except asyncio.CancelledError:
+        return
+
+    finally:
+        await account_client.close()
+
+
+@app.async_command("use")
+async def use(
+    *,
+    project_id: ProjectIdOption,
+    room: RoomOption,
+    agent_name: Annotated[
+        Optional[str], typer.Option(..., help="Name of the agent to call")
+    ] = None,
+    thread_path: Annotated[
+        Optional[str],
+        typer.Option(..., help="log all requests to the llm"),
+    ] = None,
+    message: Annotated[
+        Optional[str],
+        typer.Option(..., help="the input message to use"),
+    ] = None,
+    use_web_search: Annotated[
+        Optional[bool],
+        typer.Option(..., help="request the web search tool"),
+    ] = None,
+    use_image_gen: Annotated[
+        Optional[bool],
+        typer.Option(..., help="request the image gen tool"),
+    ] = None,
+    use_storage: Annotated[
+        Optional[bool],
+        typer.Option(..., help="request the storage tool"),
+    ] = None,
+):
+    root = logging.getLogger()
+    root.setLevel(logging.ERROR)
+
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        room = resolve_room(room)
+
+        await chat_with(
+            participant_name=agent_name,
+            room=room,
+            project_id=project_id,
+            thread_path=thread_path,
+            message=message,
+            use_web_search=use_web_search,
+            use_image_gen=use_image_gen,
+            use_storage=use_storage,
+        )
+
+    except asyncio.CancelledError:
+        return
+
+    finally:
+        await account_client.close()