meshagent-cli 0.28.2__tar.gz → 0.28.4__tar.gz

{meshagent_cli-0.28.2 → meshagent_cli-0.28.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-cli
-Version: 0.28.2
+Version: 0.28.4
 Summary: CLI for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -19,21 +19,21 @@ Requires-Dist: rich~=14.3.0
 Requires-Dist: textual<2.0,>=0.50
 Requires-Dist: prompt-toolkit~=3.0.52
 Provides-Extra: all
-Requires-Dist: meshagent-agents[all]~=0.28.2; extra == "all"
-Requires-Dist: meshagent-api[all]~=0.28.2; extra == "all"
-Requires-Dist: meshagent-computers~=0.28.2; extra == "all"
-Requires-Dist: meshagent-openai~=0.28.2; extra == "all"
-Requires-Dist: meshagent-anthropic~=0.28.2; extra == "all"
-Requires-Dist: meshagent-codex~=0.28.2; extra == "all"
-Requires-Dist: meshagent-mcp~=0.28.2; extra == "all"
-Requires-Dist: meshagent-tools~=0.28.2; extra == "all"
+Requires-Dist: meshagent-agents[all]~=0.28.4; extra == "all"
+Requires-Dist: meshagent-api[all]~=0.28.4; extra == "all"
+Requires-Dist: meshagent-computers~=0.28.4; extra == "all"
+Requires-Dist: meshagent-openai~=0.28.4; extra == "all"
+Requires-Dist: meshagent-anthropic~=0.28.4; extra == "all"
+Requires-Dist: meshagent-codex~=0.28.4; extra == "all"
+Requires-Dist: meshagent-mcp~=0.28.4; extra == "all"
+Requires-Dist: meshagent-tools~=0.28.4; extra == "all"
 Requires-Dist: supabase-auth~=2.28.0; extra == "all"
 Requires-Dist: prompt-toolkit~=3.0.52; extra == "all"
 Provides-Extra: mcp-service
-Requires-Dist: meshagent-agents[all]~=0.28.2; extra == "mcp-service"
-Requires-Dist: meshagent-api~=0.28.2; extra == "mcp-service"
-Requires-Dist: meshagent-mcp~=0.28.2; extra == "mcp-service"
-Requires-Dist: meshagent-tools~=0.28.2; extra == "mcp-service"
+Requires-Dist: meshagent-agents[all]~=0.28.4; extra == "mcp-service"
+Requires-Dist: meshagent-api~=0.28.4; extra == "mcp-service"
+Requires-Dist: meshagent-mcp~=0.28.4; extra == "mcp-service"
+Requires-Dist: meshagent-tools~=0.28.4; extra == "mcp-service"
 Requires-Dist: supabase-auth~=2.28.0; extra == "mcp-service"
 
 # [Meshagent](https://www.meshagent.com)

{meshagent_cli-0.28.2 → meshagent_cli-0.28.4}/meshagent/cli/chatbot.py

@@ -7,6 +7,7 @@ from meshagent.tools import (
     WebFetchTool,
     WebFetchToolkitBuilder,
     ContainerShellTool,
+    MemoriesToolkit,
 )
 from meshagent.tools.storage import (
     StorageToolMount,
@@ -40,6 +41,7 @@ from meshagent.cli.helper import (
     cleanup_args,
     get_client,
     parse_shell_tool_mounts,
+    parse_memory_selector,
     parse_storage_tool_mounts,
     resolve_key,
     resolve_project_id,
@@ -250,6 +252,8 @@ def build_chatbot(
     require_read_only_storage: Optional[str] = None,
     require_time: bool = True,
     require_uuid: bool = False,
+    use_memory: Optional[str] = None,
+    memory_model: Optional[str] = None,
     rules_file: Optional[list[str]] = None,
     room_rules_path: Optional[list[str]] = None,
     require_discovery: Optional[str] = None,
@@ -316,6 +320,10 @@ def build_chatbot(
             )
             raise typer.Exit(1)
 
+    memory_selection: Optional[tuple[str, Optional[list[str]]]] = None
+    if use_memory is not None:
+        memory_selection = parse_memory_selector(use_memory)
+
     BaseClass = ChatBot
     decision_model = None
     if llm_participant:
@@ -539,6 +547,16 @@ def build_chatbot(
             if require_uuid:
                 providers.extend((UUIDToolkit()).tools)
 
+            if memory_selection is not None:
+                memory_name, memory_namespace = memory_selection
+                providers.extend(
+                    MemoriesToolkit(
+                        memory_name=memory_name,
+                        namespace=memory_namespace,
+                        llm_model=memory_model,
+                    ).tools
+                )
+
             if len(require_table_write) > 0:
                 providers.extend(
                     (
@@ -845,6 +863,20 @@ async def join(
             help="Enable UUID generation tools",
         ),
     ] = False,
+    use_memory: Annotated[
+        Optional[str],
+        typer.Option(
+            "--use-memory",
+            help="Use memories toolkit for <name> or <namespace>/<name>",
+        ),
+    ] = None,
+    memory_model: Annotated[
+        Optional[str],
+        typer.Option(
+            "--memory-model",
+            help="Model name for memory LLM ingestion",
+        ),
+    ] = None,
     require_document_authoring: Annotated[
         Optional[bool],
         typer.Option(..., help="Enable MeshDocument authoring"),
@@ -916,7 +948,6 @@ async def join(
             token = ParticipantToken(
                 name=agent_name,
             )
-
             token.add_api_grant(ApiScope.agent_default(tunnels=require_computer_use))
 
             token.add_role_grant(role=role)
@@ -969,6 +1000,8 @@ async def join(
             require_read_only_storage=require_read_only_storage,
             require_time=require_time,
             require_uuid=require_uuid,
+            use_memory=use_memory,
+            memory_model=memory_model,
             room_rules_path=room_rules,
             require_document_authoring=require_document_authoring,
             require_discovery=require_discovery,
@@ -1190,6 +1223,20 @@ async def service(
             help="Enable UUID generation tools",
         ),
     ] = False,
+    use_memory: Annotated[
+        Optional[str],
+        typer.Option(
+            "--use-memory",
+            help="Use memories toolkit for <name> or <namespace>/<name>",
+        ),
+    ] = None,
+    memory_model: Annotated[
+        Optional[str],
+        typer.Option(
+            "--memory-model",
+            help="Model name for memory LLM ingestion",
+        ),
+    ] = None,
     working_dir: WorkingDirOption = None,
     working_directory: WorkingDirectoryAliasOption = None,
     require_document_authoring: Annotated[
@@ -1302,6 +1349,8 @@ async def service(
             require_read_only_storage=require_read_only_storage,
             require_time=require_time,
             require_uuid=require_uuid,
+            use_memory=use_memory,
+            memory_model=memory_model,
             room_rules_path=room_rules,
             working_dir=working_dir,
             require_document_authoring=require_document_authoring,
@@ -1501,6 +1550,20 @@ async def spec(
             help="Enable UUID generation tools",
         ),
     ] = False,
+    use_memory: Annotated[
+        Optional[str],
+        typer.Option(
+            "--use-memory",
+            help="Use memories toolkit for <name> or <namespace>/<name>",
+        ),
+    ] = None,
+    memory_model: Annotated[
+        Optional[str],
+        typer.Option(
+            "--memory-model",
+            help="Model name for memory LLM ingestion",
+        ),
+    ] = None,
     working_dir: WorkingDirOption = None,
     working_directory: WorkingDirectoryAliasOption = None,
     require_document_authoring: Annotated[
@@ -1612,6 +1675,8 @@ async def spec(
             require_read_only_storage=require_read_only_storage,
             require_time=require_time,
             require_uuid=require_uuid,
+            use_memory=use_memory,
+            memory_model=memory_model,
             room_rules_path=room_rules,
             working_dir=working_dir,
             require_document_authoring=require_document_authoring,
@@ -1822,6 +1887,20 @@ async def deploy(
             help="Enable UUID generation tools",
         ),
     ] = False,
+    use_memory: Annotated[
+        Optional[str],
+        typer.Option(
+            "--use-memory",
+            help="Use memories toolkit for <name> or <namespace>/<name>",
+        ),
+    ] = None,
+    memory_model: Annotated[
+        Optional[str],
+        typer.Option(
+            "--memory-model",
+            help="Model name for memory LLM ingestion",
+        ),
+    ] = None,
     working_dir: WorkingDirOption = None,
     working_directory: WorkingDirectoryAliasOption = None,
     require_document_authoring: Annotated[
@@ -1940,6 +2019,8 @@ async def deploy(
             require_read_only_storage=require_read_only_storage,
             require_time=require_time,
             require_uuid=require_uuid,
+            use_memory=use_memory,
+            memory_model=memory_model,
             room_rules_path=room_rules,
             working_dir=working_dir,
             require_document_authoring=require_document_authoring,
@@ -2835,7 +2916,11 @@ async def chat_with(
                 return
 
             items = message_nodes[0].get_children()
-            self._has_active_events = self._thread_has_active_events(items)
+            has_active_event_nodes = self._thread_has_active_event_nodes(items)
+            thread_status_text = self._active_thread_status_text()
+            self._has_active_events = (
+                has_active_event_nodes or thread_status_text is not None
+            )
             selected_before = self._selected_pending_approval()
             selected_id = selected_before[0] if selected_before is not None else None
             self._pending_approval_items = self._collect_pending_approvals(items)
@@ -2863,6 +2948,11 @@ async def chat_with(
                 ):
                     rendered_items.append(renderable)
 
+            if thread_status_text is not None and not has_active_event_nodes:
+                rendered_items.append(
+                    self._render_thread_status_item(thread_status_text)
+                )
+
             if len(rendered_items) == 0:
                 self._messages_view.update("")
             else:
@@ -2871,7 +2961,7 @@ async def chat_with(
             if self._messages_scroll is not None:
                 self._messages_scroll.scroll_end(animate=False)
 
-        def _thread_has_active_events(self, items) -> bool:
+        def _thread_has_active_event_nodes(self, items) -> bool:
             for item in items:
                 if getattr(item, "tag_name", None) != "event":
                     continue
@@ -2880,6 +2970,37 @@ async def chat_with(
                     return True
             return False
 
+        def _active_thread_status_text(self) -> str | None:
+            participant = self._chat_client._participant
+            if participant is None:
+                return None
+
+            status_attr = f"thread.status.text.{self._chat_client.thread_path}"
+            status = participant.get_attribute(status_attr)
+            if not isinstance(status, str):
+                return None
+
+            normalized = status.strip()
+            if normalized == "":
+                return None
+
+            return normalized
+
+        def _render_thread_status_item(self, status_text: str) -> RenderableType:
+            table = Table.grid(expand=True, padding=(0, 0))
+            table.add_column(width=2, no_wrap=True)
+            table.add_column(ratio=1)
+            table.add_column(width=2, no_wrap=True)
+
+            table.add_row(Text("  "), Text(" "), Text("  "))
+            table.add_row(
+                Text("  "),
+                Text(f"{self._event_spinner()} {status_text}", style="bold magenta"),
+                Text("  "),
+            )
+            table.add_row(Text("  "), Text(" "), Text("  "))
+            return table
+
         def _collect_pending_approvals(self, items) -> list[tuple[str, str, str]]:
             approvals: list[tuple[str, str, str]] = []
             seen: set[str] = set()
@@ -3615,6 +3736,20 @@ async def run(
             help="Enable UUID generation tools",
         ),
     ] = False,
+    use_memory: Annotated[
+        Optional[str],
+        typer.Option(
+            "--use-memory",
+            help="Use memories toolkit for <name> or <namespace>/<name>",
+        ),
+    ] = None,
+    memory_model: Annotated[
+        Optional[str],
+        typer.Option(
+            "--memory-model",
+            help="Model name for memory LLM ingestion",
+        ),
+    ] = None,
     require_document_authoring: Annotated[
         Optional[bool],
         typer.Option(..., help="Enable MeshDocument authoring"),
@@ -3687,7 +3822,7 @@ async def run(
         working_dir=working_dir,
         working_directory=working_directory,
     )
-    if not verbose:
+    if not verbose and not log_llm_requests:
         root = logging.getLogger()
         root.setLevel(logging.ERROR)
 
@@ -3767,6 +3902,8 @@ async def run(
                 require_read_only_storage=require_read_only_storage,
                 require_time=require_time,
                 require_uuid=require_uuid,
+                use_memory=use_memory,
+                memory_model=memory_model,
                 room_rules_path=room_rules,
                 require_document_authoring=require_document_authoring,
                 require_discovery=require_discovery,

{meshagent_cli-0.28.2 → meshagent_cli-0.28.4}/meshagent/cli/helper.py

@@ -213,6 +213,22 @@ async def resolve_key(project_id: str | None, key: str | None):
     return key
 
 
+def parse_memory_selector(value: str) -> tuple[str, Optional[list[str]]]:
+    cleaned = value.strip()
+    if cleaned == "":
+        raise typer.BadParameter("--use-memory cannot be empty")
+
+    segments = [segment.strip() for segment in cleaned.split("/")]
+    if any(segment == "" for segment in segments):
+        raise typer.BadParameter(
+            "--use-memory must be '<name>' or '<namespace>/<name>' with no empty segments"
+        )
+
+    memory_name = segments[-1]
+    namespace = segments[:-1]
+    return memory_name, namespace or None
+
+
 def _split_mount_value(
     value: str, option_name: str, default_read_only: bool
 ) -> tuple[str, str, bool]:

meshagent_cli-0.28.4/meshagent/cli/helper_test.py

@@ -0,0 +1,33 @@
+import pytest
+import typer
+
+from meshagent.cli.helper import parse_memory_selector
+
+
+def test_parse_memory_selector_name_only() -> None:
+    memory_name, namespace = parse_memory_selector("graph")
+
+    assert memory_name == "graph"
+    assert namespace is None
+
+
+def test_parse_memory_selector_with_namespace() -> None:
+    memory_name, namespace = parse_memory_selector("team/shared/graph")
+
+    assert memory_name == "graph"
+    assert namespace == ["team", "shared"]
+
+
+@pytest.mark.parametrize(
+    "value",
+    [
+        "",
+        " ",
+        "/graph",
+        "team/",
+        "team//graph",
+    ],
+)
+def test_parse_memory_selector_rejects_empty_segments(value: str) -> None:
+    with pytest.raises(typer.BadParameter):
+        parse_memory_selector(value)

{meshagent_cli-0.28.2 → meshagent_cli-0.28.4}/meshagent/cli/mailbot.py

@@ -9,13 +9,14 @@ from meshagent.cli.common_options import (
     ProjectIdOption,
     RoomOption,
 )
-from meshagent.tools import Toolkit, WebFetchTool, ContainerShellTool
+from meshagent.tools import Toolkit, WebFetchTool, ContainerShellTool, MemoriesToolkit
 from meshagent.api import RoomClient, WebSocketClientProtocol, ApiScope
 from meshagent.api.helpers import websocket_room_url
 from meshagent.cli.helper import (
     cleanup_args,
     get_client,
     parse_shell_tool_mounts,
+    parse_memory_selector,
     parse_storage_tool_mounts,
     resolve_key,
     resolve_project_id,
@@ -212,6 +213,8 @@ def build_mailbot(
     shell_tool_mounts: Optional[ContainerMountSpec] = None,
     require_time: bool = True,
     require_uuid: bool = False,
+    use_memory: Optional[str] = None,
+    memory_model: Optional[str] = None,
     require_table_read: bool,
     require_table_write: bool,
     require_computer_use: bool,
@@ -257,6 +260,10 @@ def build_mailbot(
     supports_openai_tools = llm_participant is None and not is_claude_model
     base_shell_env = _copy_shell_env_vars(copy_env=shell_copy_env)
     base_shell_env.update(_set_shell_env_vars(set_env=shell_set_env))
+    memory_selection: Optional[tuple[str, Optional[list[str]]]] = None
+    if use_memory is not None:
+        memory_selection = parse_memory_selector(use_memory)
+
     if not supports_openai_tools:
         if image_generation:
             print("image generation tool is only supported by openai models")
@@ -506,6 +513,16 @@ def build_mailbot(
             if require_uuid:
                 thread_toolkit.tools.extend(UUIDToolkit().tools)
 
+            if memory_selection is not None:
+                memory_name, memory_namespace = memory_selection
+                thread_toolkit.tools.extend(
+                    MemoriesToolkit(
+                        memory_name=memory_name,
+                        namespace=memory_namespace,
+                        llm_model=memory_model,
+                    ).tools
+                )
+
             if require_computer_use:
                 from meshagent.computers.agent import ComputerToolkit
 
@@ -670,6 +687,20 @@ async def join(
             help="Enable UUID generation tools",
         ),
     ] = False,
+    use_memory: Annotated[
+        Optional[str],
+        typer.Option(
+            "--use-memory",
+            help="Use memories toolkit for <name> or <namespace>/<name>",
+        ),
+    ] = None,
+    memory_model: Annotated[
+        Optional[str],
+        typer.Option(
+            "--memory-model",
+            help="Model name for memory LLM ingestion",
+        ),
+    ] = None,
     database_namespace: Annotated[
         Optional[str],
         typer.Option(..., help="Use a specific database namespace"),
@@ -792,6 +823,8 @@ async def join(
             shell_tool_mounts=shell_tool_mounts,
             require_time=require_time,
             require_uuid=require_uuid,
+            use_memory=use_memory,
+            memory_model=memory_model,
             require_table_read=require_table_read,
             require_table_write=require_table_write,
             require_computer_use=require_computer_use,
@@ -978,6 +1011,20 @@ async def service(
             help="Enable UUID generation tools",
         ),
     ] = False,
+    use_memory: Annotated[
+        Optional[str],
+        typer.Option(
+            "--use-memory",
+            help="Use memories toolkit for <name> or <namespace>/<name>",
+        ),
+    ] = None,
+    memory_model: Annotated[
+        Optional[str],
+        typer.Option(
+            "--memory-model",
+            help="Model name for memory LLM ingestion",
+        ),
+    ] = None,
     database_namespace: Annotated[
         Optional[str],
         typer.Option(..., help="Use a specific database namespace"),
@@ -1081,6 +1128,8 @@ async def service(
             shell_tool_mounts=shell_tool_mounts,
             require_time=require_time,
             require_uuid=require_uuid,
+            use_memory=use_memory,
+            memory_model=memory_model,
             require_table_read=require_table_read,
             require_table_write=require_table_write,
             require_computer_use=require_computer_use,
@@ -1254,6 +1303,20 @@ async def spec(
             help="Enable UUID generation tools",
         ),
     ] = False,
+    use_memory: Annotated[
+        Optional[str],
+        typer.Option(
+            "--use-memory",
+            help="Use memories toolkit for <name> or <namespace>/<name>",
+        ),
+    ] = None,
+    memory_model: Annotated[
+        Optional[str],
+        typer.Option(
+            "--memory-model",
+            help="Model name for memory LLM ingestion",
+        ),
+    ] = None,
     database_namespace: Annotated[
         Optional[str],
         typer.Option(..., help="Use a specific database namespace"),
@@ -1357,6 +1420,8 @@ async def spec(
             shell_tool_mounts=shell_tool_mounts,
             require_time=require_time,
             require_uuid=require_uuid,
+            use_memory=use_memory,
+            memory_model=memory_model,
             require_table_read=require_table_read,
             require_table_write=require_table_write,
             require_computer_use=require_computer_use,
@@ -1541,6 +1606,20 @@ async def deploy(
             help="Enable UUID generation tools",
         ),
     ] = False,
+    use_memory: Annotated[
+        Optional[str],
+        typer.Option(
+            "--use-memory",
+            help="Use memories toolkit for <name> or <namespace>/<name>",
+        ),
+    ] = None,
+    memory_model: Annotated[
+        Optional[str],
+        typer.Option(
+            "--memory-model",
+            help="Model name for memory LLM ingestion",
+        ),
+    ] = None,
     database_namespace: Annotated[
         Optional[str],
         typer.Option(..., help="Use a specific database namespace"),
@@ -1651,6 +1730,8 @@ async def deploy(
             shell_tool_mounts=shell_tool_mounts,
             require_time=require_time,
             require_uuid=require_uuid,
+            use_memory=use_memory,
+            memory_model=memory_model,
             require_table_read=require_table_read,
             require_table_write=require_table_write,
             require_computer_use=require_computer_use,
@@ -1677,7 +1758,7 @@ async def deploy(
     spec.metadata.description = service_description
     spec.container.image = "meshagent/cli:default"
     spec.container.command = shlex.join(
-        ["meshagent", "mailbot", *cleanup_args(sys.argv[:2])]
+        ["meshagent", "mailbot", "service", *cleanup_args(sys.argv[2:])]
     )
 
     client = await get_client()

{meshagent_cli-0.28.2 → meshagent_cli-0.28.4}/meshagent/cli/port.py

@@ -8,6 +8,7 @@ from meshagent.api.helpers import websocket_room_url
 from typing import Annotated, Optional
 
 import typer
+from rich import print
 
 from meshagent.cli import async_typer
 from meshagent.cli.common_options import ProjectIdOption
@@ -18,6 +19,41 @@ from meshagent.api.port_forward import port_forward
 app = async_typer.AsyncTyper(help="Port forwarding into room containers")
 
 
+def _parse_port_mapping(value: str) -> tuple[int, int]:
+    raw = value.strip()
+    if raw == "":
+        raise typer.BadParameter("--port cannot be empty")
+
+    parts = [part.strip() for part in raw.split(":")]
+    if len(parts) != 2:
+        raise typer.BadParameter("Expected --port in LOCAL:REMOTE format")
+
+    local_raw, remote_raw = parts
+    if local_raw == "" or remote_raw == "":
+        raise typer.BadParameter("Expected --port in LOCAL:REMOTE format")
+
+    try:
+        local_port = int(local_raw)
+    except ValueError as exc:
+        raise typer.BadParameter(
+            f"LOCAL port must be an integer, got: {local_raw}"
+        ) from exc
+
+    try:
+        remote_port = int(remote_raw)
+    except ValueError as exc:
+        raise typer.BadParameter(
+            f"REMOTE port must be an integer, got: {remote_raw}"
+        ) from exc
+
+    if not (0 <= local_port <= 65535):
+        raise typer.BadParameter("LOCAL port must be between 0 and 65535")
+    if not (1 <= remote_port <= 65535):
+        raise typer.BadParameter("REMOTE port must be between 1 and 65535")
+
+    return local_port, remote_port
+
+
 @app.async_command("forward", help="Forward a container port to localhost")
 async def forward(
     *,
@@ -59,12 +95,11 @@ async def forward(
 
     client = await get_client()
     try:
+        local_port, remote_port = _parse_port_mapping(port)
         project_id = await resolve_project_id(project_id)
 
         connection = await client.connect_room(project_id=project_id, room=room)
 
-        ports = port.split(":")
-
         if name is not None:
             async with RoomClient(
                 protocol=WebSocketClientProtocol(
@@ -86,8 +121,8 @@ async def forward(
             raise typer.Exit(1)
 
         handler = await port_forward(
-            listen_port=int(ports[0]),
-            port=int(ports[1]),
+            listen_port=local_port,
+            port=remote_port,
             container_id=container_id,
             token=connection.jwt,
         )
@@ -95,6 +130,9 @@ async def forward(
         await asyncio.sleep(10000)
 
         await handler.close()
+    except typer.BadParameter as exc:
+        print(f"[red]{exc}[/red]")
+        raise typer.Exit(1) from exc
 
     finally:
         await client.close()

meshagent_cli-0.28.4/meshagent/cli/port_test.py

@@ -0,0 +1,38 @@
+import pytest
+import typer
+
+from meshagent.cli.port import _parse_port_mapping
+
+
+@pytest.mark.parametrize(
+    ("value", "expected"),
+    [
+        ("3000:3000", (3000, 3000)),
+        ("0:3000", (0, 3000)),
+        (" 8080 : 80 ", (8080, 80)),
+    ],
+)
+def test_parse_port_mapping_accepts_valid_values(
+    value: str, expected: tuple[int, int]
+) -> None:
+    assert _parse_port_mapping(value) == expected
+
+
+@pytest.mark.parametrize(
+    "value",
+    [
+        "",
+        "3000",
+        ":3000",
+        "3000:",
+        "abc:3000",
+        "3000:abc",
+        "-1:3000",
+        "70000:3000",
+        "3000:0",
+        "3000:70000",
+    ],
+)
+def test_parse_port_mapping_rejects_invalid_values(value: str) -> None:
+    with pytest.raises(typer.BadParameter):
+        _parse_port_mapping(value)