meshagent-cli 0.22.2__py3-none-any.whl

meshagent/cli/__init__.py

@@ -0,0 +1,3 @@
+from .version import __version__
+
+__all__ = [__version__]

meshagent/cli/agent.py

@@ -0,0 +1,273 @@
+import typer
+from rich import print
+from typing import Annotated, Optional
+from meshagent.cli.common_options import ProjectIdOption, RoomOption
+import json
+import asyncio
+
+from meshagent.api.helpers import meshagent_base_url, websocket_room_url
+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(help="Interact with agents and toolkits in a room")
+
+
+@app.async_command("ask", help="Send a request to an agent")
+async def ask(
+    *,
+    project_id: ProjectIdOption,
+    room: RoomOption,
+    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(
+            ..., help="How long to wait for the agent if the agent is not in the room"
+        ),
+    ] = 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)
+        room = resolve_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=connection.jwt,
+            )
+        ) as client:
+            found = timeout == 0
+            for i in range(30):
+                if found:
+                    break
+
+                if i == 1:
+                    print("[magenta]Waiting for agent...[/magenta]")
+
+                agents = await client.agents.list_agents()
+                await asyncio.sleep(1)
+
+                for a in agents:
+                    if a.name == agent:
+                        found = True
+                        break
+
+            if not found:
+                print("[red]Timed out waiting for agent to join the room[/red]")
+                raise typer.Exit(1)
+
+            print("[magenta]Asking agent...[/magenta]")
+
+            response = await client.agents.ask(agent=agent, arguments=json.loads(input))
+            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", help="Invoke a specific tool from a toolkit")
+async def invoke_tool(
+    *,
+    project_id: ProjectIdOption,
+    room: RoomOption,
+    toolkit: Annotated[str, typer.Option(..., help="Toolkit name")],
+    tool: Annotated[str, typer.Option(..., help="Tool name")],
+    arguments: Annotated[
+        str, typer.Option(..., help="JSON string with arguments for the tool")
+    ],
+    participant_id: Annotated[
+        Optional[str],
+        typer.Option(..., help="Optional participant ID to invoke the tool on"),
+    ] = None,
+    on_behalf_of_id: Annotated[
+        Optional[str], typer.Option(..., help="Optional 'on_behalf_of' participant ID")
+    ] = None,
+    caller_context: Annotated[
+        Optional[str], typer.Option(..., help="Optional JSON for caller context")
+    ] = None,
+    timeout: Annotated[
+        Optional[int],
+        typer.Option(
+            ...,
+            help="How long to wait for the toolkit if the toolkit is not in the room",
+        ),
+    ] = 30,
+):
+    """
+    Invoke a specific tool from a given toolkit with arguments.
+    """
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        room = resolve_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=connection.jwt,
+            )
+        ) as client:
+            found = timeout == 0
+            for i in range(timeout):
+                if found:
+                    break
+
+                if i == 1:
+                    print("[magenta]Waiting for toolkit...[/magenta]")
+
+                agents = await client.agents.list_toolkits(
+                    participant_id=participant_id
+                )
+                await asyncio.sleep(1)
+
+                for a in agents:
+                    if a.name == toolkit:
+                        found = True
+                        break
+
+            if not found:
+                print("[red]Timed out waiting for toolkit to join the room[/red]")
+                raise typer.Exit(1)
+
+            print("[bold green]Invoking tool...[/bold green]")
+            parsed_context = json.loads(caller_context) if caller_context else None
+            response = await client.agents.invoke_tool(
+                toolkit=toolkit,
+                tool=tool,
+                arguments=json.loads(arguments),
+                participant_id=participant_id,
+                on_behalf_of_id=on_behalf_of_id,
+                caller_context=parsed_context,
+            )
+            # The response is presumably a dictionary or similar
+            print(response.to_json())
+    except RoomException as e:
+        print(f"[red]{e}[/red]")
+    finally:
+        await account_client.close()
+
+
+@app.async_command("list-agents", help="List agents currently in the room")
+async def list_agents_command(
+    *,
+    project_id: ProjectIdOption,
+    room: RoomOption,
+):
+    """
+    List all agents available in the room.
+    """
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        room = resolve_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=connection.jwt,
+            )
+        ) as client:
+            print("[bold green]Fetching list of agents...[/bold green]")
+            agents = await client.agents.list_agents()
+            # Format the output as JSON
+            output = []
+            for agent in agents:
+                output.append(
+                    {
+                        "name": agent.name,
+                        "title": agent.title,
+                        "description": agent.description,
+                        "supports_tools": agent.supports_tools,
+                        "labels": agent.labels,
+                    }
+                )
+            print(json.dumps(output, indent=2))
+
+    finally:
+        await account_client.close()
+
+
+@app.async_command(
+    "list-toolkits", help="List toolkits (and tools) available in the room"
+)
+async def list_toolkits_command(
+    *,
+    project_id: ProjectIdOption,
+    room: RoomOption,
+    role: str = "user",
+    participant_id: Annotated[
+        Optional[str], typer.Option(..., help="Optional participant ID")
+    ] = None,
+):
+    """
+    List all toolkits (and tools within them) available in the room.
+    """
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        room = resolve_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=connection.jwt,
+            )
+        ) as client:
+            print("[bold green]Fetching list of toolkits...[/bold green]")
+            toolkits = await client.agents.list_toolkits(participant_id=participant_id)
+
+            # Format and output as JSON
+            output = []
+            for tk in toolkits:
+                output.append(
+                    {
+                        "name": tk.name,
+                        "title": tk.title,
+                        "description": tk.description,
+                        "thumbnail_url": tk.thumbnail_url,
+                        "tools": [
+                            {
+                                "name": tool.name,
+                                "title": tool.title,
+                                "description": tool.description,
+                                "input_schema": tool.input_schema,
+                                "thumbnail_url": tool.thumbnail_url,
+                                "defs": tool.defs,
+                                "supports_context": tool.supports_context,
+                            }
+                            for tool in tk.tools
+                        ],
+                    }
+                )
+            print(json.dumps(output, indent=2))
+
+    finally:
+        await account_client.close()

meshagent/cli/api_keys.py

@@ -0,0 +1,102 @@
+import json
+from rich import print
+
+from meshagent.cli.common_options import ProjectIdOption
+from meshagent.cli import async_typer
+from meshagent.cli.helper import (
+    get_client,
+    print_json_table,
+    resolve_project_id,
+    set_active_api_key,
+)
+from meshagent.cli.common_options import OutputFormatOption
+from typing import Annotated
+import typer
+
+app = async_typer.AsyncTyper(help="Manage or activate api-keys for your project")
+
+
+@app.async_command("list")
+async def list(
+    *,
+    project_id: ProjectIdOption,
+    o: OutputFormatOption = "table",
+):
+    project_id = await resolve_project_id(project_id=project_id)
+    client = await get_client()
+    keys = (await client.list_api_keys(project_id=project_id))["keys"]
+
+    if len(keys) > 0:
+        if o == "json":
+            sanitized_keys = [
+                {k: v for k, v in key.items() if k != "created_by"} for key in keys
+            ]
+            print(json.dumps({"api-keys": sanitized_keys}, indent=2))
+        else:
+            print_json_table(keys, "id", "name", "description")
+    else:
+        print("There are not currently any API keys in the project")
+    await client.close()
+
+
+@app.async_command("create")
+async def create(
+    *,
+    project_id: ProjectIdOption,
+    name: str,
+    description: Annotated[
+        str, typer.Option(..., help="a description for the api key")
+    ] = "",
+    activate: Annotated[
+        bool,
+        typer.Option(
+            ..., help="use this key by default for commands that accept an API key"
+        ),
+    ] = False,
+    silent: Annotated[bool, typer.Option(..., help="do not print api key")] = False,
+):
+    project_id = await resolve_project_id(project_id=project_id)
+
+    client = await get_client()
+    api_key = await client.create_api_key(
+        project_id=project_id, name=name, description=description
+    )
+    if not silent:
+        if not activate:
+            print(
+                "[green]This is your token. Save it for later, you will not be able to get the value again:[/green]\n"
+            )
+            print(api_key["value"])
+            print(
+                "[green]\nNote: you can use the --activate flag to save a key in your local project settings when creating a key.[/green]\n"
+            )
+        else:
+            print("[green]This is your token:[/green]\n")
+            print(api_key["value"])
+
+    await client.close()
+    if activate:
+        await set_active_api_key(project_id=project_id, key=api_key["value"])
+        print(
+            "[green]your api key has been activated and will be used automatically with commands that require a key[/green]\n"
+        )
+
+
+@app.async_command("activate")
+async def activate(
+    *,
+    project_id: ProjectIdOption,
+    key: str,
+):
+    project_id = await resolve_project_id(project_id=project_id)
+    if activate:
+        await set_active_api_key(project_id=project_id, key=key)
+
+
+@app.async_command("delete")
+async def delete(*, project_id: ProjectIdOption, id: str):
+    project_id = await resolve_project_id(project_id=project_id)
+
+    client = await get_client()
+    await client.delete_api_key(project_id=project_id, id=id)
+    await client.close()

meshagent/cli/async_typer.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+import threading
+from functools import partial, wraps
+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[..., Any], func: Callable[..., Any]) -> Any:
+        if inspect.iscoroutinefunction(func):
+
+            @wraps(func)
+            def runner(*args: Any, **kwargs: Any) -> Any:
+                return _run_coroutine_sync(func(*args, **kwargs))
+
+            decorator(runner)
+        else:
+            decorator(func)
+        return func
+
+    def callback(self, *args: Any, **kwargs: Any) -> Any:
+        decorator = super().callback(*args, **kwargs)
+        return partial(self.maybe_run_async, decorator)
+
+    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/auth.py

@@ -0,0 +1,30 @@
+import typer
+
+from meshagent.cli import async_typer
+from meshagent.cli import auth_async
+from meshagent.cli.helper import get_active_project
+
+app = async_typer.AsyncTyper(help="Authenticate to meshagent")
+
+
+@app.async_command("login")
+async def login():
+    await auth_async.login()
+
+    project_id = await get_active_project()
+    if project_id is None:
+        print(
+            "You have been logged in, but you haven"
+            't activated a project yet, list your projects with "meshagent project list" and then activate one with "meshagent project activate PROJECT_ID"'
+        )
+
+
+@app.async_command("logout")
+async def logout():
+    await auth_async.logout()
+
+
+@app.async_command("whoami")
+async def whoami():
+    _, s = await auth_async.session()
+    typer.echo(s.user.email if s else "Not logged in")