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

meshagent/cli/agent.py

@@ -15,16 +15,16 @@ 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 +32,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)
@@ -76,10 +78,10 @@ async def ask(
         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 +163,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,
 ):
     """
@@ -205,10 +207,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

@@ -24,7 +24,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,13 +68,13 @@ 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,
@@ -103,6 +103,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:
@@ -136,7 +138,7 @@ async def make_call(
 
 async def _make_call(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     role: str = "agent",
     local: Optional[bool] = None,
@@ -198,7 +200,9 @@ async def _make_call(
                     "room_url": websocket_room_url(room_name=room),
                     "room_name": room,
                     "token": token.to_jwt(api_key=key),
-                    "arguments": arguments,
+                    "arguments": json.loads(arguments)
+                    if isinstance(arguments, str)
+                    else arguments,
                 }
 
                 await send_webhook(