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

meshagent/cli/mailbot.py

@@ -1,36 +1,33 @@
-from meshagent.agents.mail import MailWorker
-
 import typer
 from meshagent.api import ParticipantToken
 from rich import print
 from typing import Annotated, Optional
 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, 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.openai import OpenAIResponsesAdapter
 from meshagent.openai.tools.responses_adapter import ImageGenerationTool, LocalShellTool
 from meshagent.api.services import ServiceHost
 
-from meshagent.agents.mail import room_address
+
 from typing import List
 from pathlib import Path
 
 from meshagent.api import RequiredToolkit, RequiredSchema
 from meshagent.openai.tools.responses_adapter import WebSearchTool
 
+
 app = async_typer.AsyncTyper(help="Join a mailbot to a room")
 
 
@@ -48,7 +45,10 @@ def build_mailbot(
     web_search: Annotated[
         Optional[bool], typer.Option(..., help="Enable web search tool calling")
     ] = False,
+    queue: str,
 ):
+    from meshagent.agents.mail import MailWorker
+
     requirements = []
 
     toolkits = []
@@ -79,15 +79,13 @@ def build_mailbot(
                 name=agent_name,
                 requires=requirements,
                 toolkits=toolkits,
+                queue=queue,
                 rules=rule if len(rule) > 0 else None,
             )
 
         async def start(self, *, room: RoomClient):
-            parsed_token = ParticipantToken.from_jwt(
-                room.protocol.token, validate=False
-            )
             print(
-                f"[bold green]Send an email interact with your mailbot: {room_address(project_id=parsed_token.project_id, room_name=room.room_name)}[/bold green]"
+                "[bold green]Configure and send an email interact with your mailbot[/bold green]"
             )
             return await super().start(room=room)
 
@@ -124,11 +122,9 @@ def build_mailbot(
 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,29 +137,38 @@ async def make_call(
     ] = [],
     model: Annotated[
         str, typer.Option(..., help="Name of the LLM model to use for the chatbot")
-    ] = "gpt-4o",
+    ] = "gpt-5",
     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,
+    key: Annotated[
+        str,
+        typer.Option("--key", help="an api key to sign the token with"),
+    ] = None,
+    queue: Annotated[str, typer.Option(..., help="the name of the mail queue")],
 ):
+    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(
@@ -190,6 +195,7 @@ async def make_call(
                 image_generation=None,
                 web_search=web_search,
                 rules_file=rules_file,
+                queue=queue,
             )
 
             bot = CustomMailbot()
@@ -210,7 +216,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,
@@ -224,22 +229,22 @@ async def service(
     ] = [],
     model: Annotated[
         str, typer.Option(..., help="Name of the LLM model to use for the chatbot")
-    ] = "gpt-4o",
+    ] = "gpt-5",
     local_shell: Annotated[
         Optional[bool], typer.Option(..., help="Enable local shell tool calling")
     ] = False,
     host: Annotated[Optional[str], typer.Option()] = None,
     port: Annotated[Optional[int], typer.Option()] = None,
     path: Annotated[str, typer.Option()] = "/agent",
+    queue: Annotated[str, typer.Option(..., help="the name of the mail queue")],
 ):
-    room = resolve_room(room)
-
     print("[bold green]Connecting to room...[/bold green]", flush=True)
 
     service = ServiceHost(host=host, port=port)
     service.add_path(
         path=path,
         cls=build_mailbot(
+            queue=queue,
             computer_use=None,
             model=model,
             local_shell=local_shell,

meshagent/cli/meeting_transcriber.py

@@ -0,0 +1,124 @@
+import typer
+from rich import print
+from typing import Annotated, Optional
+from meshagent.cli.common_options import ProjectIdOption, RoomOption
+from meshagent.api import RoomClient, WebSocketClientProtocol, RoomException
+from meshagent.api.helpers import meshagent_base_url, websocket_room_url
+from meshagent.cli import async_typer
+from meshagent.api import ParticipantToken, ApiScope
+from meshagent.cli.helper import (
+    get_client,
+    resolve_project_id,
+    resolve_room,
+    resolve_key,
+)
+
+from meshagent.api import RequiredSchema
+from meshagent.api.services import ServiceHost
+
+app = async_typer.AsyncTyper(help="Join a meeting transcriber to a room")
+
+
+@app.async_command("join")
+async def join(
+    *,
+    project_id: ProjectIdOption = None,
+    room: RoomOption,
+    agent_name: Annotated[str, typer.Option(..., help="Name of the agent")],
+    key: Annotated[
+        str,
+        typer.Option("--key", help="an api key to sign the token with"),
+    ] = None,
+):
+    try:
+        from meshagent.livekit.agents.meeting_transcriber import MeetingTranscriber
+    except ImportError:
+
+        class MeetingTranscriber:
+            def __init__(self, **kwargs):
+                raise RoomException(
+                    "meshagent.livekit module not found, transcribers are not available"
+                )
+
+    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="agent")
+        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 = []
+
+            requirements.append(RequiredSchema(name="transcript"))
+
+            bot = MeetingTranscriber(
+                name=agent_name,
+                requires=requirements,
+            )
+
+            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")],
+    host: Annotated[Optional[str], typer.Option()] = None,
+    port: Annotated[Optional[int], typer.Option()] = None,
+    path: Annotated[str, typer.Option()] = "/agent",
+):
+    try:
+        from meshagent.livekit.agents.meeting_transcriber import MeetingTranscriber
+    except ImportError:
+
+        class MeetingTranscriber:
+            def __init__(self, **kwargs):
+                raise RoomException(
+                    "meshagent.livekit module not found, voicebots are not available"
+                )
+
+    requirements = []
+
+    requirements.append(RequiredSchema(name="transcript"))
+
+    service = ServiceHost(host=host, port=port)
+
+    @service.path(path=path)
+    class CustomMeetingTranscriber(MeetingTranscriber):
+        def __init__(self):
+            super().__init__(
+                name=agent_name,
+                requires=requirements,
+            )
+
+    await service.run()

meshagent/cli/messaging.py

@@ -1,9 +1,8 @@
 import typer
 from rich import print
-from typing import Annotated, Optional
+from typing import Annotated
 from meshagent.cli.common_options import (
     ProjectIdOption,
-    ApiKeyIdOption,
     RoomOption,
 )
 import json
@@ -14,8 +13,6 @@ from meshagent.cli import async_typer
 from meshagent.cli.helper import (
     get_client,
     resolve_project_id,
-    resolve_api_key,
-    resolve_token_jwt,
     resolve_room,
 )
 
@@ -26,11 +23,7 @@ app = async_typer.AsyncTyper()
 async def messaging_list_participants_command(
     *,
     project_id: ProjectIdOption = None,
-    room: RoomOption = None,
-    token_path: Annotated[Optional[str], typer.Option()] = None,
-    api_key_id: ApiKeyIdOption = None,
-    name: Annotated[str, typer.Option()] = "cli",
-    role: str = "user",
+    room: RoomOption,
 ):
     """
     List all messaging-enabled participants in the room.
@@ -39,24 +32,16 @@ async def messaging_list_participants_command(
     try:
         # Resolve project_id if not provided
         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,
-            name=name,
-            role=role,
-            room=room,
-        )
+        connection = await account_client.connect_room(project_id=project_id, room=room)
 
         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=jwt,
+                token=connection.jwt,
             )
         ) as client:
             # Must enable before we can see who else is enabled
@@ -80,14 +65,11 @@ async def messaging_list_participants_command(
 async def messaging_send_command(
     *,
     project_id: ProjectIdOption = None,
-    room: RoomOption = None,
-    token_path: Annotated[Optional[str], typer.Option()] = None,
-    api_key_id: ApiKeyIdOption = None,
-    name: Annotated[str, typer.Option()] = "cli",
-    role: str = "user",
+    room: RoomOption,
     to_participant_id: Annotated[
         str, typer.Option(..., help="Participant ID to send a message to")
     ],
+    type: Annotated[str, typer.Option(..., help="type of the message to send")],
     data: Annotated[str, typer.Option(..., help="JSON message to send")],
 ):
     """
@@ -97,24 +79,15 @@ async def messaging_send_command(
     try:
         # Resolve project_id if not provided
         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,
-            name=name,
-            role=role,
-            room=room,
-        )
+        connection = await account_client.connect_room(project_id=project_id, room=room)
 
         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=jwt,
+                token=connection.jwt,
             )
         ) as client:
             # Create and enable messaging
@@ -136,7 +109,7 @@ async def messaging_send_command(
                 # Send the message
                 await client.messaging.send_message(
                     to=participant,
-                    type="chat.message",
+                    type=type,
                     message=json.loads(data),
                     attachment=None,
                 )
@@ -151,11 +124,7 @@ async def messaging_send_command(
 async def messaging_broadcast_command(
     *,
     project_id: ProjectIdOption = None,
-    room: RoomOption = None,
-    token_path: Annotated[Optional[str], typer.Option()] = None,
-    api_key_id: ApiKeyIdOption = None,
-    name: Annotated[str, typer.Option()] = "cli",
-    role: str = "user",
+    room: RoomOption,
     data: Annotated[str, typer.Option(..., help="JSON message to broadcast")],
 ):
     """
@@ -165,23 +134,15 @@ async def messaging_broadcast_command(
     try:
         # Resolve project_id if not provided
         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,
-            name=name,
-            role=role,
-            room=room,
-        )
+        connection = await account_client.connect_room(project_id=project_id, room=room)
 
         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=jwt,
+                token=connection.jwt,
             )
         ) as client:
             # Create and enable messaging

meshagent/cli/oauth2.py

@@ -0,0 +1,189 @@
+from meshagent.cli import async_typer
+from meshagent.cli.common_options import ProjectIdOption, RoomOption
+from meshagent.cli.helper import (
+    get_client,
+    resolve_project_id,
+)
+from meshagent.api.oauth import OAuthClientConfig
+from meshagent.api import RoomClient, WebSocketClientProtocol
+from meshagent.api.helpers import meshagent_base_url, websocket_room_url
+from rich import print
+from typing import Annotated, Optional
+import typer
+import json
+
+app = async_typer.AsyncTyper(help="OAuth2 test commands")
+
+
+@app.async_command("request")
+async def oauth2(
+    *,
+    project_id: ProjectIdOption = None,
+    room: RoomOption,
+    from_participant_id: Annotated[str, typer.Option()],
+    client_id: Annotated[str, typer.Option()],
+    authorization_endpoint: Annotated[str, typer.Option()],
+    token_endpoint: Annotated[str, typer.Option()],
+    scopes: Annotated[Optional[str], typer.Option()] = None,
+    client_secret: Annotated[Optional[str], typer.Option()],
+    redirect_uri: Annotated[Optional[str], typer.Option()],
+    pkce: Annotated[bool, typer.Option()] = True,
+):
+    """
+    Run an OAuth2 request test between two participants in the same room.
+    One will act as the consumer, the other as the provider.
+    """
+
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+
+        jwt_consumer = 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=jwt_consumer.jwt,
+            )
+        ) as consumer:
+            print("[green]Requesting OAuth token from consumer side...[/green]")
+            token = await consumer.secrets.request_oauth_token(
+                oauth=OAuthClientConfig(
+                    client_id=client_id,
+                    authorization_endpoint=authorization_endpoint,
+                    token_endpoint=token_endpoint,
+                    scopes=scopes.split(",") if scopes is not None else scopes,
+                    client_secret=client_secret,
+                    no_pkce=not pkce,
+                ),
+                from_participant_id=from_participant_id,
+                timeout=300,
+                redirect_uri=redirect_uri,
+            )
+
+            print(f"[bold cyan]Got access token:[/bold cyan] {token}")
+
+    finally:
+        await account_client.close()
+
+
+@app.async_command("get")
+async def get(
+    *,
+    project_id: ProjectIdOption = None,
+    room: RoomOption,
+    delegated_to: Annotated[str, typer.Option()],
+    client_id: Annotated[str, typer.Option()],
+    authorization_endpoint: Annotated[str, typer.Option()],
+    token_endpoint: Annotated[str, typer.Option()],
+    scopes: Annotated[Optional[str], typer.Option()] = None,
+    client_secret: Annotated[Optional[str], typer.Option()],
+    redirect_uri: Annotated[Optional[str], typer.Option()],
+    pkce: Annotated[bool, typer.Option()] = True,
+):
+    """
+    Run an OAuth2 request test between two participants in the same room.
+    One will act as the consumer, the other as the provider.
+    """
+
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+
+        jwt_consumer = 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=jwt_consumer.jwt,
+            )
+        ) as consumer:
+            print("[green]Requesting OAuth token from consumer side...[/green]")
+            token = await consumer.secrets.get_offline_oauth_token(
+                oauth=OAuthClientConfig(
+                    client_id=client_id,
+                    authorization_endpoint=authorization_endpoint,
+                    token_endpoint=token_endpoint,
+                    scopes=scopes.split(",") if scopes is not None else scopes,
+                    client_secret=client_secret,
+                    no_pkce=not pkce,
+                ),
+                delegated_to=delegated_to,
+            )
+
+            print(f"[bold cyan]Got access token:[/bold cyan] {token}")
+
+    finally:
+        await account_client.close()
+
+
+@app.async_command("list")
+async def list(
+    *,
+    project_id: ProjectIdOption = None,
+    room: RoomOption,
+):
+    """
+    list secrets
+    """
+
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+
+        jwt_consumer = 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=jwt_consumer.jwt,
+            )
+        ) as consumer:
+            secrets = await consumer.secrets.list_user_secrets()
+            output = []
+            for s in secrets:
+                output.append(s.model_dump(mode="json"))
+
+            print(json.dumps(output, indent=2))
+
+    finally:
+        await account_client.close()
+
+
+@app.async_command("delete")
+async def delete(
+    *,
+    project_id: ProjectIdOption = None,
+    room: RoomOption,
+    id: str,
+    delegated_to: Annotated[Optional[str], typer.Option()] = None,
+):
+    """
+    delete a secret
+    """
+
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+
+        jwt_consumer = 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=jwt_consumer.jwt,
+            )
+        ) as consumer:
+            await consumer.secrets.delete_user_secret(id=id, delegated_to=delegated_to)
+            print("deleted secret")
+
+    finally:
+        await account_client.close()