voidx 1.0.0__py3-none-any.whl

voidx/agent/slash_components/model.py

@@ -0,0 +1,419 @@
+"""Slash command support for /model operations."""
+
+from __future__ import annotations
+
+import asyncio
+
+from voidx.agent.slash_components.runtime import PROVIDERS, get_providers, _select_from_list, ui
+
+
+class SlashModelMixin:
+    async def _model_new(self) -> None:
+        """Interactive model configuration — create or update a named profile."""
+        from voidx.config import Profile
+        from voidx.llm.provider import create_chat_model
+
+        ui.print("[bold]Configure LLM[/bold]")
+
+        # Step 1: choose provider via arrow keys
+        providers = get_providers(self._g._settings)
+        provider_choices = providers + ["Add custom provider..."]
+        idx = await _select_from_list(self._g._app, "Provider", provider_choices)
+        if idx is None:
+            ui.print("[dim]Cancelled.[/dim]")
+            return
+        if provider_choices[idx] == "Add custom provider...":
+            new_provider = await self._prompt("Provider name")
+            if not new_provider or not new_provider.strip():
+                ui.error("Provider name is required.")
+                return
+            new_provider = new_provider.strip()
+            protocol_choices = ["openai", "anthropic"]
+            proto_idx = await _select_from_list(self._g._app, "Protocol", protocol_choices)
+            if proto_idx is None:
+                ui.print("[dim]Cancelled.[/dim]")
+                return
+            protocol = protocol_choices[proto_idx]
+            custom_base_url = await self._prompt("Base URL (optional)", default="")
+            if custom_base_url is None:
+                ui.print("[dim]Cancelled.[/dim]")
+                return
+            custom_base_url = custom_base_url.strip()
+            ui.print(f"[dim]  Custom provider: {new_provider} (protocol={protocol})[/dim]")
+        else:
+            new_provider = provider_choices[idx]
+            protocol = self._g._settings.resolve_protocol(new_provider) if self._g._settings else None
+            custom_base_url = ""
+        ui.print(f"[dim]  Provider: {new_provider}[/dim]")
+
+        # Step 2: choose model from known list or enter manually
+        from voidx.llm.catalog import list_models as list_provider_models
+        known = await list_provider_models(new_provider)
+        model_choices = known + ["Other (enter manually)"]
+        ui.print()
+        model_idx = await _select_from_list(self._g._app, "Model", model_choices)
+        if model_idx is None:
+            ui.print("[dim]Cancelled.[/dim]")
+            return
+        if model_choices[model_idx] == "Other (enter manually)":
+            new_model = await self._prompt(
+                f"Model name",
+                default=self._g.config.model.model,
+            )
+            if new_model is None:
+                ui.print("[dim]Cancelled.[/dim]")
+                return
+            if not new_model.strip():
+                ui.error("Model name is required.")
+                return
+            new_model = new_model.strip()
+        else:
+            new_model = model_choices[model_idx]
+            ui.print(f"[dim]  Model: {new_model}[/dim]")
+
+        # Step 3: API key
+        current_key = ""
+        if self._g._settings:
+            current_key = self._g._settings.resolve_api_key(new_provider) or ""
+        masked = self._mask_key(current_key) if current_key else "(not set)"
+        ui.print(f"[dim]Current: {masked}[/dim]")
+        new_key = await self._prompt("API key", default="", secret=True)
+        if new_key is None:
+            ui.print("[dim]Cancelled.[/dim]")
+            return
+        if new_key.strip():
+            api_key = new_key.strip()
+        else:
+            if self._g._settings:
+                key = self._g._settings.resolve_api_key(new_provider)
+                if not key:
+                    ui.error(
+                        f"No API key found for '{new_provider}'. Provide one now."
+                    )
+                    return
+                api_key = key
+            else:
+                return
+
+        # Step 4: build and validate
+        base_url = custom_base_url or (self._g._settings.resolve_base_url(new_provider) if self._g._settings else None)
+        test_cfg = self._g.config.model.model_copy()
+        test_cfg.provider = new_provider
+        test_cfg.model = new_model
+        test_cfg.base_url = base_url
+        test_cfg.protocol = protocol
+
+        test_model = create_chat_model(api_key, test_cfg)
+
+        ui.print()
+        ui.print(f"[dim]  Testing connection to {new_provider}/{new_model}...[/dim]")
+
+        ok, err_msg = await self._test_connection(test_model)
+        if not ok:
+            ui.error(f"Connection failed: {err_msg}")
+            ui.print("[dim]Configuration not saved. Check your API key and try again.[/dim]")
+            return
+
+        # Step 5: save profile (key = provider/model) and activate
+        profile_key = f"{new_provider}/{new_model}"
+        profile = Profile(
+            name=profile_key,
+            api_key=api_key,
+            base_url=base_url,
+            protocol=protocol,
+        )
+        env_path = self._g._settings.save_profile(profile)
+
+        self._g.config.model.provider = new_provider
+        self._g.config.model.model = new_model
+        self._g.config.model.base_url = base_url
+        self._g.config.model.protocol = protocol
+        self._sync_context_limit()
+        self._g.api_key = api_key
+        self._g.model = test_model
+
+        ui.print(f"  [cyan]{profile_key}[/cyan] [green]✓ configured[/green]")
+        ui.print(f"[dim]Saved to {env_path}[/dim]")
+
+    @staticmethod
+    async def _test_connection(model) -> tuple[bool, str]:
+        """Test an LLM connection with a minimal prompt. Returns (ok, error_msg)."""
+        from langchain_core.messages import HumanMessage
+        try:
+            resp = await model.ainvoke([HumanMessage(content="hi")])
+            if resp and getattr(resp, "content", None):
+                return True, ""
+            return False, "empty response"
+        except Exception as e:
+            msg = str(e)
+            # Extract the most useful part of the error
+            if len(msg) > 300:
+                msg = msg[:300] + "..."
+            return False, msg
+
+    @staticmethod
+    def _mask_key(key: str) -> str:
+        if len(key) <= 8:
+            return "*" * len(key)
+        return key[:4] + "****" + key[-4:]
+
+    async def _prompt(self, text: str, default: str = "", secret: bool = False) -> str | None:
+        app = getattr(self._g, "_app", None)
+        if app is not None and hasattr(app, "ask_text"):
+            return await app.ask_text(text, default=default, secret=secret)
+
+        loop = asyncio.get_event_loop()
+        result = await loop.run_in_executor(
+            None,
+            lambda: input(f"  {text}: ").strip(),
+        )
+        return result if result else default
+
+    async def _list_models(self) -> None:
+        from voidx.llm.catalog import list_models
+
+        current = f"{self._g.config.model.provider}/{self._g.config.model.model}"
+        ui.print(f"[bold]Current:[/bold] [cyan]{current}[/cyan]\n")
+
+        for provider in get_providers(self._g._settings):
+            ui.print(f"  [bold]{provider}[/bold] ", end="")
+            models = await list_models(provider)
+            if models:
+                shown = models[:8]
+                suffix = f" [dim](+{len(models) - 8} more)[/dim]" if len(models) > 8 else ""
+                ui.print(f"{'  '.join(shown)}{suffix}")
+            else:
+                ui.print("[dim](none)[/dim]")
+        ui.print()
+        ui.print("[dim]Usage: /model list|new|reasoning|test|del|switch|<name>[/dim]")
+
+    async def _model_list(self) -> None:
+        cfg = self._g.config
+        if self._g._settings is None:
+            ui.error("No Settings reference.")
+            return
+
+        current = f"{cfg.model.provider}/{cfg.model.model}"
+        ui.print(f"[bold]Current:[/bold] [cyan]{current}[/cyan]")
+
+        profiles = self._g._settings.list_profiles()
+        if not profiles:
+            ui.print("[dim]No profiles configured. Use /model new.[/dim]")
+            return
+
+        ui.print()
+        for p in profiles:
+            is_active = p.name == current
+            marker = " *" if is_active else "  "
+            masked = self._mask_key(p.api_key) if p.api_key else "(env)"
+            ui.print(f" {marker} [cyan]{p.name}[/cyan] {masked}")
+
+    # ── /model action helpers ─────────────────────────────────────────────
+
+    def _profile_names(self) -> list[str]:
+        """Return names of configured profiles."""
+        if self._g._settings is None:
+            return []
+        return [p.name for p in self._g._settings.list_profiles()]
+
+    async def _pick_or_act(self, action: str, target: str, callback) -> None:
+        """If *target* is a profile name, call callback(target).
+        Otherwise show profiles for arrow-key selection, then call callback."""
+        import sys as _sys
+
+        if target:
+            await callback(target)
+            _sys.stdout.flush()
+            return
+
+        names = self._profile_names()
+        if not names:
+            ui.print("[yellow]No profiles configured. Use /model new first.[/yellow]")
+            return
+
+        ui.print(f"[bold]{action}[/bold] — select profile (↑↓ Enter, ESC cancel):")
+        idx = await _select_from_list(self._g._app, action, names)
+        if idx is None:
+            ui.print("[dim]Cancelled.[/dim]")
+            return
+        await callback(names[idx])
+        _sys.stdout.flush()
+
+    async def _model_test(self, target: str) -> None:
+        async def _do_test(profile_name: str) -> None:
+            from voidx.llm.provider import create_chat_model
+            settings = self._g._settings
+            if settings is None:
+                ui.error("No Settings reference.")
+                return
+            profile = settings.resolve_profile(profile_name)
+            if not profile:
+                ui.error(f"Profile not found: {profile_name}")
+                return
+            cfg = self._g.config.model.model_copy()
+            cfg.provider = profile.provider
+            cfg.model = profile.model
+            cfg.base_url = profile.base_url or settings.resolve_base_url(profile.provider)
+            cfg.protocol = profile.protocol or settings.resolve_protocol(profile.provider)
+            model = create_chat_model(profile.api_key, cfg)
+            ui.print(f"[dim]Testing {profile.name} ({profile.provider}/{profile.model})...[/dim]")
+            ok, err_msg = await self._test_connection(model)
+            if ok:
+                ui.print(f"[green]✓ {profile.name} — connection successful[/green]")
+            else:
+                ui.print(f"[red]✗ {profile.name} — {err_msg}[/red]")
+
+        await self._pick_or_act("Test", target, _do_test)
+
+    async def _model_del(self, target: str) -> None:
+        async def _do_delete(profile_name: str) -> None:
+            if self._g._settings is None:
+                ui.error("No Settings reference.")
+                return
+            profile = self._g._settings.resolve_profile(profile_name)
+            if not profile:
+                ui.error(f"Profile not found: {profile_name}")
+                return
+            env_path = self._g._settings.delete_profile(profile_name)
+            was_active = (self._g.config.model.provider == profile.provider
+                          and self._g.config.model.model == profile.model)
+            if was_active:
+                self._g.model = None
+                self._g.api_key = None
+                ui.print(f"[yellow]'{profile_name}' removed. Model disconnected.[/yellow]")
+            else:
+                ui.print(f"[dim]'{profile_name}' removed.[/dim]")
+            ui.print(f"[dim]Cleaned {env_path}[/dim]")
+
+        await self._pick_or_act("Delete", target, _do_delete)
+
+    async def _model_switch(self, target: str) -> None:
+        async def _do_switch(profile_name: str) -> None:
+            from voidx.llm.provider import create_chat_model
+            settings = self._g._settings
+            if settings is None:
+                ui.error("No Settings reference.")
+                return
+            profile = settings.resolve_profile(profile_name)
+            if not profile:
+                ui.error(f"Profile not found: {profile_name}")
+                return
+            self._g.config.model.provider = profile.provider
+            self._g.config.model.model = profile.model
+            self._g.config.model.base_url = profile.base_url or settings.resolve_base_url(profile.provider)
+            self._g.config.model.protocol = profile.protocol or settings.resolve_protocol(profile.provider)
+            self._sync_context_limit()
+            self._g.api_key = profile.api_key
+            self._g.model = create_chat_model(profile.api_key, self._g.config.model)
+            settings.save_profile(profile)
+            ui.print(f"[cyan]{profile.name}[/cyan] ({profile.provider}/{profile.model}) [green]✓ switched[/green]")
+
+        await self._pick_or_act("Switch", target, _do_switch)
+
+    async def _model_reasoning(self, effort: str) -> None:
+        valid = ("off", "low", "medium", "high", "xhigh")
+
+        if effort and effort in valid:
+            new_effort = effort
+        elif not effort:
+            current = self._g.config.model.reasoning_effort or "xhigh"
+            choices = list(valid)
+            idx = await _select_from_list(self._g._app, "Select effort", choices)
+            if idx is None:
+                ui.print("[dim]Cancelled.[/dim]")
+                return
+            new_effort = choices[idx]
+        else:
+            ui.error(f"Invalid effort: '{effort}'. Use: {', '.join(valid)}")
+            return
+
+        self._g.config.model.reasoning_effort = new_effort
+        self._sync_context_limit()
+
+        if self._g.api_key:
+            from voidx.llm.provider import create_chat_model
+            self._g.model = create_chat_model(self._g.api_key, self._g.config.model)
+
+        ui.print(f"Reasoning effort: [cyan]{new_effort}[/cyan] [green]✓[/green]")
+
+    async def _switch_model(self, model_spec: str) -> None:
+        from voidx.llm.provider import create_chat_model
+        from voidx.memory.session import update_session_model
+
+        if not model_spec:
+            await self._list_models()
+            return
+
+        spec = model_spec.strip()
+
+        if " " in spec:
+            parts = spec.split(None, 1)
+            new_provider = parts[0].lower()
+            new_model = parts[1]
+        elif "/" in spec:
+            new_provider, new_model = spec.split("/", 1)
+            new_provider = new_provider.lower()
+        else:
+            new_provider = self._g.config.model.provider
+            new_model = spec
+
+        # Resolve API key for the target provider
+        if self._g._settings is None:
+            ui.error("No Settings reference available.")
+            return
+        new_key = self._g._settings.resolve_api_key(new_provider)
+        if not new_key:
+            ui.error(
+                f"No API key found for '{new_provider}'. Use /model new."
+            )
+            return
+
+        self._g.api_key = new_key
+
+        old = f"{self._g.config.model.provider}/{self._g.config.model.model}"
+        self._g.config.model.provider = new_provider
+        self._g.config.model.model = new_model
+        self._g.config.model.base_url = (
+            self._g._settings.resolve_base_url(new_provider) if self._g._settings else None
+        )
+        self._g.config.model.protocol = (
+            self._g._settings.resolve_protocol(new_provider) if self._g._settings else None
+        )
+
+        from voidx.config import Profile
+        existing = self._g._settings.resolve_profile(f"{new_provider}/{new_model}")
+        if existing:
+            self._g.config.model.base_url = existing.base_url or self._g.config.model.base_url
+            self._g.config.model.protocol = existing.protocol or self._g.config.model.protocol
+
+        self._sync_context_limit()
+
+        self._g.model = create_chat_model(self._g.api_key, self._g.config.model)
+
+        new_profile = Profile(
+            name=f"{new_provider}/{new_model}",
+            api_key=new_key,
+            base_url=self._g.config.model.base_url,
+            protocol=self._g.config.model.protocol,
+        )
+        self._g._settings.save_profile(new_profile)
+
+        if self._g._session:
+            await update_session_model(self._g._session.id, new_provider, new_model)
+
+        ui.print(f"[dim]  {old}[/dim]")
+        ui.print(f"  [cyan]→ {new_provider}/{new_model}[/cyan] [green]✓[/green]")
+
+    def _sync_context_limit(self) -> None:
+        from voidx.llm.provider import get_context_limit
+
+        limit = get_context_limit(self._g.config.model.provider)
+        stats = getattr(self._g, "_usage_stats", None)
+        if stats is not None:
+            stats.context_limit = limit
+        app = getattr(self._g, "_app", None)
+        if app is not None and hasattr(app, "status"):
+            app.status.context_limit = limit
+            app.status.provider = self._g.config.model.provider
+            app.status.model = self._g.config.model.model
+            app.status.reasoning_effort = self._g.config.model.reasoning_effort or "xhigh"

voidx/agent/slash_components/runtime.py

@@ -0,0 +1,55 @@
+"""Shared runtime helpers for slash commands."""
+
+from __future__ import annotations
+
+import sys
+
+from voidx.ui.console import VoidConsole
+
+ui = VoidConsole()
+
+_STATIC_PROVIDERS = [
+    "anthropic",
+    "openai",
+    "deepseek",
+    "openrouter",
+    "mimo",
+    "mimo-token-plan",
+    "qwen",
+    "zhipu",
+    "kimi",
+    "doubao",
+]
+
+
+def get_providers(settings=None) -> list[str]:
+    """Return providers list, merging static + custom providers from settings."""
+    base = list(_STATIC_PROVIDERS)
+    if settings:
+        for profile in settings.list_profiles():
+            if profile.provider not in base:
+                base.append(profile.provider)
+        for cp in settings.list_custom_providers():
+            name = cp["name"]
+            if name not in base:
+                base.append(name)
+    return base
+
+
+# Backward-compatible alias (static list only).
+PROVIDERS = list(_STATIC_PROVIDERS)
+
+
+def _w(text: str) -> None:
+    sys.stdout.write(text)
+    sys.stdout.flush()
+
+
+async def _select_from_list(app, prompt: str, items: list[str]) -> int | None:
+    if not app or not items:
+        return None
+    choices = [(item, str(i), "") for i, item in enumerate(items)]
+    res = await app.ask_choice(prompt, choices)
+    if res is not None:
+        return int(res)
+    return None

voidx/agent/slash_components/skills.py

@@ -0,0 +1,94 @@
+"""Slash command support for /skills operations."""
+
+from __future__ import annotations
+
+from voidx.agent.slash_components.runtime import ui
+from voidx.skills.registry import SkillRegistry
+from voidx.skills.service import SkillService
+
+
+class SlashSkillsMixin:
+    async def _skills(self, args: str) -> None:
+        parts = args.split(None, 1)
+        action = parts[0] if parts else ""
+        target = parts[1].strip() if len(parts) > 1 else ""
+
+        if action in ("", "list"):
+            self._skills_list()
+        elif action == "show":
+            self._skills_show(target)
+        elif action == "enable":
+            self._skills_set_enabled(target, True)
+        elif action == "disable":
+            self._skills_set_enabled(target, False)
+        elif action == "paths":
+            self._skills_paths()
+        else:
+            ui.error("Usage: /skills [list|show|enable|disable|paths]")
+
+    def _skill_service(self) -> SkillService:
+        selection = (
+            self._g._settings.get_skill_selection()
+            if getattr(self._g, "_settings", None) is not None
+            else None
+        )
+        return SkillService(
+            SkillRegistry(getattr(self._g, "_workspace", ".")),
+            selection=selection,
+        )
+
+    def _skills_list(self) -> None:
+        service = self._skill_service()
+        skills = service.list_skills()
+        ui.print("[bold]Skills:[/bold]")
+        if not skills:
+            ui.print("[dim]No skills found. Add SKILL.md files under ~/.voidx/skills or .voidx/skills.[/dim]")
+            return
+        for skill in skills:
+            state = "[green]enabled[/green]" if service.is_enabled(skill) else "[dim]disabled[/dim]"
+            scope = skill.meta.scope
+            desc = f" — {skill.meta.description}" if skill.meta.description else ""
+            ui.print(f"  [cyan]{skill.name}[/cyan] · {state} · [dim]{scope}[/dim]{desc}")
+        ui.print("[dim]Usage: /skills show|enable|disable|paths[/dim]")
+
+    def _skills_show(self, name: str) -> None:
+        if not name:
+            ui.error("Usage: /skills show <name>")
+            return
+        service = self._skill_service()
+        skill = service.get(name)
+        if skill is None:
+            ui.error(f"Skill not found: {name}")
+            return
+        state = "enabled" if service.is_enabled(skill) else "disabled"
+        ui.print(f"[bold]{skill.name}[/bold] [{state}]")
+        ui.print(f"[dim]{skill.path}[/dim]")
+        if skill.meta.description:
+            ui.print(skill.meta.description)
+        if skill.meta.triggers:
+            ui.print(f"[dim]Triggers: {', '.join(skill.meta.triggers)}[/dim]")
+        ui.print()
+        ui.print(skill.body or "[dim](empty skill body)[/dim]")
+
+    def _skills_set_enabled(self, name: str, enabled: bool) -> None:
+        if not name:
+            command = "enable" if enabled else "disable"
+            ui.error(f"Usage: /skills {command} <name>")
+            return
+        if getattr(self._g, "_settings", None) is None:
+            ui.error("No settings file available.")
+            return
+        service = self._skill_service()
+        if service.get(name) is None:
+            ui.error(f"Skill not found: {name}")
+            return
+        path = self._g._settings.set_skill_enabled(name, enabled)
+        state = "enabled" if enabled else "disabled"
+        ui.print(f"[dim]{name} {state}. Saved to {path}[/dim]")
+
+    def _skills_paths(self) -> None:
+        registry = SkillRegistry(getattr(self._g, "_workspace", "."))
+        ui.print("[bold]Skill paths:[/bold]")
+        ui.print(f"  bundled [dim]{registry.bundled_dir}[/dim]")
+        ui.print(f"  global  [dim]{registry.global_dir}[/dim]")
+        ui.print(f"  project [dim]{registry.project_dir}[/dim]")

voidx/agent/state.py

@@ -0,0 +1,32 @@
+"""Agent state — typed, explicit, every field has a known type."""
+
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+from langgraph.graph.message import add_messages
+from langchain_core.messages import BaseMessage
+from typing_extensions import NotRequired, TypedDict
+
+
+class AgentState(TypedDict):
+    """Complete agent state. LangGraph manages this across the graph."""
+    messages: Annotated[list[BaseMessage], add_messages]  # LangGraph auto-merge
+    workspace: str  # absolute path to working directory
+    agent: str  # current agent name (orchestrator/explore/plan/implement/review)
+    plan_mode: bool  # when True, write/edit are denied — plan→implement→review enforced
+    interaction_mode: NotRequired[str]  # auto/plan/goal
+    task_intent: NotRequired[str]  # chat/inspect/design/review/implement/debug/ambiguous
+    implementation_allowed: NotRequired[bool]  # intent hint for context, not a permission gate
+    intent_resolution_reason: NotRequired[str]
+    awaiting_implementation_approval: NotRequired[bool]
+    approved_scope: NotRequired[str]
+    goal: NotRequired[str]
+    goal_phase: NotRequired[str]
+    goal_status: NotRequired[str]
+    goal_turn_count: NotRequired[int]
+    user_message_id: NotRequired[int]
+    tool_results: dict[str, str]  # tool_call_id → result text
+    step_count: int  # current step number
+    max_steps: int  # safety limit
+    should_continue: bool  # router flag