meshagent-cli 0.6.1__py3-none-any.whl

meshagent/cli/chatbot.py

@@ -0,0 +1,311 @@
+import typer
+from rich import print
+from typing import Annotated, Optional
+from meshagent.tools.storage import StorageToolkitBuilder
+from meshagent.cli.common_options import (
+    ProjectIdOption,
+    RoomOption,
+)
+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_room,
+    resolve_key,
+)
+
+from meshagent.openai import OpenAIResponsesAdapter
+
+
+from typing import List
+from pathlib import Path
+
+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")
+
+
+def build_chatbot(
+    *,
+    model: str,
+    agent_name: str,
+    rule: List[str],
+    toolkit: List[str],
+    schema: List[str],
+    image_generation: Optional[str] = None,
+    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 = []
+
+    for t in toolkit:
+        requirements.append(RequiredToolkit(name=t))
+
+    for t in schema:
+        requirements.append(RequiredSchema(name=t))
+
+    if rules_file is not None:
+        try:
+            with open(Path(rules_file).resolve(), "r") as f:
+                rule.extend(f.read().splitlines())
+        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",
+            },
+        )
+    else:
+        llm_adapter = OpenAIResponsesAdapter(
+            model=model,
+        )
+
+    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,
+            )
+
+        async def get_thread_toolkit_builders(self, *, thread_context, participant):
+            providers = []
+
+            if image_generation:
+                providers.append(
+                    ChatBotThreadOpenAIImageGenerationToolkitBuilder(
+                        thread_context=thread_context
+                    )
+                )
+
+            if local_shell:
+                providers.append(
+                    ChatBotThreadLocalShellToolkitBuilder(thread_context=thread_context)
+                )
+
+            if mcp:
+                providers.append(MCPToolkitBuilder())
+
+            if web_search:
+                providers.append(WebSearchToolkitBuilder())
+
+            if storage:
+                providers.append(StorageToolkitBuilder())
+
+            return providers
+
+    return CustomChatbot
+
+
+@app.async_command("join")
+async def make_call(
+    *,
+    project_id: ProjectIdOption = None,
+    room: RoomOption,
+    role: str = "agent",
+    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,
+    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 chatbot")
+    ] = "gpt-5",
+    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,
+    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)
+        room = resolve_room(room)
+
+        token = ParticipantToken(
+            name=agent_name,
+        )
+
+        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(
+                url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
+                token=jwt,
+            )
+        ) as client:
+            requirements = []
+
+            for t in toolkit:
+                requirements.append(RequiredToolkit(name=t))
+
+            for t in schema:
+                requirements.append(RequiredSchema(name=t))
+
+            CustomChatbot = build_chatbot(
+                computer_use=computer_use,
+                model=model,
+                local_shell=local_shell,
+                agent_name=agent_name,
+                rule=rule,
+                toolkit=toolkit,
+                schema=schema,
+                image_generation=image_generation,
+                web_search=web_search,
+                rules_file=rules_file,
+                mcp=mcp,
+                storage=storage,
+            )
+
+            bot = CustomChatbot()
+
+            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()
+
+
+@app.async_command("service")
+async def service(
+    *,
+    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,
+    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 chatbot")
+    ] = "gpt-5",
+    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,
+    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,
+    host: Annotated[Optional[str], typer.Option()] = None,
+    port: Annotated[Optional[int], typer.Option()] = None,
+    path: Annotated[str, typer.Option()] = "/agent",
+):
+    print("[bold green]Connecting to room...[/bold green]", flush=True)
+
+    service = ServiceHost(host=host, port=port)
+    service.add_path(
+        path=path,
+        cls=build_chatbot(
+            computer_use=computer_use,
+            model=model,
+            local_shell=local_shell,
+            agent_name=agent_name,
+            rule=rule,
+            toolkit=toolkit,
+            schema=schema,
+            web_search=web_search,
+            image_generation=image_generation,
+            rules_file=rules_file,
+            mcp=mcp,
+            storage=storage,
+        ),
+    )
+
+    await service.run()

meshagent/cli/cli.py

@@ -0,0 +1,184 @@
+import typer
+import asyncio
+
+from meshagent.cli import async_typer
+
+from meshagent.cli import queue
+from meshagent.cli import auth
+from meshagent.cli import api_keys
+from meshagent.cli import projects
+from meshagent.cli import sessions
+from meshagent.cli import participant_token
+from meshagent.cli import agent
+from meshagent.cli import messaging
+from meshagent.cli import storage
+from meshagent.cli import developer
+from meshagent.cli import webhook
+from meshagent.cli import services
+from meshagent.cli import cli_secrets
+from meshagent.cli import call
+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 art import tprint
+
+import logging
+
+import os
+import sys
+from pathlib import Path
+
+otel_config(service_name="meshagent-cli")
+
+
+# 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(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")
+app.add_typer(api_keys.app, name="api-key")
+app.add_typer(sessions.app, name="session")
+app.add_typer(participant_token.app, name="participant-token")
+app.add_typer(agent.app, name="agents")
+app.add_typer(messaging.app, name="messaging")
+app.add_typer(storage.app, name="storage")
+app.add_typer(developer.app, name="developer")
+app.add_typer(webhook.app, name="webhook")
+app.add_typer(services.app, name="service")
+app.add_typer(cli_secrets.app, name="secret")
+app.add_typer(queue.app, name="queue")
+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)
+
+
+def _run_async(coro):
+    asyncio.run(coro)
+
+
+def detect_shell() -> str:
+    """
+    Best-effort detection of the *current* interactive shell.
+
+    Order of preference
+    1. Explicit --shell argument (handled by Typer)
+    2. Per-shell env vars set by the running shell
+       • BASH_VERSION / ZSH_VERSION / FISH_VERSION
+    3. $SHELL on POSIX (user’s login shell – still correct >90 % of the time)
+    4. Parent process on Windows (COMSPEC → cmd / powershell)
+    5. Safe default: 'bash'
+    """
+    # Per-shell version variables (works even if login shell ≠ current shell)
+    for var, name in (
+        ("ZSH_VERSION", "zsh"),
+        ("BASH_VERSION", "bash"),
+        ("FISH_VERSION", "fish"),
+    ):
+        if var in os.environ:
+            return name
+
+    # POSIX fallback: login shell path
+    sh = os.environ.get("SHELL")
+    if sh:
+        return Path(sh).name.lower()
+
+    # Windows heuristics
+    if sys.platform == "win32":
+        comspec = Path(os.environ.get("COMSPEC", "")).name.lower()
+        if "powershell" in comspec:
+            return "powershell"
+        if "cmd" in comspec:
+            return "cmd"
+        return "powershell"  # sensible default on modern Windows
+
+    # Last-ditch default
+    return "bash"
+
+
+def _bash_like(name: str, value: str, unset: bool) -> str:
+    return f"unset {name}" if unset else f'export {name}="{value}"'
+
+
+def _fish(name: str, value: str, unset: bool) -> str:
+    return f"set -e {name}" if unset else f'set -gx {name} "{value}"'
+
+
+def _powershell(name: str, value: str, unset: bool) -> str:
+    return f"Remove-Item Env:{name}" if unset else f'$Env:{name}="{value}"'
+
+
+def _cmd(name: str, value: str, unset: bool) -> str:
+    return f"set {name}=" if unset else f"set {name}={value}"
+
+
+SHELL_RENDERERS = {
+    "bash": _bash_like,
+    "zsh": _bash_like,
+    "fish": _fish,
+    "powershell": _powershell,
+    "cmd": _cmd,
+}
+
+
+@app.command(
+    "version",
+    help="Print the version",
+)
+def version():
+    print(__version__)
+
+
+@app.command("setup")
+def setup_command():
+    """Perform initial login and project/api key activation."""
+
+    async def runner():
+        print("\n", flush=True)
+        tprint("MeshAgent", "tarty10")
+        print("\n", flush=True)
+        await auth.login()
+        print("Activate a project...")
+        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
+            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())
+
+
+if __name__ == "__main__":
+    app()