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

meshagent/cli/developer.py

@@ -14,13 +14,13 @@ from meshagent.api import (
 )
 from meshagent.api.helpers import meshagent_base_url, websocket_room_url
 
-app = async_typer.AsyncTyper()
+app = async_typer.AsyncTyper(help="Developer utilities for a room")
 
 
-@app.async_command("watch")
+@app.async_command("watch", help="Stream developer logs from a room")
 async def watch_logs(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
 ):
     """

meshagent/cli/exec.py

@@ -82,13 +82,29 @@ def register(app: typer.Typer):
     @app.async_command("exec")
     async def exec_command(
         *,
-        project_id: ProjectIdOption = None,
+        project_id: ProjectIdOption,
         room: RoomOption,
-        name: Annotated[Optional[str], typer.Option()] = None,
-        image: Annotated[Optional[str], typer.Option()] = None,
-        command: Annotated[list[str], typer.Argument(...)] = None,
-        tty: bool = False,
-        room_storage_path: str = "/data",
+        name: Annotated[
+            Optional[str], typer.Option(help="Optional exec session name")
+        ] = None,
+        image: Annotated[
+            Optional[str],
+            typer.Option(help="Optional container image to use for the exec session"),
+        ] = None,
+        command: Annotated[
+            list[str],
+            typer.Argument(..., help="Command to execute (omit when using `--tty`)"),
+        ] = None,
+        tty: Annotated[
+            bool,
+            typer.Option(
+                "--tty/--no-tty",
+                help="Allocate an interactive TTY (requires a real terminal)",
+            ),
+        ] = False,
+        room_storage_path: Annotated[
+            str, typer.Option(help="Room storage mount path (default: /data)")
+        ] = "/data",
     ):
         """Open an interactive websocket‑based TTY."""
         client = await get_client()

meshagent/cli/helper.py

@@ -7,8 +7,14 @@ from typing import Optional
 from meshagent.cli import auth_async
 from meshagent.cli import async_typer
 from meshagent.api.helpers import meshagent_base_url
-from meshagent.api.client import Meshagent
+from meshagent.api.specs.service import ServiceSpec
+from meshagent.agents.context import AgentChatContext
+from meshagent.api.client import Meshagent, RoomConnectionInfo
 import os
+import aiofiles
+from pydantic_yaml import parse_yaml_raw_as
+import json
+
 from rich import print
 
 SETTINGS_FILE = Path.home() / ".meshagent" / "project.json"
@@ -29,11 +35,15 @@ def _save_settings(s: Settings):
 
 
 def _load_settings():
-    _ensure_cache_dir()
-    if SETTINGS_FILE.exists():
-        return Settings.model_validate_json(SETTINGS_FILE.read_text())
-
-    return Settings()
+    try:
+        _ensure_cache_dir()
+        if SETTINGS_FILE.exists():
+            return Settings.model_validate_json(SETTINGS_FILE.read_text())
+    except OSError as ex:
+        if ex.errno == 30:
+            return Settings()
+        else:
+            raise
 
 
 async def get_active_project():
@@ -57,6 +67,8 @@ async def set_active_api_key(project_id: str, key: str):
 
 async def get_active_api_key(project_id: str):
     settings = _load_settings()
+    if settings is None:
+        return None
     key: str = settings.active_api_keys.get(project_id)
     # Ignore old keys, API key format changed
     if key is not None and key.startswith("ma-"):
@@ -68,16 +80,33 @@ async def get_active_api_key(project_id: str):
 app = async_typer.AsyncTyper()
 
 
+class CustomMeshagentClient(Meshagent):
+    async def connect_room(self, *, project_id: str, room: str) -> RoomConnectionInfo:
+        from urllib.parse import quote
+
+        jwt = os.getenv("MESHAGENT_TOKEN")
+
+        if jwt is not None and room == os.getenv("MESHAGENT_ROOM"):
+            return RoomConnectionInfo(
+                jwt=jwt,
+                room_name=room,
+                project_id=os.getenv("MESHAGENT_PROJECT_ID"),
+                room_url=meshagent_base_url() + f"/rooms/{quote(room)}",
+            )
+
+        return await super().connect_room(project_id=project_id, room=room)
+
+
 async def get_client():
     key = os.getenv("MESHAGENT_API_KEY")
-    if key is not None:
-        return Meshagent(
+    if key is not None or os.getenv("MESHAGENT_SESSION_ID") is not None:
+        return CustomMeshagentClient(
             base_url=meshagent_base_url(),
             token=key,
         )
     else:
         access_token = await auth_async.get_access_token()
-        return Meshagent(
+        return CustomMeshagentClient(
             base_url=meshagent_base_url(),
             token=access_token,
         )
@@ -119,7 +148,7 @@ def resolve_room(room_name: Optional[str] = None):
 
 async def resolve_project_id(project_id: Optional[str] = None):
     if project_id is None:
-        project_id = await get_active_project()
+        project_id = os.getenv("MESHAGENT_PROJECT_ID") or await get_active_project()
 
     if project_id is None:
         print(
@@ -130,6 +159,32 @@ async def resolve_project_id(project_id: Optional[str] = None):
     return project_id
 
 
+async def init_context_from_spec(context: AgentChatContext) -> None:
+    path = os.getenv("MESHAGENT_SPEC_PATH")
+
+    if path is None:
+        return None
+
+    async with aiofiles.open(path, "r") as file:
+        spec_str = await file.read()
+        try:
+            json.loads(spec_str)
+            spec = ServiceSpec.model_validate_json(spec_str)
+        except ValueError:
+            # fallback on yaml parser if spec can't
+            spec = parse_yaml_raw_as(ServiceSpec, spec_str)
+
+        readme = spec.metadata.annotations.get("meshagent.service.readme")
+
+        if spec.metadata.description:
+            context.append_assistant_message(
+                f"This agent's description:\n{spec.metadata.description}"
+            )
+
+        if readme is not None:
+            context.append_assistant_message(f"This agent's README:\n{readme}")
+
+
 async def resolve_key(project_id: str | None, key: str | None):
     project_id = await resolve_project_id(project_id=project_id)
     if key is None:
@@ -138,10 +193,44 @@ async def resolve_key(project_id: str | None, key: str | None):
     if key is None:
         key = os.getenv("MESHAGENT_API_KEY")
 
-    if key is None:
+    if key is None and os.getenv("MESHAGENT_TOKEN") is None:
         print(
-            "[red]--key is required if MESHGENT_API_KEY is not set. You can use meshagent api-key create to create a new api key."
+            "[red]--key is required if MESHAGENT_API_KEY is not set. You can use meshagent api-key create to create a new api key."
         )
         raise typer.Exit(1)
 
     return key
+
+
+def cleanup_args(args: list[str]):
+    out = []
+    i = 0
+    while i < len(args):
+        if args[i] == "--service-name":
+            i += 1
+        elif args[i] == "--service-title":
+            i += 1
+        elif args[i] == "--service-description":
+            i += 1
+        elif args[i] == "--project-id":
+            i += 1
+        elif args[i] == "--room":
+            i += 1
+        elif args[i].startswith("--service-name="):
+            pass
+        elif args[i].startswith("--service-title="):
+            pass
+        elif args[i].startswith("--service-description="):
+            pass
+        elif args[i].startswith("--project-id="):
+            pass
+        elif args[i].startswith("--room="):
+            pass
+        elif args[i] == "deploy":
+            pass
+        elif args[i] == "spec":
+            pass
+        else:
+            out.append(args[i])
+        i += 1
+    return out

meshagent/cli/helpers.py

@@ -1,19 +1,20 @@
 from meshagent.cli import async_typer
 
-
 from meshagent.api import SchemaRegistry, SchemaRegistration
 
 
 import logging
 
-app = async_typer.AsyncTyper(help="Join a mailbot to a room")
+app = async_typer.AsyncTyper(help="Developer helper services")
 
 
-@app.async_command("service")
+@app.async_command("service", help="Run local helper HTTP services")
 async def helpers_service():
-    from meshagent.agents.planning import DynamicPlanningResponder, PlanningResponder
+    """Run local helper services (agents, schemas, toolkits)."""
+    from meshagent.agents.llmrunner import LLMTaskRunner, DynamicLLMTaskRunner
     from meshagent.openai.tools import OpenAIResponsesAdapter
     from meshagent.tools.storage import StorageToolkit
+    from meshagent.tools.database import DatabaseToolkitBuilder
     from meshagent.api.services import ServiceHost
 
     from meshagent.agents.schemas.gallery import gallery_schema
@@ -24,20 +25,51 @@ async def helpers_service():
     )
     from meshagent.agents.schemas.presentation import presentation_schema
     from meshagent.agents import thread_schema
+    from meshagent.agents.widget_schema import widget_schema
 
     logging.getLogger("openai").setLevel(logging.ERROR)
     logging.getLogger("httpx").setLevel(logging.ERROR)
 
     service = ServiceHost(port=9000)
 
-    @service.path("/planner")
-    class Planner(PlanningResponder):
+    @service.path("/runner")
+    class Runner(LLMTaskRunner):
         def __init__(self, **kwargs):
             super().__init__(
-                name="meshagent.planner",
                 title="Generic Task Runner",
                 description="an agent that will perform a task with the selected tools",
-                llm_adapter=OpenAIResponsesAdapter(model="gpt-4.1"),
+                llm_adapter=OpenAIResponsesAdapter(model="gpt-5.2"),
+                supports_tools=True,
+                input_prompt=True,
+                output_schema={
+                    "type": "object",
+                    "required": ["result"],
+                    "additionalProperties": False,
+                    "properties": {"result": {"type": "string"}},
+                },
+                annotations={"meshagent.task-runner.attachment-format": "tar"},
+            )
+
+        def get_toolkit_builders(self):
+            from meshagent.tools.storage import StorageToolkitBuilder
+            from meshagent.openai.tools.responses_adapter import WebSearchToolkitBuilder
+
+            providers = [
+                WebSearchToolkitBuilder(),
+                StorageToolkitBuilder(),
+                DatabaseToolkitBuilder(),
+                *super().get_toolkit_builders(),
+            ]
+
+            return providers
+
+    @service.path("/planner")
+    class Planner(LLMTaskRunner):
+        def __init__(self, **kwargs):
+            super().__init__(
+                title="Generic Task Runner (Legacy)",
+                description="an agent that will perform a task with the selected tools",
+                llm_adapter=OpenAIResponsesAdapter(model="gpt-5.2"),
                 supports_tools=True,
                 input_prompt=True,
                 output_schema={
@@ -49,15 +81,26 @@ async def helpers_service():
             )
 
     @service.path("/schema_planner")
-    class DynamicPlanner(DynamicPlanningResponder):
+    class DynamicPlanner(DynamicLLMTaskRunner):
         def __init__(self, **kwargs):
             super().__init__(
-                name="meshagent.schema_planner",
                 title="Schema Task Runner",
                 description="an agent that can produces output that matches a schema",
-                llm_adapter=OpenAIResponsesAdapter(model="gpt-4.1"),
+                llm_adapter=OpenAIResponsesAdapter(model="gpt-5.2"),
             )
 
+        def get_toolkit_builders(self):
+            from meshagent.tools.storage import StorageToolkitBuilder
+            from meshagent.openai.tools.responses_adapter import WebSearchToolkitBuilder
+
+            providers = [
+                WebSearchToolkitBuilder(),
+                StorageToolkitBuilder(),
+                *super().get_toolkit_builders(),
+            ]
+
+            return providers
+
     @service.path("/schemas/document")
     class DocumentSchemaRegistry(SchemaRegistry):
         def __init__(self):
@@ -102,6 +145,17 @@ async def helpers_service():
                 schemas=[SchemaRegistration(name=name, schema=schema)],
             )
 
+    @service.path("/schemas/widget")
+    class WidgetDocumentSchemaRegistry(SchemaRegistry):
+        def __init__(self):
+            name = "widget"
+            schema = widget_schema
+            super().__init__(
+                name=f"meshagent.schema.{name}",
+                validate_webhook_secret=False,
+                schemas=[SchemaRegistration(name=name, schema=schema)],
+            )
+
     @service.path("/schemas/presentation")
     class PresentationDocumentSchemaRegistry(SchemaRegistry):
         def __init__(presentation):

meshagent/cli/host.py

@@ -0,0 +1,41 @@
+from meshagent.api.services import ServiceHost
+from meshagent.api.specs.service import ServiceSpec
+import asyncio
+from meshagent.agents import Agent
+
+
+options = {"deferred": False}
+services = {}
+
+
+agents: list[tuple[Agent, str]] = []
+
+
+def set_deferred(deferred: bool):
+    options["deferred"] = deferred
+
+
+def get_deferred() -> bool:
+    return options["deferred"]
+
+
+def get_service(port: int, host: str) -> ServiceHost:
+    if port not in services:
+        services[port] = ServiceHost(host=host, port=port)
+
+    return services[port]
+
+
+def service_specs() -> list[ServiceSpec]:
+    specs = []
+    for port, s in services.items():
+        specs.append(s.get_service_spec(image=""))
+    return specs
+
+
+async def run_services():
+    tasks = []
+    for port, s in services.items():
+        tasks.append(s.run())
+
+    await asyncio.gather(*tasks)