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

meshagent/cli/agent.py

@@ -10,21 +10,23 @@ from meshagent.api import (
     RoomClient,
     WebSocketClientProtocol,
     RoomException,
+    TextResponse,
+    JsonResponse,
 )
 from meshagent.cli.helper import resolve_project_id
 from meshagent.cli import async_typer
 from meshagent.cli.helper import get_client, resolve_room
 
-app = async_typer.AsyncTyper()
+app = async_typer.AsyncTyper(help="Interact with agents and toolkits in a room")
 
 
-@app.async_command("ask")
+@app.async_command("ask", help="Send a request to an agent")
 async def ask(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
-    agent: Annotated[str, typer.Option()],
-    input: Annotated[str, typer.Option()],
+    agent: Annotated[str, typer.Option(..., help="Agent name to ask")],
+    input: Annotated[str, typer.Option(..., help="JSON string with tool arguments")],
     timeout: Annotated[
         Optional[int],
         typer.Option(
@@ -32,6 +34,8 @@ async def ask(
         ),
     ] = 30,
 ):
+    """Wait for an agent to join, then send it an ask request."""
+
     account_client = await get_client()
     try:
         project_id = await resolve_project_id(project_id=project_id)
@@ -69,17 +73,22 @@ async def ask(
             print("[magenta]Asking agent...[/magenta]")
 
             response = await client.agents.ask(agent=agent, arguments=json.loads(input))
-            print(json.dumps(response.json))
+            if isinstance(response, TextResponse):
+                print(response.text)
+            elif isinstance(response, JsonResponse):
+                print(json.dumps(response.json))
+            else:
+                print(response)
     except RoomException as e:
         print(f"[red]{e}[/red]")
     finally:
         await account_client.close()
 
 
-@app.async_command("invoke-tool")
+@app.async_command("invoke-tool", help="Invoke a specific tool from a toolkit")
 async def invoke_tool(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     toolkit: Annotated[str, typer.Option(..., help="Toolkit name")],
     tool: Annotated[str, typer.Option(..., help="Tool name")],
@@ -161,10 +170,10 @@ async def invoke_tool(
         await account_client.close()
 
 
-@app.async_command("list-agents")
+@app.async_command("list-agents", help="List agents currently in the room")
 async def list_agents_command(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
 ):
     """
@@ -194,7 +203,6 @@ async def list_agents_command(
                         "name": agent.name,
                         "title": agent.title,
                         "description": agent.description,
-                        "requires": [r.to_json() for r in agent.requires],
                         "supports_tools": agent.supports_tools,
                         "labels": agent.labels,
                     }
@@ -205,10 +213,12 @@ async def list_agents_command(
         await account_client.close()
 
 
-@app.async_command("list-toolkits")
+@app.async_command(
+    "list-toolkits", help="List toolkits (and tools) available in the room"
+)
 async def list_toolkits_command(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     role: str = "user",
     participant_id: Annotated[

meshagent/cli/api_keys.py

@@ -19,7 +19,7 @@ app = async_typer.AsyncTyper(help="Manage or activate api-keys for your project"
 @app.async_command("list")
 async def list(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     o: OutputFormatOption = "table",
 ):
     project_id = await resolve_project_id(project_id=project_id)
@@ -42,7 +42,7 @@ async def list(
 @app.async_command("create")
 async def create(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     name: str,
     description: Annotated[
         str, typer.Option(..., help="a description for the api key")
@@ -85,7 +85,7 @@ async def create(
 @app.async_command("activate")
 async def activate(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     key: str,
 ):
     project_id = await resolve_project_id(project_id=project_id)
@@ -94,7 +94,7 @@ async def activate(
 
 
 @app.async_command("delete")
-async def delete(*, project_id: ProjectIdOption = None, id: str):
+async def delete(*, project_id: ProjectIdOption, id: str):
     project_id = await resolve_project_id(project_id=project_id)
 
     client = await get_client()

meshagent/cli/async_typer.py

@@ -2,20 +2,64 @@ from __future__ import annotations
 
 import asyncio
 import inspect
+import threading
 from functools import partial, wraps
-from typing import Any, Callable
+from typing import Any, Callable, TypeVar
 
 from typer import Typer
 
+T = TypeVar("T")
+
+
+def _run_coroutine_sync(
+    coro: "asyncio.Future[T] | asyncio.coroutines.Coroutine[Any, Any, T]",
+) -> T:
+    """
+    Run an awaitable from sync code.
+
+    - If we're not currently in an event loop, use asyncio.run().
+    - If we ARE in a running loop (e.g. inside an agent / notebook / ASGI app),
+      run asyncio.run() in a separate thread and block for the result.
+
+    This avoids: RuntimeError: asyncio.run() cannot be called from a running event loop
+    """
+    try:
+        asyncio.get_running_loop()
+        in_running_loop = True
+    except RuntimeError:
+        in_running_loop = False
+
+    if not in_running_loop:
+        return asyncio.run(coro)  # type: ignore[arg-type]
+
+    result: dict[str, Any] = {}
+    done = threading.Event()
+
+    def _worker() -> None:
+        try:
+            result["value"] = asyncio.run(coro)  # type: ignore[arg-type]
+        except BaseException as e:
+            result["error"] = e
+        finally:
+            done.set()
+
+    t = threading.Thread(target=_worker, daemon=True)
+    t.start()
+    done.wait()
+
+    if "error" in result:
+        raise result["error"]
+    return result["value"]  # type: ignore[return-value]
+
 
 class AsyncTyper(Typer):
     @staticmethod
-    def maybe_run_async(decorator: Callable, func: Callable) -> Any:
+    def maybe_run_async(decorator: Callable[..., Any], func: Callable[..., Any]) -> Any:
         if inspect.iscoroutinefunction(func):
 
             @wraps(func)
             def runner(*args: Any, **kwargs: Any) -> Any:
-                return asyncio.run(func(*args, **kwargs))
+                return _run_coroutine_sync(func(*args, **kwargs))
 
             decorator(runner)
         else:
@@ -26,6 +70,10 @@ class AsyncTyper(Typer):
         decorator = super().callback(*args, **kwargs)
         return partial(self.maybe_run_async, decorator)
 
-    def async_command(self, *args: Any, **kwargs: Any) -> Any:
+    def command(self, *args: Any, **kwargs: Any) -> Any:
         decorator = super().command(*args, **kwargs)
         return partial(self.maybe_run_async, decorator)
+
+    # keep your existing name if you prefer
+    def async_command(self, *args: Any, **kwargs: Any) -> Any:
+        return self.command(*args, **kwargs)

meshagent/cli/call.py

@@ -1,4 +1,5 @@
 import typer
+import os
 from rich import print
 from typing import Annotated, Optional
 from meshagent.cli.common_options import ProjectIdOption, RoomOption
@@ -24,7 +25,7 @@ import pathlib
 from pydantic_yaml import parse_yaml_raw_as
 from meshagent.api.participant_token import ParticipantTokenSpec
 
-app = async_typer.AsyncTyper()
+app = async_typer.AsyncTyper(help="Trigger agent/tool calls via URL")
 
 PRIVATE_NETS = (
     ipaddress.ip_network("10.0.0.0/8"),
@@ -68,20 +69,16 @@ def is_local_url(url: str) -> bool:
             return True
 
 
-@app.async_command("schema")
-@app.async_command("toolkit")
-@app.async_command("agent")
-@app.async_command("tool")
+@app.async_command("schema", help="Send a call request to a schema webhook URL")
+@app.async_command("toolkit", help="Send a call request to a toolkit webhook URL")
+@app.async_command("agent", help="Send a call request to an agent webhook URL")
+@app.async_command("tool", help="Send a call request to a tool webhook URL")
 async def make_call(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     role: str = "agent",
     local: Optional[bool] = None,
-    agent_name: Annotated[
-        Optional[str], typer.Option(..., help="deprecated and unused", hidden=True)
-    ] = None,
-    name: Annotated[str, typer.Option(..., help="deprecated", hidden=True)] = None,
     participant_name: Annotated[
         Optional[str],
         typer.Option(..., help="the participant name to be used by the callee"),
@@ -103,6 +100,8 @@ async def make_call(
         typer.Option("--key", help="an api key to sign the token with"),
     ] = None,
 ):
+    """Send a `room.call` request to a URL or in-room agent."""
+
     key = await resolve_key(project_id=project_id, key=key)
 
     if permissions is not None:
@@ -124,8 +123,6 @@ async def make_call(
         room=room,
         role=role,
         local=local,
-        agent_name=agent_name,
-        name=name,
         participant_name=participant_name,
         url=url,
         arguments=arguments,
@@ -136,14 +133,10 @@ async def make_call(
 
 async def _make_call(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     role: str = "agent",
     local: Optional[bool] = None,
-    agent_name: Annotated[
-        Optional[str], typer.Option(..., help="deprecated and unused", hidden=True)
-    ] = None,
-    name: Annotated[str, typer.Option(..., help="deprecated", hidden=True)] = None,
     participant_name: Annotated[
         Optional[str],
         typer.Option(..., help="the participant name to be used by the callee"),
@@ -160,15 +153,6 @@ async def _make_call(
     Instruct an agent to 'call' a given URL with specific arguments.
 
     """
-    if name is not None:
-        print("[yellow]name is deprecated and should no longer be passed[/yellow]")
-
-    if agent_name is not None:
-        print(
-            "[yellow]agent-name is deprecated and should no longer be passed, use participant-name instead[/yellow]"
-        )
-        participant_name = agent_name
-
     if participant_name is None:
         print("[red]--participant-name is required[/red]")
         raise typer.Exit(1)
@@ -180,13 +164,18 @@ async def _make_call(
         room = resolve_room(room)
 
         if token is None:
-            token = ParticipantToken(
-                name=participant_name,
-            )
-            token.add_api_grant(permissions or ApiScope.agent_default())
-            token.add_role_grant(role=role)
-            token.add_room_grant(room)
-            token.grants.append(ParticipantGrant(name="tunnel_ports", scope="9000"))
+            jwt = os.getenv("MESHAGENT_TOKEN")
+            if jwt is None:
+                token = ParticipantToken(
+                    name=participant_name,
+                )
+                token.add_api_grant(permissions or ApiScope.agent_default())
+                token.add_role_grant(role=role)
+                token.add_room_grant(room)
+                token.grants.append(ParticipantGrant(name="tunnel_ports", scope="9000"))
+                jwt = token.to_jwt(api_key=key)
+        else:
+            jwt = token.to_jwt(api_key=key)
 
         if local is None:
             local = is_local_url(url)
@@ -197,8 +186,10 @@ async def _make_call(
                 data = {
                     "room_url": websocket_room_url(room_name=room),
                     "room_name": room,
-                    "token": token.to_jwt(api_key=key),
-                    "arguments": arguments,
+                    "token": jwt,
+                    "arguments": json.loads(arguments)
+                    if isinstance(arguments, str)
+                    else arguments,
                 }
 
                 await send_webhook(
@@ -211,7 +202,7 @@ async def _make_call(
                     url=websocket_room_url(
                         room_name=room, base_url=meshagent_base_url()
                     ),
-                    token=token.to_jwt(api_key=key),
+                    token=jwt,
                 )
             ) as client:
                 print("[bold green]Making agent call...[/bold green]")