virtuai-cli 0.8.6__tar.gz → 0.8.8__tar.gz

{virtuai_cli-0.8.6 → virtuai_cli-0.8.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtuai-cli
-Version: 0.8.6
+Version: 0.8.8
 Summary: Run VirtuAI deep agents on your local machine
 Author-email: uCloudStore <lmoreno@ucloudstore.com>
 License: Proprietary
@@ -20,6 +20,8 @@ Requires-Dist: keyring>=25.0
 Requires-Dist: typer>=0.12
 Requires-Dist: rich>=13.0
 Requires-Dist: textual>=0.86
+Provides-Extra: local
+Requires-Dist: langchain-ollama>=0.2; extra == "local"
 
 # VirtuAI CLI
 

{virtuai_cli-0.8.6 → virtuai_cli-0.8.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "virtuai-cli"
-version = "0.8.6"
+version = "0.8.8"
 description = "Run VirtuAI deep agents on your local machine"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -30,6 +30,14 @@ dependencies = [
     "textual>=0.86",
 ]
 
+# Optional: local model inference. Pulls langchain-ollama (+ langchain-core) so
+# the CLI can answer the server's model_generate frames from a locally-running
+# Ollama. Install with: pip install 'virtuai-cli[local]'
+[project.optional-dependencies]
+local = [
+    "langchain-ollama>=0.2",
+]
+
 [project.urls]
 Homepage = "https://imvituai.com"
 

{virtuai_cli-0.8.6 → virtuai_cli-0.8.8}/src/virtuai_cli/__init__.py

@@ -1,2 +1,2 @@
 """VirtuAI local CLI."""
-__version__ = "0.8.6"
+__version__ = "0.8.7"

{virtuai_cli-0.8.6 → virtuai_cli-0.8.8}/src/virtuai_cli/chat/ask.py

@@ -134,6 +134,10 @@ async def _run_ask(
                     err.print(f"[dim]✓ {first[0][:80] if first else ''}[/dim]")
                 else:
                     err.print("[dim]✓ done[/dim]")
+            elif etype == "notice" and mode == "stream":
+                msg = event.get("message", "")
+                color = {"warn": "yellow", "error": "red"}.get(event.get("level"), "dim")
+                err.print(f"[{color}]⚠ {msg}[/{color}]")
             elif etype == "error":
                 msg = event.get("error") or event.get("message") or "unknown"
                 err.print(f"[red]error: {msg}[/red]")

{virtuai_cli-0.8.6 → virtuai_cli-0.8.8}/src/virtuai_cli/chat/tui.py

@@ -871,6 +871,10 @@ class ChatApp(App):
                     "\n\n*[response truncated — try raising the agent's max_tokens]*"
                 )
                 turn._truncated_shown = True
+        elif etype == "notice":
+            msg = event.get("message") or ""
+            if msg:
+                await turn.append_token(f"\n\n*⚠ {msg}*\n\n")
         elif etype == "error":
             msg = event.get("error") or event.get("message") or "unknown error"
             await turn.append_token(f"\n\n*[error: {msg}]*")

{virtuai_cli-0.8.6 → virtuai_cli-0.8.8}/src/virtuai_cli/runner.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
+import os
 import platform
 import sys
 import time
@@ -13,6 +14,9 @@ from typing import Callable, Optional
 
 _AUDIT_DIR = Path.home() / ".virtuai"
 
+# Local Ollama endpoint used to answer the server's model_generate frames.
+OLLAMA_BASE_URL = os.environ.get("OLLAMA_BASE_URL", "http://localhost:11434")
+
 import websockets
 from rich.console import Console
 
@@ -101,6 +105,84 @@ def _default_on_status(level: str, msg: str) -> None:
     console.print(f"[{style}]{msg}[/{style}]" if style else msg)
 
 
+async def _probe_ollama() -> dict:
+    """Return {"reachable": bool, "models": [name, ...]} for the local Ollama.
+
+    Reported in the ready frame so the server knows up-front whether it can
+    proxy a model turn here or should fall back to a cloud model.
+    """
+    try:
+        import httpx
+    except Exception:
+        return {"reachable": False, "models": []}
+    try:
+        async with httpx.AsyncClient(timeout=2.0) as client:
+            resp = await client.get(f"{OLLAMA_BASE_URL.rstrip('/')}/api/tags")
+            resp.raise_for_status()
+            data = resp.json()
+            models = [m.get("name", "") for m in data.get("models", []) if m.get("name")]
+            return {"reachable": True, "models": models}
+    except Exception:
+        return {"reachable": False, "models": []}
+
+
+async def _handle_model_generate(frame: dict, ws, on_status: StatusCallback) -> None:
+    """Answer a server model_generate frame from the local Ollama.
+
+    Streams text deltas as model_token frames, then a terminal model_result
+    carrying tool_calls + usage. On any failure replies model_error so the
+    server can fall back to a cloud model.
+    """
+    fid = frame.get("id")
+
+    async def _error(reason: str) -> None:
+        await ws.send(json.dumps({
+            "v": 1, "id": fid, "type": "model_error", "error": reason,
+        }))
+
+    try:
+        from langchain_ollama import ChatOllama
+        from langchain_core.messages import messages_from_dict
+    except Exception:
+        await _error(
+            "local model support not installed — run: pip install 'virtuai-cli[local]'"
+        )
+        return
+
+    model = frame.get("model") or ""
+    on_status("info", f"local model: {model}")
+    try:
+        messages = messages_from_dict(frame.get("messages", []))
+        tools = frame.get("tools") or []
+        kwargs = {"model": model, "base_url": OLLAMA_BASE_URL}
+        if frame.get("temperature") is not None:
+            kwargs["temperature"] = frame["temperature"]
+        if frame.get("num_predict") is not None:
+            kwargs["num_predict"] = frame["num_predict"]
+        llm = ChatOllama(**kwargs)
+        if tools:
+            llm = llm.bind_tools(tools)
+
+        gathered = None
+        async for chunk in llm.astream(messages):
+            gathered = chunk if gathered is None else gathered + chunk
+            text = chunk.content if isinstance(chunk.content, str) else ""
+            if text:
+                await ws.send(json.dumps({
+                    "v": 1, "id": fid, "type": "model_token", "content": text,
+                }))
+
+        tool_calls = list(getattr(gathered, "tool_calls", []) or []) if gathered else []
+        usage = dict(getattr(gathered, "usage_metadata", None) or {}) if gathered else {}
+        await ws.send(json.dumps({
+            "v": 1, "id": fid, "type": "model_result",
+            "tool_calls": tool_calls, "usage": usage,
+        }))
+    except Exception as exc:
+        logger.warning("model_generate failed: %s", exc)
+        await _error(str(exc))
+
+
 async def _handle_frame(
     frame: dict,
     workdir: Path,
@@ -124,11 +206,16 @@ async def _handle_frame(
             "workdir": str(workdir),
             "local_skills": _read_local_skills(workdir),
             "local_memory": _read_local_memory(workdir),
+            "ollama": await _probe_ollama(),
         }
         await ws.send(json.dumps(reply))
         on_status("info", f"Connected. Workdir: {workdir}")
         return
 
+    if ftype == "model_generate":
+        await _handle_model_generate(frame, ws, on_status)
+        return
+
     if ftype == "ping":
         await ws.send(json.dumps({"v": 1, "id": fid, "type": "pong", "ts": time.time()}))
         return
@@ -176,15 +263,18 @@ async def _handle_frame(
 
         try:
             async with asyncio.timeout(timeout):
-                async for raw_line in proc.stdout:
-                    chunk = raw_line.decode("utf-8", errors="replace")
+                # Read in chunks rather than lines so partial-line output
+                # (e.g. interactive prompts like "Enter verification code: "
+                # that have no trailing newline) is forwarded immediately.
+                while True:
+                    chunk_bytes = await proc.stdout.read(4096)
+                    if not chunk_bytes:
+                        break
+                    chunk = chunk_bytes.decode("utf-8", errors="replace")
                     chunks.append(chunk)
                     total_bytes += len(chunk)
                     if on_output and fid:
                         on_output(fid, chunk)
-                    # Forward chunk to server — server may show it in the agent
-                    # trace or buffer it; either way the agent gets the full
-                    # execute_result below.
                     try:
                         await ws.send(json.dumps({
                             "v": 1, "id": fid, "type": "execute_output",

{virtuai_cli-0.8.6 → virtuai_cli-0.8.8}/src/virtuai_cli/security.py

@@ -65,24 +65,35 @@ _PASS_THROUGH_ENV = {
     # Some build tools need these
     "USER", "LOGNAME",
     "XDG_RUNTIME_DIR",
+    # GCP / Cloud SDK — needed for gcloud auth and ADC to work
+    "CLOUDSDK_CONFIG",
+    "GOOGLE_APPLICATION_CREDENTIALS",
+    "GOOGLE_CLOUD_PROJECT",
+    "GCLOUD_PROJECT",
+    "GOOGLE_CLOUD_QUOTA_PROJECT",
 }
 
-_VIRTUAI_ENV_PREFIX = "VIRTUAI_"
+# Env var prefixes whose entire namespace is passed through
+_PASS_THROUGH_PREFIXES = ("VIRTUAI_", "GOOGLE_", "GCLOUD_", "CLOUDSDK_", "AWS_", "AZURE_")
 
 
 def scrub_env(workdir: Path, extra_allow: list[str] | None = None) -> dict[str, str]:
-    """Build a clean environment: allowlist + VIRTUAI_ vars + user opt-ins."""
+    """Build a clean environment: allowlist + cloud-tool prefixes + user opt-ins.
+
+    HOME is intentionally kept as-is so local tools (gcloud, aws, git, npm …)
+    can find their credentials and config in the user's real home directory.
+    The agent runs on the user's own machine with their explicit permission,
+    so restricting HOME would only break authentication without adding security.
+    REAL_HOME is also set as a convenience alias for scripts that need it.
+    """
     allowed = set(_PASS_THROUGH_ENV)
     if extra_allow:
         allowed.update(extra_allow)
 
     env: dict[str, str] = {}
     for key, value in os.environ.items():
-        if key in allowed or key.startswith(_VIRTUAI_ENV_PREFIX):
+        if key in allowed or any(key.startswith(p) for p in _PASS_THROUGH_PREFIXES):
             env[key] = value
 
-    # Keep REAL_HOME so the agent can resolve user paths, but override HOME
-    # so tools that write to ~/.cache/~/.config don't escape the workdir
     env["REAL_HOME"] = env.get("HOME", os.path.expanduser("~"))
-    env["HOME"] = str(workdir)
     return env

{virtuai_cli-0.8.6 → virtuai_cli-0.8.8}/src/virtuai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtuai-cli
-Version: 0.8.6
+Version: 0.8.8
 Summary: Run VirtuAI deep agents on your local machine
 Author-email: uCloudStore <lmoreno@ucloudstore.com>
 License: Proprietary
@@ -20,6 +20,8 @@ Requires-Dist: keyring>=25.0
 Requires-Dist: typer>=0.12
 Requires-Dist: rich>=13.0
 Requires-Dist: textual>=0.86
+Provides-Extra: local
+Requires-Dist: langchain-ollama>=0.2; extra == "local"
 
 # VirtuAI CLI
 

{virtuai_cli-0.8.6 → virtuai_cli-0.8.8}/src/virtuai_cli.egg-info/requires.txt

@@ -6,3 +6,6 @@ keyring>=25.0
 typer>=0.12
 rich>=13.0
 textual>=0.86
+
+[local]
+langchain-ollama>=0.2