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

meshagent/cli/task_runner.py

@@ -1,5 +1,6 @@
 import typer
 import json
+import os
 from rich import print
 from typing import Annotated, Optional
 from meshagent.tools import Toolkit
@@ -21,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
@@ -29,9 +31,11 @@ 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
@@ -55,17 +59,24 @@ from meshagent.openai.tools.responses_adapter import (
     ImageGenerationTool,
 )
 
+from meshagent.cli.host import get_service, run_services, get_deferred, service_specs
 from meshagent.tools.database import DatabaseToolkitBuilder, DatabaseToolkitConfig
 from meshagent.agents.adapter import MessageStreamLLMAdapter
 from meshagent.agents.context import AgentCallContext
 
 from meshagent.api import RequiredToolkit, RequiredSchema
-from meshagent.api.services import ServiceHost
+from meshagent.api.specs.service import AgentSpec, ANNOTATION_AGENT_TYPE
 import logging
 import os.path
 
 from urllib.request import urlopen
 
+import yaml
+import shlex
+import sys
+
+from meshagent.api.client import ConflictError
+
 logger = logging.getLogger("taskrunner")
 
 app = async_typer.AsyncTyper(help="Join a taskrunner to a room")
@@ -74,7 +85,6 @@ app = async_typer.AsyncTyper(help="Join a taskrunner to a room")
 def build_task_runner(
     *,
     model: str,
-    agent_name: str,
     rule: List[str],
     toolkit: List[str],
     schema: List[str],
@@ -107,6 +117,7 @@ def build_task_runner(
     title: Optional[str] = None,
     description: Optional[str] = None,
     shell_image: Optional[str] = None,
+    delegate_shell_token: Optional[bool] = None,
 ):
     output_schema = None
     if output_schema_str is not None:
@@ -153,15 +164,15 @@ def build_task_runner(
             participant_name=llm_participant,
         )
     else:
-        llm_adapter = OpenAIResponsesAdapter(
-            model=model,
-        )
+        if model.startswith("claude-"):
+            llm_adapter = AnthropicOpenAIResponsesStreamAdapter(model=model)
+        else:
+            llm_adapter = OpenAIResponsesAdapter(model=model)
 
     class CustomTaskRunner(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,
@@ -179,13 +190,20 @@ def build_task_runner(
                 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,
-            context: AgentCallContext,
+            participant: Optional[RemoteParticipant] = None,
         ):
-            participant = context.caller
             rules = []
             try:
                 room_rules = await self.room.storage.download(path=path)
@@ -229,7 +247,9 @@ def build_task_runner(
 
             if room_rules_path is not None:
                 for p in room_rules_path:
-                    rules.extend(await self._load_room_rules(path=p, context=context))
+                    rules.extend(
+                        await self._load_room_rules(path=p, participant=context.caller)
+                    )
 
             logging.info(f"using rules {rules}")
 
@@ -256,12 +276,17 @@ def build_task_runner(
                     )
                 )
 
+            env = {}
+            if delegate_shell_token:
+                env["MESHAGENT_TOKEN"] = self.room.protocol.token
+
             if require_shell:
                 providers.append(
                     ShellTool(
                         working_directory=working_directory,
                         config=ShellConfig(name="shell"),
                         image=shell_image or "python:3.13",
+                        env=env,
                     )
                 )
 
@@ -375,12 +400,14 @@ def build_task_runner(
 
 
 @app.async_command("join")
-async def make_call(
+async def join(
     *,
     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],
@@ -476,6 +503,10 @@ async def make_call(
         Optional[str],
         typer.Option(..., help="The default working directory for shell commands"),
     ] = None,
+    delegate_shell_token: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Delegate the room token to shell tools"),
+    ] = False,
     key: Annotated[
         str,
         typer.Option("--key", help="an api key to sign the token with"),
@@ -513,79 +544,94 @@ async def make_call(
         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_api_grant(ApiScope.agent_default())
 
-        token.add_role_grant(role=role)
-        token.add_room_grant(room)
+            token.add_role_grant(role=role)
+            token.add_room_grant(room)
 
-        jwt = token.to_jwt(api_key=key)
+            jwt = token.to_jwt(api_key=key)
 
         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 = []
+        requirements = []
 
-            for t in toolkit:
-                requirements.append(RequiredToolkit(name=t))
+        for t in toolkit:
+            requirements.append(RequiredToolkit(name=t))
 
-            for t in schema:
-                requirements.append(RequiredSchema(name=t))
+        for t in schema:
+            requirements.append(RequiredSchema(name=t))
 
-            CustomTaskRunner = build_task_runner(
-                title=title,
-                description=description,
-                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,
-                require_table_read=require_table_read,
-                require_table_write=require_table_write,
-                require_read_only_storage=require_read_only_storage,
-                room_rules_path=room_rules,
-                require_document_authoring=require_document_authoring,
-                require_discovery=require_discovery,
-                working_directory=working_directory,
-                llm_participant=llm_participant,
-                output_schema_str=output_schema,
-                output_schema_path=output_schema_path,
-                annotations=json.loads(annotations) if annotations != "" else {},
-            )
+        CustomTaskRunner = build_task_runner(
+            title=title,
+            description=description,
+            model=model,
+            local_shell=local_shell,
+            shell=shell,
+            apply_patch=apply_patch,
+            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,
+            require_table_read=require_table_read,
+            require_table_write=require_table_write,
+            require_read_only_storage=require_read_only_storage,
+            room_rules_path=room_rules,
+            require_document_authoring=require_document_authoring,
+            require_discovery=require_discovery,
+            working_directory=working_directory,
+            delegate_shell_token=delegate_shell_token,
+            llm_participant=llm_participant,
+            output_schema_str=output_schema,
+            output_schema_path=output_schema_path,
+            annotations=json.loads(annotations) if annotations != "" else {},
+        )
 
-            bot = CustomTaskRunner()
+        bot = CustomTaskRunner()
 
-            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,
+        if get_deferred():
+            from meshagent.cli.host import agents
+
+            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()
@@ -681,6 +727,10 @@ async def service(
         Optional[str],
         typer.Option(..., help="The default working directory for shell commands"),
     ] = None,
+    delegate_shell_token: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Delegate the room token to shell tools"),
+    ] = False,
     require_document_authoring: Annotated[
         Optional[bool],
         typer.Option(..., help="Enable document authoring", hidden=True),
@@ -702,8 +752,8 @@ async def service(
         Optional[int], typer.Option(help="Port to bind the service on")
     ] = None,
     path: Annotated[
-        str, typer.Option(help="HTTP path to mount the service at")
-    ] = "/agent",
+        Optional[str], typer.Option(help="HTTP path to mount the service at")
+    ] = None,
     output_schema: Annotated[
         Optional[str],
         typer.Option(..., help="an output schema to use", hidden=True),
@@ -727,15 +777,26 @@ async def service(
 ):
     print("[bold green]Connecting to room...[/bold green]", flush=True)
 
-    service = ServiceHost(host=host, port=port)
+    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: "TaskRunner"})
+    )
+
     service.add_path(
+        identity=agent_name,
         path=path,
         cls=build_task_runner(
             model=model,
             local_shell=local_shell,
             shell=shell,
             apply_patch=apply_patch,
-            agent_name=agent_name,
             title=title,
             description=description,
             rule=rule,
@@ -758,6 +819,7 @@ async def service(
             require_read_only_storage=require_read_only_storage,
             room_rules_path=room_rules,
             working_directory=working_directory,
+            delegate_shell_token=delegate_shell_token,
             require_document_authoring=require_document_authoring,
             require_discovery=require_discovery,
             llm_participant=llm_participant,
@@ -767,4 +829,489 @@ async def service(
         ),
     )
 
-    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",
+        ),
+    ] = [],
+    toolkit: Annotated[
+        List[str],
+        typer.Option("--toolkit", "-t", help="the name or url of a required toolkit"),
+    ] = [],
+    schema: Annotated[
+        List[str],
+        typer.Option("--schema", "-s", help="the name or url of a required schema"),
+    ] = [],
+    model: Annotated[
+        str, typer.Option(..., help="Name of the LLM model to use for the task runner")
+    ] = "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,
+    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", hidden=True)
+    ] = None,
+    require_local_shell: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable local shell tool calling", hidden=True),
+    ] = False,
+    require_shell: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable function shell tool calling", hidden=True),
+    ] = False,
+    require_apply_patch: Annotated[
+        Optional[bool], typer.Option(..., help="Enable apply patch tool", hidden=True)
+    ] = False,
+    require_web_search: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable web search tool calling", hidden=True),
+    ] = False,
+    require_mcp: Annotated[
+        Optional[bool], typer.Option(..., help="Enable mcp tool calling", hidden=True)
+    ] = False,
+    require_storage: Annotated[
+        Optional[bool], typer.Option(..., help="Enable storage toolkit", hidden=True)
+    ] = False,
+    require_table_read: Annotated[
+        list[str],
+        typer.Option(
+            ..., help="Enable table read tools for a specific table", hidden=True
+        ),
+    ] = [],
+    require_table_write: Annotated[
+        list[str],
+        typer.Option(
+            ..., help="Enable table write tools for a specific table", hidden=True
+        ),
+    ] = [],
+    require_read_only_storage: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable read only storage toolkit", hidden=True),
+    ] = False,
+    working_directory: Annotated[
+        Optional[str],
+        typer.Option(..., help="The default working directory for shell commands"),
+    ] = None,
+    delegate_shell_token: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Delegate the room token to shell tools"),
+    ] = False,
+    require_document_authoring: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable document authoring", hidden=True),
+    ] = False,
+    require_discovery: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable discovery of agents and tools", hidden=True),
+    ] = False,
+    llm_participant: Annotated[
+        Optional[str],
+        typer.Option(
+            ..., help="Delegate LLM interactions to a remote participant", hidden=True
+        ),
+    ] = 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,
+    output_schema: Annotated[
+        Optional[str],
+        typer.Option(..., help="an output schema to use", hidden=True),
+    ] = None,
+    output_schema_path: Annotated[
+        Optional[str],
+        typer.Option(..., help="the path or url to output schema to use", hidden=True),
+    ] = None,
+    annotations: Annotated[
+        str,
+        typer.Option(
+            "--annotations", "-a", help='annotations in json format {"name":"value"}'
+        ),
+    ] = '{"meshagent.task-runner.attachment-format":"tar"}',
+    title: Annotated[
+        Optional[str], typer.Option(..., help="a friendly name for the task runner")
+    ] = None,
+    description: Annotated[
+        Optional[str], typer.Option(..., help="a description for the task runner")
+    ] = None,
+):
+    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: "TaskRunner"})
+    )
+
+    service.add_path(
+        identity=agent_name,
+        path=path,
+        cls=build_task_runner(
+            model=model,
+            local_shell=local_shell,
+            shell=shell,
+            apply_patch=apply_patch,
+            title=title,
+            description=description,
+            rule=rule,
+            toolkit=toolkit,
+            schema=schema,
+            rules_file=rules_file,
+            web_search=web_search,
+            image_generation=image_generation,
+            mcp=mcp,
+            storage=storage,
+            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,
+            room_rules_path=room_rules,
+            working_directory=working_directory,
+            delegate_shell_token=delegate_shell_token,
+            require_document_authoring=require_document_authoring,
+            require_discovery=require_discovery,
+            llm_participant=llm_participant,
+            output_schema_str=output_schema,
+            output_schema_path=output_schema_path,
+            annotations=json.loads(annotations) if annotations != "" else {},
+        ),
+    )
+
+    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", "task-runner", "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",
+        ),
+    ] = [],
+    toolkit: Annotated[
+        List[str],
+        typer.Option("--toolkit", "-t", help="the name or url of a required toolkit"),
+    ] = [],
+    schema: Annotated[
+        List[str],
+        typer.Option("--schema", "-s", help="the name or url of a required schema"),
+    ] = [],
+    model: Annotated[
+        str, typer.Option(..., help="Name of the LLM model to use for the task runner")
+    ] = "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,
+    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", hidden=True)
+    ] = None,
+    require_local_shell: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable local shell tool calling", hidden=True),
+    ] = False,
+    require_shell: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable function shell tool calling", hidden=True),
+    ] = False,
+    require_apply_patch: Annotated[
+        Optional[bool], typer.Option(..., help="Enable apply patch tool", hidden=True)
+    ] = False,
+    require_web_search: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable web search tool calling", hidden=True),
+    ] = False,
+    require_mcp: Annotated[
+        Optional[bool], typer.Option(..., help="Enable mcp tool calling", hidden=True)
+    ] = False,
+    require_storage: Annotated[
+        Optional[bool], typer.Option(..., help="Enable storage toolkit", hidden=True)
+    ] = False,
+    require_table_read: Annotated[
+        list[str],
+        typer.Option(
+            ..., help="Enable table read tools for a specific table", hidden=True
+        ),
+    ] = [],
+    require_table_write: Annotated[
+        list[str],
+        typer.Option(
+            ..., help="Enable table write tools for a specific table", hidden=True
+        ),
+    ] = [],
+    require_read_only_storage: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable read only storage toolkit", hidden=True),
+    ] = False,
+    working_directory: Annotated[
+        Optional[str],
+        typer.Option(..., help="The default working directory for shell commands"),
+    ] = None,
+    delegate_shell_token: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Delegate the room token to shell tools"),
+    ] = False,
+    require_document_authoring: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable document authoring", hidden=True),
+    ] = False,
+    require_discovery: Annotated[
+        Optional[bool],
+        typer.Option(..., help="Enable discovery of agents and tools", hidden=True),
+    ] = False,
+    llm_participant: Annotated[
+        Optional[str],
+        typer.Option(
+            ..., help="Delegate LLM interactions to a remote participant", hidden=True
+        ),
+    ] = 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,
+    output_schema: Annotated[
+        Optional[str],
+        typer.Option(..., help="an output schema to use", hidden=True),
+    ] = None,
+    output_schema_path: Annotated[
+        Optional[str],
+        typer.Option(..., help="the path or url to output schema to use", hidden=True),
+    ] = None,
+    annotations: Annotated[
+        str,
+        typer.Option(
+            "--annotations", "-a", help='annotations in json format {"name":"value"}'
+        ),
+    ] = '{"meshagent.task-runner.attachment-format":"tar"}',
+    title: Annotated[
+        Optional[str], typer.Option(..., help="a friendly name for the task runner")
+    ] = None,
+    description: Annotated[
+        Optional[str], typer.Option(..., help="a description for the task runner")
+    ] = None,
+    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)
+
+    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: "TaskRunner"})
+    )
+
+    service.add_path(
+        identity=agent_name,
+        path=path,
+        cls=build_task_runner(
+            model=model,
+            local_shell=local_shell,
+            shell=shell,
+            apply_patch=apply_patch,
+            title=title,
+            description=description,
+            rule=rule,
+            toolkit=toolkit,
+            schema=schema,
+            rules_file=rules_file,
+            web_search=web_search,
+            image_generation=image_generation,
+            mcp=mcp,
+            storage=storage,
+            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,
+            room_rules_path=room_rules,
+            working_directory=working_directory,
+            delegate_shell_token=delegate_shell_token,
+            require_document_authoring=require_document_authoring,
+            require_discovery=require_discovery,
+            llm_participant=llm_participant,
+            output_schema_str=output_schema,
+            output_schema_path=output_schema_path,
+            annotations=json.loads(annotations) if annotations != "" else {},
+        ),
+    )
+
+    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", "task-runner", "service", *cleanup_args(sys.argv[2:])]
+    )
+
+    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()