meshagent-cli 0.0.36__py3-none-any.whl → 0.0.38__py3-none-any.whl

meshagent/cli/call.py

@@ -1,35 +1,37 @@
-
 import typer
 from rich import print
 from typing import Annotated, Optional
 import json
 import aiohttp
-from meshagent.api import RoomClient, ParticipantToken, WebSocketClientProtocol, RoomException, ParticipantGrant
+from meshagent.api import (
+    RoomClient,
+    ParticipantToken,
+    WebSocketClientProtocol,
+    ParticipantGrant,
+)
 from meshagent.api.helpers import meshagent_base_url, websocket_room_url
 from meshagent.api.services import send_webhook
 from meshagent.cli import async_typer
-from meshagent.cli.helper import get_client, print_json_table, set_active_project, resolve_project_id
-from meshagent.cli.helper import set_active_project, get_active_project, resolve_project_id, resolve_api_key
-
-app = async_typer.AsyncTyper()
-
+from meshagent.cli.helper import get_client, resolve_project_id
+from meshagent.cli.helper import resolve_api_key
 from urllib.parse import urlparse
 from pathlib import PurePath
 import socket
 import ipaddress
 
+app = async_typer.AsyncTyper()
+
 PRIVATE_NETS = (
     ipaddress.ip_network("10.0.0.0/8"),
     ipaddress.ip_network("172.16.0.0/12"),
     ipaddress.ip_network("192.168.0.0/16"),
-    ipaddress.ip_network("169.254.0.0/16"),      # IPv4 link-local
-    ipaddress.ip_network("fc00::/7"),            # IPv6 unique-local
-    ipaddress.ip_network("fe80::/10"),           # IPv6 link-local
+    ipaddress.ip_network("169.254.0.0/16"),  # IPv4 link-local
+    ipaddress.ip_network("fc00::/7"),  # IPv6 unique-local
+    ipaddress.ip_network("fe80::/10"),  # IPv6 link-local
 )
 
 
 def is_local_url(url: str) -> bool:
-
     """
     Return True if *url* points to the local machine or a private-LAN host.
     """
@@ -42,14 +44,14 @@ def is_local_url(url: str) -> bool:
 
     # 2. Quick loop-back check on hostname literal
     hostname = parsed.hostname
-    if hostname in {"localhost", None}:          # None ⇒ something like "http:///path"
+    if hostname in {"localhost", None}:  # None ⇒ something like "http:///path"
         return True
 
     try:
         # Accept both direct IP literals and DNS names
         addr_info = socket.getaddrinfo(hostname, None)
     except socket.gaierror:
-        return False        # Unresolvable host ⇒ treat as non-local (or raise)
+        return False  # Unresolvable host ⇒ treat as non-local (or raise)
 
     for *_, sockaddr in addr_info:
         ip_str = sockaddr[0]
@@ -75,7 +77,9 @@ async def make_call(
     local: Optional[bool] = None,
     agent_name: Annotated[str, typer.Option(..., help="Name of the agent to call")],
     url: Annotated[str, typer.Option(..., help="URL the agent should call")],
-    arguments: Annotated[str, typer.Option(..., help="JSON string with arguments for the call")] = {}
+    arguments: Annotated[
+        str, typer.Option(..., help="JSON string with arguments for the call")
+    ] = {},
 ):
     """
     Instruct an agent to 'call' a given URL with specific arguments.
@@ -84,46 +88,51 @@ async def make_call(
     try:
         project_id = await resolve_project_id(project_id=project_id)
         api_key_id = await resolve_api_key(project_id, api_key_id)
-        
-        key = (await account_client.decrypt_project_api_key(project_id=project_id, id=api_key_id))["token"]
+
+        key = (
+            await account_client.decrypt_project_api_key(
+                project_id=project_id, id=api_key_id
+            )
+        )["token"]
 
         token = ParticipantToken(
-            name=name,
-            project_id=project_id,
-            api_key_id=api_key_id
+            name=name, project_id=project_id, api_key_id=api_key_id
         )
         token.add_role_grant(role=role)
         token.add_room_grant(room)
         token.grants.append(ParticipantGrant(name="tunnel_ports", scope="9000"))
 
-        if local == None:
+        if local is None:
             local = is_local_url(url)
-        
+
         if local:
             async with aiohttp.ClientSession() as session:
-                 
-                event="room.call"
-                data={
-                    "room_url" : websocket_room_url(room_name=room),
-                    "room_name" : room,
-                    "token" : token.to_jwt(token=key),
-                    "arguments" : arguments,
+                event = "room.call"
+                data = {
+                    "room_url": websocket_room_url(room_name=room),
+                    "room_name": room,
+                    "token": token.to_jwt(token=key),
+                    "arguments": arguments,
                 }
-                 
-                await send_webhook(session=session, url=url, event=event, data=data, secret=None)
+
+                await send_webhook(
+                    session=session, url=url, event=event, data=data, secret=None
+                )
         else:
             print("[bold green]Connecting to room...[/bold green]")
             async with RoomClient(
-                protocol=WebSocketClientProtocol(url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
-                                                token=token.to_jwt(token=key))
+                protocol=WebSocketClientProtocol(
+                    url=websocket_room_url(
+                        room_name=room, base_url=meshagent_base_url()
+                    ),
+                    token=token.to_jwt(token=key),
+                )
             ) as client:
                 print("[bold green]Making agent call...[/bold green]")
                 await client.agents.make_call(
-                    name=agent_name,
-                    url=url,
-                    arguments=json.loads(arguments)
+                    name=agent_name, url=url, arguments=json.loads(arguments)
                 )
                 print("[bold cyan]Call request sent successfully.[/bold cyan]")
-        
+
     finally:
         await account_client.close()

meshagent/cli/chatbot.py

@@ -1,12 +1,17 @@
-
 import typer
 from rich import print
 from typing import Annotated, Optional
 from meshagent.tools import Toolkit
-from meshagent.api import RoomClient, ParticipantToken, WebSocketClientProtocol, RoomException
+from meshagent.api import RoomClient, WebSocketClientProtocol
 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
+from meshagent.cli.helper import (
+    get_client,
+    resolve_project_id,
+    resolve_api_key,
+    resolve_token_jwt,
+    resolve_room,
+)
 from meshagent.agents.chat import ChatBot
 from meshagent.openai import OpenAIResponsesAdapter
 from meshagent.openai.tools.responses_adapter import LocalShellTool
@@ -21,24 +26,24 @@ from meshagent.api import RequiredToolkit, RequiredSchema
 app = async_typer.AsyncTyper()
 
 
-def build_chatbot(*,
+def build_chatbot(
+    *,
     model: str,
-    agent_name: str, 
+    agent_name: str,
     rule: List[str],
     toolkit: List[str],
     schema: List[str],
     image_generation: Optional[str] = None,
     local_shell: bool,
-    computer_use: bool
+    computer_use: bool,
 ):
-
     requirements = []
-    
+
     toolkits = []
 
     for t in toolkit:
         requirements.append(RequiredToolkit(name=t))
-    
+
     for t in schema:
         requirements.append(RequiredSchema(name=t))
 
@@ -49,16 +54,13 @@ def build_chatbot(*,
         llm_adapter = OpenAIResponsesAdapter(
             model=model,
             response_options={
-                "reasoning" : {
-                    "generate_summary" : "concise"
-                },
-                "truncation" : "auto"
-            }
+                "reasoning": {"generate_summary": "concise"},
+                "truncation": "auto",
+            },
         )
     else:
-        llm_adapter = OpenAIResponsesAdapter(
-            model=model
-        )
+        llm_adapter = OpenAIResponsesAdapter(model=model)
+
     class CustomChatbot(BaseClass):
         def __init__(self):
             super().__init__(
@@ -66,31 +68,35 @@ def build_chatbot(*,
                 name=agent_name,
                 requires=requirements,
                 toolkits=toolkits,
-                rules=rule if len(rule) > 0 else None
+                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)
-            
+            toolkits = await super().get_thread_toolkits(
+                thread_context=thread_context, participant=participant
+            )
+
             thread_toolkit = Toolkit(name="thread_toolkit", tools=[])
 
             if local_shell:
-                thread_toolkit.tools.append(LocalShellTool()) 
+                thread_toolkit.tools.append(LocalShellTool())
 
-            if image_generation != None:
-               
+            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
-                ))
-               
+                thread_toolkit.tools.append(
+                    ChatBotThreadOpenAIImageGenerationTool(
+                        model=image_generation,
+                        thread_context=thread_context,
+                        partial_images=3,
+                    )
+                )
+
             toolkits.append(thread_toolkit)
             return toolkits
-    
+
     return CustomChatbot
 
+
 @app.async_command("join")
 async def make_call(
     *,
@@ -100,15 +106,31 @@ async def make_call(
     name: Annotated[str, typer.Option(..., help="Participant name")] = "cli",
     role: str = "agent",
     agent_name: Annotated[str, typer.Option(..., help="Name of the agent to call")],
-    token_path: Annotated[Optional[str], typer.Option()] = None, 
-    
+    token_path: Annotated[Optional[str], typer.Option()] = None,
     rule: Annotated[List[str], typer.Option("--rule", "-r", help="a system rule")] = [],
-    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-4o",
-    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,
+    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-4o",
+    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,
 ):
     account_client = await get_client()
     try:
@@ -116,75 +138,107 @@ async def make_call(
         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, name=name, role=role, room=room)
-        
+        jwt = await resolve_token_jwt(
+            project_id=project_id,
+            api_key_id=api_key_id,
+            token_path=token_path,
+            name=name,
+            role=role,
+            room=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
+                token=jwt,
             )
         ) as client:
-            
             requirements = []
-            
-            toolkits = []
 
             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)
-                
-            bot = CustomChatbot(
-                llm_adapter=OpenAIResponsesAdapter(),
-                name=agent_name,
-                requires=requirements,
-                toolkits=toolkits,
-                rules=rule if len(rule) > 0 else None
+            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,
             )
 
+            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(
     *,
     room: Annotated[Optional[str], typer.Option()] = 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")] = [],
-    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-4o",
-    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,
-
-    host: Annotated[Optional[str], typer.Option()] = None, 
-    port: Annotated[Optional[int], typer.Option()] = 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-4o",
+    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,
+    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
+    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,
+            image_generation=image_generation,
+        ),
     )
-    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, image_generation=image_generation))
 
     await service.run()

meshagent/cli/cli.py

@@ -22,8 +22,16 @@ from meshagent.cli import tty
 
 from meshagent.cli import otel
 
+from art import tprint
+
 import logging
 
+import os
+import sys
+from pathlib import Path
+from meshagent.cli.helper import get_client, resolve_project_id, resolve_api_key
+
+
 otel.init(level=logging.INFO)
 
 # Turn down OpenAI logs, they are a bit noisy
@@ -49,16 +57,11 @@ app.add_typer(chatbot.app, name="chatbot")
 app.add_typer(voicebot.app, name="voicebot")
 app.add_typer(tty.app, name="tty")
 
+
 def _run_async(coro):
     asyncio.run(coro)
 
 
-import os, sys
-from pathlib import Path
-import typer
-from meshagent.cli.helper import get_client, set_active_project, get_active_project, resolve_project_id, resolve_api_key
-
-
 def detect_shell() -> str:
     """
     Best-effort detection of the *current* interactive shell.
@@ -99,19 +102,19 @@ def detect_shell() -> str:
 
 
 def _bash_like(name: str, value: str, unset: bool) -> str:
-    return f'unset {name}' if unset else f'export {name}="{value}"'
+    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}"'
+    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}"'
+    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}'
+    return f"set {name}=" if unset else f"set {name}={value}"
 
 
 SHELL_RENDERERS = {
@@ -128,7 +131,8 @@ SHELL_RENDERERS = {
     help="Generate commands to set meshagent environment variables.",
 )
 def env(
-    shell: Optional[str] = typer.Option(None,
+    shell: Optional[str] = typer.Option(
+        None,
         "--shell",
         case_sensitive=False,
         help="bash | zsh | fish | powershell | cmd",
@@ -138,7 +142,7 @@ def env(
     ),
 ):
     """Print shell-specific exports/unsets for Docker environment variables."""
-    
+
     async def command():
         nonlocal shell, unset
         shell = (shell or detect_shell()).lower()
@@ -151,14 +155,18 @@ def env(
             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"]
+            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_API_KEY" : api_key_id,
-            "MESHAGENT_SECRET" : token
+            "MESHAGENT_PROJECT_ID": project_id,
+            "MESHAGENT_API_KEY": api_key_id,
+            "MESHAGENT_SECRET": token,
         }
         if shell not in SHELL_RENDERERS:
             typer.echo(f"Unsupported shell '{shell}'.", err=True)
@@ -171,17 +179,21 @@ def env(
 
         if not unset and shell in ("bash", "zsh"):
             typer.echo(
-                '\n# Run this command to configure your current shell:\n'
-                f'# eval "$(meshagent env)"'
+                "\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."""
 
     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)
@@ -195,5 +207,6 @@ def setup_command():
 
     _run_async(runner())
 
+
 if __name__ == "__main__":
     app()