virtuai-cli 0.2.2__tar.gz → 0.4.0__tar.gz

{virtuai_cli-0.2.2 → virtuai_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtuai-cli
-Version: 0.2.2
+Version: 0.4.0
 Summary: Run VirtuAI deep agents on your local machine
 Author-email: uCloudStore <lmoreno@ucloudstore.com>
 License: Proprietary

{virtuai_cli-0.2.2 → virtuai_cli-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "virtuai-cli"
-version = "0.2.2"
+version = "0.4.0"
 description = "Run VirtuAI deep agents on your local machine"
 readme = "README.md"
 requires-python = ">=3.11"

{virtuai_cli-0.2.2 → virtuai_cli-0.4.0}/src/virtuai_cli/__init__.py

@@ -1,2 +1,2 @@
 """VirtuAI local CLI."""
-__version__ = "0.2.2"
+__version__ = "0.4.0"

{virtuai_cli-0.2.2 → virtuai_cli-0.4.0}/src/virtuai_cli/chat/command.py

@@ -92,6 +92,7 @@ def run_chat(
         agent_id=picked["agent_id"],
         agent_name=picked["name"],
         workspace_name=info["workspace_name"],
-        default_model_id=picked.get("default_model_id"),
+        default_model_id=picked.get("default_model_id") or None,
+        allowed_models=picked.get("allowed_models") or [],
     )
     app.run()

virtuai_cli-0.4.0/src/virtuai_cli/chat/history.py

@@ -0,0 +1,44 @@
+"""HTTP helpers for browsing past conversations from the TUI."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import certifi
+import httpx
+
+
+_VERIFY = certifi.where()
+
+
+async def list_conversations(
+    server_url: str,
+    token: str,
+    agent_id: str,
+    limit: int = 20,
+) -> list[dict]:
+    """Return up to `limit` of the user's recent conversations for this agent."""
+    headers = {"Authorization": f"Bearer {token}"}
+    url = f"{server_url.rstrip('/')}/api/web-chat/conversations/{agent_id}"
+    async with httpx.AsyncClient(verify=_VERIFY, timeout=15.0) as client:
+        resp = await client.get(url, headers=headers, params={"limit": limit, "offset": 0})
+        resp.raise_for_status()
+        return resp.json()
+
+
+async def load_conversation(
+    server_url: str,
+    token: str,
+    agent_id: str,
+    session_id: str,
+    message_limit: int = 200,
+) -> Optional[dict]:
+    """Return {conversation, messages} for one session_id, or None if not found."""
+    headers = {"Authorization": f"Bearer {token}"}
+    url = f"{server_url.rstrip('/')}/api/web-chat/conversations/{agent_id}/{session_id}"
+    async with httpx.AsyncClient(verify=_VERIFY, timeout=30.0) as client:
+        resp = await client.get(url, headers=headers, params={"message_limit": message_limit})
+        if resp.status_code == 404:
+            return None
+        resp.raise_for_status()
+        return resp.json()

{virtuai_cli-0.2.2 → virtuai_cli-0.4.0}/src/virtuai_cli/chat/tui.py

@@ -14,6 +14,7 @@ from textual.reactive import reactive
 from textual.widgets import Footer, Header, Input, Static
 
 from virtuai_cli import runner as ws_runner
+from virtuai_cli.chat.history import list_conversations, load_conversation
 from virtuai_cli.chat.sse import stream_chat
 from virtuai_cli.chat.widgets import AssistantTurn, UserBubble
 
@@ -64,6 +65,7 @@ class ChatApp(App):
         agent_name: str,
         workspace_name: str,
         default_model_id: Optional[str] = None,
+        allowed_models: Optional[list[dict]] = None,
     ) -> None:
         super().__init__()
         self.server_url = server_url
@@ -73,6 +75,8 @@ class ChatApp(App):
         self.agent_name = agent_name
         self.workspace_name = workspace_name
         self.default_model_id = default_model_id
+        self.current_model_id = default_model_id
+        self.allowed_models = list(allowed_models or [])
 
         self.session_id: Optional[str] = None
         self._stream_task: Optional[asyncio.Task] = None
@@ -94,7 +98,7 @@ class ChatApp(App):
         yield Footer()
 
     def _initial_status(self) -> str:
-        model = f" · {self.default_model_id}" if self.default_model_id else ""
+        model = f" · {self.current_model_id}" if self.current_model_id else ""
         return f"{self.workspace_name} · {self.agent_name}{model} · connecting…"
 
     # ── Mount: start the WS runner in the background ──────────────────────
@@ -119,9 +123,10 @@ class ChatApp(App):
     def _set_status(self, text: str) -> None:
         # The status widget may have been torn down during app shutdown —
         # swallow the lookup error so we don't surface a NoMatches on exit.
+        model = f" · {self.current_model_id}" if self.current_model_id else ""
         try:
             self.query_one("#status", Static).update(
-                f"{self.workspace_name} · {self.agent_name} · {text}"
+                f"{self.workspace_name} · {self.agent_name}{model} · {text}"
             )
         except Exception:
             pass
@@ -160,20 +165,148 @@ class ChatApp(App):
     async def _handle_slash(self, cmd: str) -> None:
         parts = cmd.split(None, 1)
         head = parts[0].lower()
+        arg = parts[1].strip() if len(parts) > 1 else ""
         if head in ("/exit", "/quit"):
             self.exit()
         elif head in ("/clear", "/new"):
             await self.action_clear_conversation()
+        elif head == "/models":
+            await self._show_models()
+        elif head == "/model":
+            await self._set_model(arg)
+        elif head == "/history":
+            await self._show_history()
+        elif head == "/load":
+            await self._load_session(arg)
         elif head == "/help":
             await self._append(Static(
                 "[b]Commands[/b]\n"
-                "  /help          this list\n"
-                "  /clear, /new   start a fresh conversation\n"
-                "  /exit, /quit   close the TUI\n"
-                "  Esc            cancel current response\n"
+                "  /help              this list\n"
+                "  /clear, /new       start a fresh conversation\n"
+                "  /history           list this agent's recent conversations\n"
+                "  /load <id>         load a past conversation by session_id\n"
+                "  /models            list models available for this agent\n"
+                "  /model <id>        switch the model for the next message\n"
+                "  /exit, /quit       close the TUI\n"
+                "  Esc                cancel current response\n"
             ))
         else:
-            await self._append(Static(f"[red]Unknown command: {head}[/red]"))
+            await self._append(Static(f"[red]Unknown command: {head}[/red]  (try /help)"))
+
+    async def _show_models(self) -> None:
+        if not self.allowed_models:
+            await self._append(Static(
+                "[yellow]No model catalog available for this agent.[/yellow]"
+            ))
+            return
+        lines = ["[b]Available models[/b]"]
+        for m in self.allowed_models:
+            marker = "•" if m["id"] != self.current_model_id else "[green]✓[/green]"
+            label = m.get("label") or m["id"]
+            provider = f" [dim]({m['provider']})[/dim]" if m.get("provider") else ""
+            lines.append(f"  {marker} [bold]{m['id']}[/bold] — {label}{provider}")
+        lines.append("\n[dim]Use [/dim][b]/model <id>[/b][dim] to switch.[/dim]")
+        await self._append(Static("\n".join(lines)))
+
+    async def _show_history(self) -> None:
+        try:
+            convs = await list_conversations(self.server_url, self.token, self.agent_id, limit=20)
+        except Exception as exc:
+            await self._append(Static(f"[red]Could not load history:[/red] {exc}"))
+            return
+        if not convs:
+            await self._append(Static("[dim]No past conversations with this agent.[/dim]"))
+            return
+        lines = ["[b]Recent conversations[/b]  [dim](most recent first)[/dim]"]
+        for c in convs:
+            sid = c.get("session_id", "")
+            title = c.get("title") or "(untitled)"
+            when = (c.get("last_message_at") or c.get("updated_at") or "")[:19]
+            count = c.get("message_count", 0)
+            marker = "[green]✓[/green] " if sid == self.session_id else "  "
+            lines.append(f"{marker}[bold]{sid}[/bold]  {when}  · {count} msgs  · {title}")
+        lines.append("\n[dim]Use [/dim][b]/load <session_id>[/b][dim] to switch.[/dim]")
+        await self._append(Static("\n".join(lines)))
+
+    async def _load_session(self, session_id: str) -> None:
+        if not session_id:
+            await self._append(Static(
+                "Usage: [b]/load <session_id>[/b]  (see [b]/history[/b] for IDs)"
+            ))
+            return
+        if self._stream_task and not self._stream_task.done():
+            await self._append(Static(
+                "[yellow]Cancel the in-flight response (Esc) before loading another conversation.[/yellow]"
+            ))
+            return
+        try:
+            data = await load_conversation(self.server_url, self.token, self.agent_id, session_id)
+        except Exception as exc:
+            await self._append(Static(f"[red]Could not load conversation:[/red] {exc}"))
+            return
+        if data is None:
+            await self._append(Static(f"[red]Conversation not found:[/red] {session_id}"))
+            return
+
+        # Clear the screen and rebuild it with the loaded history.
+        scroll = self.query_one("#conversation", VerticalScroll)
+        for child in list(scroll.children):
+            await child.remove()
+
+        conv = data.get("conversation") or {}
+        messages = data.get("messages") or []
+        self.session_id = conv.get("session_id") or session_id
+        self._current_turn = None
+
+        header = (
+            f"[b]Loaded conversation[/b] {self.session_id}\n"
+            f"[dim]{conv.get('title') or '(untitled)'} · {len(messages)} message(s)[/dim]"
+        )
+        await scroll.mount(Static(header))
+
+        for msg in messages:
+            mtype = (msg.get("message_type") or "").lower()
+            content = msg.get("content") or ""
+            if mtype in ("user", "human"):
+                await scroll.mount(UserBubble(content))
+            else:
+                turn = AssistantTurn()
+                await scroll.mount(turn)
+                if content:
+                    await turn.append_token(content)
+                turn.mark_final()
+        scroll.scroll_end(animate=False)
+        self._set_status(f"loaded {self.session_id}")
+
+    async def _set_model(self, requested: str) -> None:
+        if not requested:
+            current = self.current_model_id or "(none)"
+            await self._append(Static(
+                f"Current model: [b]{current}[/b]\n"
+                f"Usage: [b]/model <id>[/b]  (see [b]/models[/b] for the list)"
+            ))
+            return
+        if self._stream_task and not self._stream_task.done():
+            await self._append(Static(
+                "[yellow]Cancel the in-flight response (Esc) before switching models.[/yellow]"
+            ))
+            return
+        if self.allowed_models:
+            valid_ids = {m["id"] for m in self.allowed_models}
+            if requested not in valid_ids:
+                # Loose match by label too
+                by_label = {m.get("label", ""): m["id"] for m in self.allowed_models}
+                if requested in by_label:
+                    requested = by_label[requested]
+                else:
+                    await self._append(Static(
+                        f"[red]'{requested}' is not in this agent's catalog.[/red]  "
+                        f"Run [b]/models[/b] to see valid IDs."
+                    ))
+                    return
+        self.current_model_id = requested
+        self._set_status(f"model set to {requested}")
+        await self._append(Static(f"[green]✓[/green] Model switched to [b]{requested}[/b]."))
 
     async def action_clear_conversation(self) -> None:
         self.session_id = None
@@ -200,7 +333,7 @@ class ChatApp(App):
                 self.agent_id,
                 message,
                 session_id=self.session_id,
-                model_id=self.default_model_id,
+                model_id=self.current_model_id,
             ):
                 await self._handle_event(event, turn)
         except asyncio.CancelledError:

{virtuai_cli-0.2.2 → virtuai_cli-0.4.0}/src/virtuai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtuai-cli
-Version: 0.2.2
+Version: 0.4.0
 Summary: Run VirtuAI deep agents on your local machine
 Author-email: uCloudStore <lmoreno@ucloudstore.com>
 License: Proprietary

{virtuai_cli-0.2.2 → virtuai_cli-0.4.0}/src/virtuai_cli.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ src/virtuai_cli.egg-info/requires.txt
 src/virtuai_cli.egg-info/top_level.txt
 src/virtuai_cli/chat/__init__.py
 src/virtuai_cli/chat/command.py
+src/virtuai_cli/chat/history.py
 src/virtuai_cli/chat/sse.py
 src/virtuai_cli/chat/tui.py
 src/virtuai_cli/chat/widgets.py