meshagent-cli 0.5.18__py3-none-any.whl → 0.6.0__py3-none-any.whl

meshagent/cli/chatbot.py

@@ -1,36 +1,38 @@
 import typer
 from rich import print
 from typing import Annotated, Optional
+from meshagent.tools.storage import StorageToolkitBuilder
 from meshagent.cli.common_options import (
     ProjectIdOption,
-    ApiKeyIdOption,
     RoomOption,
 )
-from meshagent.tools import Toolkit
-from meshagent.api import RoomClient, WebSocketClientProtocol
+from meshagent.api import (
+    RoomClient,
+    WebSocketClientProtocol,
+    ParticipantToken,
+    ApiScope,
+)
 from meshagent.api.helpers import meshagent_base_url, websocket_room_url
 from meshagent.cli import async_typer
 from meshagent.cli.helper import (
     get_client,
     resolve_project_id,
-    resolve_api_key,
-    resolve_token_jwt,
     resolve_room,
+    resolve_key,
 )
-from meshagent.agents.chat import ChatBot
+
 from meshagent.openai import OpenAIResponsesAdapter
-from meshagent.api.services import ServiceHost
-from meshagent.computers.agent import ComputerAgent
-from meshagent.agents.chat import (
-    ChatBotThreadOpenAIImageGenerationTool,
-    ChatBotThreadLocalShellTool,
-)
+
 
 from typing import List
 from pathlib import Path
 
-from meshagent.openai.tools.responses_adapter import WebSearchTool
+from meshagent.openai.tools.responses_adapter import (
+    WebSearchToolkitBuilder,
+    MCPToolkitBuilder,
+)
 from meshagent.api import RequiredToolkit, RequiredSchema
+from meshagent.api.services import ServiceHost
 
 app = async_typer.AsyncTyper(help="Join a chatbot to a room")
 
@@ -46,8 +48,17 @@ def build_chatbot(
     local_shell: bool,
     computer_use: bool,
     web_search: bool,
+    mcp: bool,
+    storage: bool,
     rules_file: Optional[str] = None,
 ):
+    from meshagent.agents.chat import ChatBot
+
+    from meshagent.agents.chat import (
+        ChatBotThreadOpenAIImageGenerationToolkitBuilder,
+        ChatBotThreadLocalShellToolkitBuilder,
+    )
+
     requirements = []
 
     toolkits = []
@@ -67,8 +78,13 @@ def build_chatbot(
 
     BaseClass = ChatBot
     if computer_use:
-        BaseClass = ComputerAgent
+        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={
@@ -77,7 +93,9 @@ def build_chatbot(
             },
         )
     else:
-        llm_adapter = OpenAIResponsesAdapter(model=model)
+        llm_adapter = OpenAIResponsesAdapter(
+            model=model,
+        )
 
     class CustomChatbot(BaseClass):
         def __init__(self):
@@ -89,33 +107,31 @@ def build_chatbot(
                 rules=rule if len(rule) > 0 else None,
             )
 
-        async def get_thread_toolkits(self, *, thread_context, participant):
-            toolkits = await super().get_thread_toolkits(
-                thread_context=thread_context, participant=participant
-            )
+        async def get_thread_toolkit_builders(self, *, thread_context, participant):
+            providers = []
 
-            thread_toolkit = Toolkit(name="thread_toolkit", tools=[])
+            if image_generation:
+                providers.append(
+                    ChatBotThreadOpenAIImageGenerationToolkitBuilder(
+                        thread_context=thread_context
+                    )
+                )
 
             if local_shell:
-                thread_toolkit.tools.append(
-                    ChatBotThreadLocalShellTool(thread_context=thread_context)
+                providers.append(
+                    ChatBotThreadLocalShellToolkitBuilder(thread_context=thread_context)
                 )
 
-            if image_generation is not None:
-                print("adding openai image gen to thread", flush=True)
-                thread_toolkit.tools.append(
-                    ChatBotThreadOpenAIImageGenerationTool(
-                        model=image_generation,
-                        thread_context=thread_context,
-                        partial_images=3,
-                    )
-                )
+            if mcp:
+                providers.append(MCPToolkitBuilder())
 
             if web_search:
-                thread_toolkit.tools.append(WebSearchTool())
+                providers.append(WebSearchToolkitBuilder())
+
+            if storage:
+                providers.append(StorageToolkitBuilder())
 
-            toolkits.append(thread_toolkit)
-            return toolkits
+            return providers
 
     return CustomChatbot
 
@@ -124,11 +140,9 @@ def build_chatbot(
 async def make_call(
     *,
     project_id: ProjectIdOption = None,
-    room: RoomOption = None,
-    api_key_id: ApiKeyIdOption = None,
+    room: RoomOption,
     role: str = "agent",
     agent_name: Annotated[str, typer.Option(..., help="Name of the agent to call")],
-    token_path: Annotated[Optional[str], typer.Option()] = None,
     rule: Annotated[List[str], typer.Option("--rule", "-r", help="a system rule")] = [],
     rules_file: Optional[str] = None,
     toolkit: Annotated[
@@ -141,7 +155,7 @@ async def make_call(
     ] = [],
     model: Annotated[
         str, typer.Option(..., help="Name of the LLM model to use for the chatbot")
-    ] = "gpt-4o",
+    ] = "gpt-5",
     image_generation: Annotated[
         Optional[str], typer.Option(..., help="Name of an image gen model")
     ] = None,
@@ -157,21 +171,34 @@ async def make_call(
     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,
+    key: Annotated[
+        str,
+        typer.Option("--key", help="an api key to sign the token with"),
+    ] = None,
 ):
+    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)
-        api_key_id = await resolve_api_key(project_id, api_key_id)
         room = resolve_room(room)
-        jwt = await resolve_token_jwt(
-            project_id=project_id,
-            api_key_id=api_key_id,
-            token_path=token_path,
+
+        token = ParticipantToken(
             name=agent_name,
-            role=role,
-            room=room,
         )
 
+        token.add_api_grant(ApiScope.agent_default())
+
+        token.add_role_grant(role=role)
+        token.add_room_grant(room)
+
+        jwt = token.to_jwt(api_key=key)
+
         print("[bold green]Connecting to room...[/bold green]", flush=True)
         async with RoomClient(
             protocol=WebSocketClientProtocol(
@@ -198,6 +225,8 @@ async def make_call(
                 image_generation=image_generation,
                 web_search=web_search,
                 rules_file=rules_file,
+                mcp=mcp,
+                storage=storage,
             )
 
             bot = CustomChatbot()
@@ -219,7 +248,6 @@ async def make_call(
 @app.async_command("service")
 async def service(
     *,
-    room: RoomOption = 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,
@@ -233,7 +261,7 @@ async def service(
     ] = [],
     model: Annotated[
         str, typer.Option(..., help="Name of the LLM model to use for the chatbot")
-    ] = "gpt-4o",
+    ] = "gpt-5",
     image_generation: Annotated[
         Optional[str], typer.Option(..., help="Name of an image gen model")
     ] = None,
@@ -249,12 +277,16 @@ async def service(
     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,
     host: Annotated[Optional[str], typer.Option()] = None,
     port: Annotated[Optional[int], typer.Option()] = None,
     path: Annotated[str, typer.Option()] = "/agent",
 ):
-    room = resolve_room(room)
-
     print("[bold green]Connecting to room...[/bold green]", flush=True)
 
     service = ServiceHost(host=host, port=port)
@@ -271,6 +303,8 @@ async def service(
             web_search=web_search,
             image_generation=image_generation,
             rules_file=rules_file,
+            mcp=mcp,
+            storage=storage,
         ),
     )
 

meshagent/cli/cli.py

@@ -1,6 +1,5 @@
 import typer
 import asyncio
-from typing import Optional
 
 from meshagent.cli import async_typer
 
@@ -22,10 +21,15 @@ from meshagent.cli import cli_mcp
 from meshagent.cli import chatbot
 from meshagent.cli import voicebot
 from meshagent.cli import mailbot
+from meshagent.cli import containers
+from meshagent.cli import oauth2
+from meshagent.cli import helpers
+from meshagent.cli import meeting_transcriber
 from meshagent.cli.exec import register as register_exec
 from meshagent.cli.version import __version__
+from meshagent.cli.helper import get_active_api_key
+from meshagent.otel import otel_config
 
-from meshagent.cli import otel
 
 from art import tprint
 
@@ -34,16 +38,15 @@ import logging
 import os
 import sys
 from pathlib import Path
-from meshagent.cli.helper import get_client, resolve_project_id, resolve_api_key
 
+otel_config(service_name="meshagent-cli")
 
-otel.init(level=logging.INFO)
 
 # Turn down OpenAI logs, they are a bit noisy
 logging.getLogger("openai").setLevel(logging.ERROR)
 logging.getLogger("httpx").setLevel(logging.ERROR)
 
-app = async_typer.AsyncTyper()
+app = async_typer.AsyncTyper(no_args_is_help=True)
 app.add_typer(call.app, name="call")
 app.add_typer(auth.app, name="auth")
 app.add_typer(projects.app, name="project")
@@ -62,6 +65,10 @@ app.add_typer(cli_mcp.app, name="mcp")
 app.add_typer(chatbot.app, name="chatbot")
 app.add_typer(voicebot.app, name="voicebot")
 app.add_typer(mailbot.app, name="mailbot")
+app.add_typer(containers.app, name="container")
+app.add_typer(oauth2.app, name="oauth2")
+app.add_typer(helpers.app, name="helpers")
+app.add_typer(meeting_transcriber.app, name="meeting-transcriber")
 
 register_exec(app)
 
@@ -142,66 +149,6 @@ def version():
     print(__version__)
 
 
-@app.command(
-    "env",
-    help="Generate shell commands to set meshagent environment variables.",
-)
-def env(
-    shell: Optional[str] = typer.Option(
-        None,
-        "--shell",
-        case_sensitive=False,
-        help="bash | zsh | fish | powershell | cmd",
-    ),
-    unset: bool = typer.Option(
-        False, "--unset", help="Output commands to unset the variables."
-    ),
-):
-    """Print shell-specific exports/unsets for Docker environment variables."""
-
-    async def command():
-        nonlocal shell, unset
-        shell = (shell or detect_shell()).lower()
-        if shell not in SHELL_RENDERERS:
-            typer.echo(f"Unsupported shell '{shell}'.", err=True)
-            raise typer.Exit(code=1)
-
-        client = await get_client()
-        try:
-            project_id = await resolve_project_id(project_id=None)
-            api_key_id = await resolve_api_key(project_id=project_id, api_key_id=None)
-
-            token = (
-                await client.decrypt_project_api_key(
-                    project_id=project_id, id=api_key_id
-                )
-            )["token"]
-        finally:
-            await client.close()
-
-        vars = {
-            "MESHAGENT_PROJECT_ID": project_id,
-            "MESHAGENT_KEY_ID": api_key_id,
-            "MESHAGENT_SECRET": token,
-        }
-        if shell not in SHELL_RENDERERS:
-            typer.echo(f"Unsupported shell '{shell}'.", err=True)
-            raise typer.Exit(code=1)
-
-        render = SHELL_RENDERERS[shell]
-
-        for name, value in vars.items():
-            typer.echo(render(name, value, unset))
-
-        if not unset and shell in ("bash", "zsh"):
-            typer.echo(
-                "\n# Run this command to configure your current shell:\n"
-                '# eval "$(meshagent env)"'
-            )
-
-    _run_async(command())
-
-
 @app.command("setup")
 def setup_command():
     """Perform initial login and project/api key activation."""
@@ -215,11 +162,20 @@ def setup_command():
         project_id = await projects.activate(None, interactive=True)
         if project_id is None:
             print("You have choosen to not activate a project. Exiting.")
-        if project_id is not None:
-            print("Activate an api-key...")
-            api_key_id = await api_keys.activate(None, interactive=True)
-            if api_key_id is None:
-                print("You have choosen to not activate an api-key. Exiting.")
+        if (
+            project_id is not None
+            and await get_active_api_key(project_id=project_id) is None
+        ):
+            if typer.confirm(
+                "You do not have an active api key for this project. Would you like to create and activate a new api key?",
+                default=True,
+            ):
+                name = typer.prompt(
+                    "Enter a name for your API Key (must be a unique name):"
+                )
+                await api_keys.create(
+                    project_id=None, activate=True, silent=True, name=name
+                )
 
     _run_async(runner())
 

meshagent/cli/cli_mcp.py

@@ -1,11 +1,7 @@
-from mcp.client.session import ClientSession
-from mcp.client.sse import sse_client
-from mcp.client.stdio import stdio_client, StdioServerParameters
-
 import typer
 from rich import print
 from typing import Annotated, Optional, List
-from meshagent.cli.common_options import ProjectIdOption, ApiKeyIdOption, RoomOption
+from meshagent.cli.common_options import ProjectIdOption, RoomOption
 
 from meshagent.api.helpers import meshagent_base_url, websocket_room_url
 from meshagent.api import RoomClient, WebSocketClientProtocol, RoomException
@@ -13,21 +9,32 @@ from meshagent.cli import async_typer
 from meshagent.cli.helper import (
     get_client,
     resolve_project_id,
-    resolve_api_key,
-    resolve_token_jwt,
     resolve_room,
+    resolve_key,
 )
 
 from meshagent.tools.hosting import RemoteToolkit
 
-from meshagent.mcp import MCPToolkit
 
 from meshagent.api.services import ServiceHost
 import os
 
-from meshagent.cli.services import _kv_to_dict
 import shlex
 
+from meshagent.api import ParticipantToken, ApiScope
+
+
+def _kv_to_dict(pairs: List[str]) -> dict[str, str]:
+    """Convert ["A=1","B=2"] → {"A":"1","B":"2"}."""
+    out: dict[str, str] = {}
+    for p in pairs:
+        if "=" not in p:
+            raise typer.BadParameter(f"'{p}' must be KEY=VALUE")
+        k, v = p.split("=", 1)
+        out[k] = v
+    return out
+
+
 app = async_typer.AsyncTyper()
 
 
@@ -36,30 +43,41 @@ async def sse(
     *,
     project_id: ProjectIdOption = None,
     room: RoomOption,
-    token_path: Annotated[Optional[str], typer.Option()] = None,
-    api_key_id: ApiKeyIdOption = None,
     name: Annotated[str, typer.Option(..., help="Participant name")] = "cli",
     role: str = "tool",
     url: Annotated[str, typer.Option()],
     toolkit_name: Annotated[Optional[str], typer.Option()] = None,
+    key: Annotated[
+        str,
+        typer.Option("--key", help="an api key to sign the token with"),
+    ] = None,
 ):
+    from mcp.client.session import ClientSession
+    from mcp.client.sse import sse_client
+
+    from meshagent.mcp import MCPToolkit
+
+    key = await resolve_key(project_id=project_id, key=key)
+
     if toolkit_name is None:
         toolkit_name = "mcp"
 
     account_client = await get_client()
     try:
         project_id = await resolve_project_id(project_id=project_id)
-        api_key_id = await resolve_api_key(project_id, api_key_id)
         room = resolve_room(room)
-        jwt = await resolve_token_jwt(
-            project_id=project_id,
-            api_key_id=api_key_id,
-            token_path=token_path,
+
+        token = ParticipantToken(
             name=name,
-            role=role,
-            room=room,
         )
 
+        token.add_api_grant(ApiScope.agent_default())
+
+        token.add_role_grant(role=role)
+        token.add_room_grant(room)
+
+        jwt = token.to_jwt(api_key=key)
+
         print("[bold green]Connecting to room...[/bold green]")
         async with RoomClient(
             protocol=WebSocketClientProtocol(
@@ -103,31 +121,42 @@ async def stdio(
     *,
     project_id: ProjectIdOption = None,
     room: RoomOption,
-    token_path: Annotated[Optional[str], typer.Option()] = None,
-    api_key_id: ApiKeyIdOption = None,
     name: Annotated[str, typer.Option(..., help="Participant name")] = "cli",
     role: str = "tool",
     command: Annotated[str, typer.Option()],
     toolkit_name: Annotated[Optional[str], typer.Option()] = None,
     env: Annotated[List[str], typer.Option("--env", "-e", help="KEY=VALUE")] = [],
+    key: Annotated[
+        str,
+        typer.Option("--key", help="an api key to sign the token with"),
+    ] = None,
 ):
+    from mcp.client.session import ClientSession
+    from mcp.client.stdio import stdio_client, StdioServerParameters
+
+    from meshagent.mcp import MCPToolkit
+
+    key = await resolve_key(project_id=project_id, key=key)
+
     if toolkit_name is None:
         toolkit_name = "mcp"
 
     account_client = await get_client()
     try:
         project_id = await resolve_project_id(project_id=project_id)
-        api_key_id = await resolve_api_key(project_id, api_key_id)
         room = resolve_room(room)
-        jwt = await resolve_token_jwt(
-            project_id=project_id,
-            api_key_id=api_key_id,
-            token_path=token_path,
+
+        token = ParticipantToken(
             name=name,
-            role=role,
-            room=room,
         )
 
+        token.add_api_grant(ApiScope.agent_default())
+
+        token.add_role_grant(role=role)
+        token.add_room_grant(room)
+
+        jwt = token.to_jwt(api_key=key)
+
         print("[bold green]Connecting to room...[/bold green]")
         async with RoomClient(
             protocol=WebSocketClientProtocol(
@@ -253,6 +282,11 @@ async def stdio_service(
     toolkit_name: Annotated[Optional[str], typer.Option()] = None,
     env: Annotated[List[str], typer.Option("--env", "-e", help="KEY=VALUE")] = [],
 ):
+    from mcp.client.session import ClientSession
+    from mcp.client.stdio import stdio_client, StdioServerParameters
+
+    from meshagent.mcp import MCPToolkit
+
     try:
         parsed_command = shlex.split(command)
 

meshagent/cli/cli_secrets.py

@@ -8,7 +8,7 @@ from meshagent.cli.common_options import ProjectIdOption
 
 from meshagent.cli import async_typer
 from meshagent.cli.helper import get_client, print_json_table, resolve_project_id
-from meshagent.api.accounts_client import (
+from meshagent.api.client import (
     PullSecret,
     KeysSecret,
     SecretLike,

meshagent/cli/common_options.py

@@ -14,18 +14,10 @@ ProjectIdOption = Annotated[
     ),
 ]
 
-ApiKeyIdOption = Annotated[
-    Optional[str],
-    typer.Option(
-        "--api-key-id",
-        help="A MeshAgent project API key id. If empty, the activated api key will be used.",
-    ),
-]
-
 RoomOption = Annotated[
-    Optional[str],
+    str,
     typer.Option(
         "--room",
-        help="Room name. If empty, the MESHAGENT_ROOM environment variable will be used.",
+        help="Room name",
     ),
 ]