voidx 1.0.0__py3-none-any.whl

voidx/agent/graph_components/tool_execution.py

@@ -0,0 +1,208 @@
+"""Tool execution node for the agent graph."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+
+from langchain_core.messages import AIMessage, ToolMessage
+
+from voidx.agent.graph_components.runtime import current_parent_tool_call_id, ui
+from voidx.tools.base import ToolContext
+from voidx.ui.console import _fmt_args, _title
+from voidx.ui.dock import dock
+from voidx.ui.events import (
+    FileChangeAppended,
+    ToolFinished,
+    ToolResultAppended,
+    ToolStarted,
+    ui_events,
+)
+from voidx.ui.session_changes import session_tracker
+
+
+class GraphToolExecutionMixin:
+    async def _execute_tools(self, state) -> dict:
+        last = state["messages"][-1]
+        if not isinstance(last, AIMessage) or not last.tool_calls:
+            return {}
+
+        if dock.active and dock.current_agent is not None:
+            self._turn_node = dock.current_agent
+
+        self._current_messages = state["messages"]
+        ctx = ToolContext(
+            workspace=state.get("workspace", self._workspace),
+            file_mtimes=self._file_mtimes,
+            mcp_manager=getattr(self, "_mcp_manager", None),
+            lsp_manager=getattr(self, "_lsp_manager", None),
+            sandbox_extra_paths=self._permission.sandbox_workspace_write,
+        )
+        agent_name = state.get("agent", "orchestrator")
+        session_id = self._session.id if self._session else "default"
+        plan_mode = state.get("plan_mode", False)
+        interaction_mode = state.get("interaction_mode")
+
+        tool_calls = last.tool_calls
+        self._sub_buffers = {}
+
+        approved, denied = await self._authorize_tool_calls(
+            tool_calls,
+            agent_name=agent_name,
+            plan_mode=plan_mode,
+            session_id=session_id,
+            interaction_mode=interaction_mode,
+        )
+
+        # ── Phase 2: parallel execution of all approved tools ────────
+
+        async def execute_one(tc):
+            tid = tc["name"]
+            targs = tc.get("args", {})
+            cid = tc.get("id", "")
+
+            tool_event_id = cid or f"{tid}:{id(tc)}"
+            tool_node = None
+            if dock.active and ui_events.is_running:
+                gerund = _title(ui._TOOL_GERUND.get(tid, tid + "ing"))
+                tool_node = await ui_events.request(ToolStarted(
+                    tool_call_id=tool_event_id,
+                    tool_name=tid,
+                    label=gerund,
+                    args=_fmt_args(targs),
+                    raw_args=targs,
+                ))
+                if dock.active and dock.current_agent is not None:
+                    self._turn_node = dock.current_agent
+            elif dock.active:
+                gerund = _title(ui._TOOL_GERUND.get(tid, tid + "ing"))
+                tool_node = dock.start_tool(
+                    gerund,
+                    _fmt_args(targs),
+                    tool_call_id=tool_event_id,
+                    tool_name=tid,
+                    raw_args=targs,
+                )
+                if dock.current_agent is not None:
+                    self._turn_node = dock.current_agent
+            else:
+                ui.tool_call(tid, targs)
+
+            t0 = time.monotonic()
+            ok = True
+            try:
+                session_tracker.capture_tool_call(tid, targs, ctx.workspace, ctx.sandbox_extra_paths)
+                parent_tool_token = current_parent_tool_call_id.set(tool_event_id)
+                try:
+                    result = await self.tools.execute_tool(tid, targs, ctx)
+                finally:
+                    current_parent_tool_call_id.reset(parent_tool_token)
+                ok = self._tool_result_ok(result)
+            except Exception as e:
+                from voidx.tools.base import ToolResult
+                result = ToolResult(
+                    output=f"Tool execution error: {e}",
+                    metadata={"error": str(e)},
+                )
+                ok = False
+            elapsed = time.monotonic() - t0
+
+            # on-failure: notify user when auto-approved tool fails
+            if not ok and hasattr(self, "_needs_failure_check"):
+                failure_tc = self._needs_failure_check.get(cid, None)
+                if failure_tc and self._permission.approval_policy == "on-failure":
+                    self._notify_tool_failure(failure_tc, result)
+            elif ok and hasattr(self, "_needs_failure_check"):
+                self._clear_failure_check(cid)
+
+            if dock.active and ui_events.is_running:
+                await ui_events.emit(ToolFinished(
+                    tool_call_id=tool_event_id,
+                    label=_title(tid),
+                    elapsed=elapsed,
+                    ok=ok,
+                ))
+            elif tool_node:
+                dock.finish_tool_node(tool_node, _title(tid), elapsed, ok)
+            else:
+                ui.tool_done(tid, elapsed, ok)
+
+            # Render diff to terminal (if any)
+            if getattr(result, "diff", None) and ok:
+                session_tracker.record_diff(result.diff)
+                if dock.active and ui_events.is_running:
+                    await ui_events.emit(FileChangeAppended(
+                        tool_call_id=tool_event_id,
+                        diff_text=result.diff,
+                    ))
+                elif tool_node:
+                    dock.append_file_change(
+                        result.diff,
+                        parent=tool_node,
+                        tool_call_id=tool_event_id,
+                    )
+                else:
+                    from voidx.ui.diff import diff_stat
+                    added, removed = diff_stat(result.diff)
+                    ui.print(f"  [green]+{added}[/green] [red]−{removed}[/red]")
+                if self._debug and not tool_node:
+                    ui.diff(result.diff)
+            elif self._debug:
+                if dock.active and ui_events.is_running:
+                    await ui_events.emit(ToolResultAppended(
+                        tool_call_id=tool_event_id,
+                        text=result.output,
+                    ))
+                elif tool_node:
+                    dock.append_tool_result(
+                        result.output,
+                        parent=tool_node,
+                        tool_call_id=tool_event_id,
+                    )
+                else:
+                    ui.tool_result(result.output)
+
+            return ToolMessage(content=result.output, tool_call_id=cid)
+
+        # Run all approved tools in parallel
+        executed = await asyncio.gather(*[execute_one(tc) for tc in approved])
+
+        # Clear on-failure tracking for this batch (full logic in Phase 2)
+        if hasattr(self, "_needs_failure_check"):
+            self._needs_failure_check.clear()
+
+        if dock.active and ui_events.is_running:
+            await ui_events.drain()
+
+        # Child-agent messages are buffered by parent tool_call_id. Append them
+        # only after parent ToolMessages so parent tool_use→tool_result
+        # adjacency is preserved for ALL agent calls.
+        sub_buffers: dict[str, list] = getattr(self, "_sub_buffers", {})
+        approved_ids = [tc.get("id", "") for tc in approved]
+        extra: list = []
+        for call_id in approved_ids:
+            extra.extend(sub_buffers.get(call_id, []))
+        for call_id, messages in sub_buffers.items():
+            if call_id not in approved_ids:
+                extra.extend(messages)
+        self._sub_buffers = {}
+
+        # Denied tools get error messages
+        denied_msgs = [
+            ToolMessage(content=reason, tool_call_id=tc.get("id", ""))
+            for tc, reason in denied
+        ]
+
+        return {"messages": list(executed) + extra + denied_msgs}
+
+    @staticmethod
+    def _tool_result_ok(result) -> bool:
+        metadata = getattr(result, "metadata", {}) or {}
+        if metadata.get("error") or metadata.get("blocked") or metadata.get("timeout"):
+            return False
+        if "exit_code" in metadata:
+            try:
+                return int(metadata.get("exit_code") or 0) == 0
+            except (TypeError, ValueError):
+                return False
+        return True

voidx/agent/runtime_context.py

@@ -0,0 +1,368 @@
+"""Structured runtime context assembly for LLM calls."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from enum import Enum
+from typing import Iterable
+
+from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
+from pydantic import BaseModel, Field
+
+from voidx.config import ApprovalReviewer, Config
+
+
+class InteractionMode(str, Enum):
+    AUTO = "auto"
+    PLAN = "plan"
+    GOAL = "goal"
+
+    @classmethod
+    def parse(cls, value: str | "InteractionMode" | None) -> "InteractionMode":
+        if isinstance(value, cls):
+            return value
+        if not value:
+            return cls.AUTO
+        normalized = str(value).strip().lower()
+        for mode in cls:
+            if mode.value == normalized:
+                return mode
+        raise ValueError(f"Invalid interaction mode: {value}")
+
+    @property
+    def denies_writes(self) -> bool:
+        return self == InteractionMode.PLAN
+
+
+class TaskIntent(str, Enum):
+    CHAT = "chat"
+    INSPECT = "inspect"
+    DESIGN = "design"
+    REVIEW = "review"
+    IMPLEMENT = "implement"
+    DEBUG = "debug"
+    AMBIGUOUS = "ambiguous"
+
+
+_IMPLEMENT_HINTS = (
+    "fix", "implement", "change", "edit", "write", "refactor", "patch",
+    "apply", "do it", "go ahead", "start coding",
+    "\u4fee\u590d", "\u5b9e\u73b0", "\u4fee\u6539", "\u6539\u4e00\u4e0b",
+    "\u76f4\u63a5\u6539", "\u5f00\u59cb\u5e72", "\u5f00\u59cb\u505a",
+    "\u52a8\u624b", "\u843d\u5730", "\u7ee7\u7eed\u6539",
+    "\u7ee7\u7eed\u505a", "\u7ee7\u7eed\u5b9e\u73b0",
+    "\u7ee7\u7eed\u4fee\u590d", "\u53ef\u4ee5\u6539",
+    "\u53ef\u4ee5\u5f00\u59cb",
+)
+_DESIGN_HINTS = (
+    "design", "plan", "proposal", "approach", "architecture", "suggest",
+    "\u8bbe\u8ba1", "\u65b9\u6848", "\u5efa\u8bae", "\u600e\u4e48\u6539",
+    "\u5982\u4f55\u6539", "\u8ba8\u8bba", "\u89c4\u5212",
+)
+_INSPECT_HINTS = (
+    "look at", "inspect", "analyze", "explain", "understand", "check",
+    "what is", "why", "how does",
+    "\u770b\u770b", "\u770b\u4e00\u4e0b", "\u5206\u6790", "\u68b3\u7406",
+    "\u4e86\u89e3", "\u68c0\u67e5", "\u73b0\u72b6", "\u662f\u4ec0\u4e48",
+    "\u4e3a\u4ec0\u4e48",
+)
+_REVIEW_HINTS = ("review", "\u5ba1\u67e5", "\u590d\u6838", "\u8bc4\u5ba1")
+_DEBUG_HINTS = ("debug", "bug", "error", "traceback", "\u62a5\u9519", "\u6392\u67e5", "\u95ee\u9898")
+
+
+def infer_task_intent(text: str, interaction_mode: str | InteractionMode | None = None) -> TaskIntent:
+    mode = InteractionMode.parse(interaction_mode)
+    if mode == InteractionMode.PLAN:
+        return TaskIntent.DESIGN
+
+    normalized = text.lower()
+    if _contains_any(normalized, _IMPLEMENT_HINTS):
+        return TaskIntent.IMPLEMENT
+    if _contains_any(normalized, _REVIEW_HINTS):
+        return TaskIntent.REVIEW
+    if _contains_any(normalized, _DEBUG_HINTS):
+        return TaskIntent.DEBUG
+    if _contains_any(normalized, _DESIGN_HINTS):
+        return TaskIntent.DESIGN
+    if _contains_any(normalized, _INSPECT_HINTS):
+        return TaskIntent.INSPECT
+    return TaskIntent.CHAT
+
+
+def implementation_allowed_for_intent(intent: str | TaskIntent) -> bool:
+    return TaskIntent(intent) == TaskIntent.IMPLEMENT
+
+
+class ExecutionPolicy(BaseModel):
+    sandbox_mode: str
+    approval_policy: str
+    approval_reviewer: str = ApprovalReviewer.USER.value
+    extra_write_paths: list[str] = Field(default_factory=list)
+
+    @classmethod
+    def from_config(cls, config: Config) -> "ExecutionPolicy":
+        return cls(
+            sandbox_mode=config.sandbox_mode.value,
+            approval_policy=config.approval_policy.value,
+            approval_reviewer=config.approval_reviewer.value,
+            extra_write_paths=list(config.sandbox_workspace_write),
+        )
+
+
+class RuntimeEnvelope(BaseModel):
+    date: str
+    workspace: str
+    provider: str
+    model: str
+    interaction_mode: InteractionMode
+    permission_profile: str
+    execution_policy: ExecutionPolicy
+    agent: str
+    agent_id: int = -1
+
+
+class ContextSection(BaseModel):
+    name: str
+    content: str
+
+
+class RuntimeContext(BaseModel):
+    sections: list[ContextSection]
+    task_sections: list[ContextSection] = Field(default_factory=list)
+
+    def section_names(self) -> list[str]:
+        names = [section.name for section in self.sections]
+        names.extend(section.name for section in self.task_sections)
+        return names
+
+    def render_system(self) -> str:
+        return _render_sections(self.sections)
+
+    def render_task_context(self) -> str:
+        return _render_sections(self.task_sections)
+
+    def apply_to_messages(self, messages: list[BaseMessage]) -> None:
+        ContextCompiler(self).apply_to_messages(messages)
+
+
+class ContextCompiler:
+    """Compile structured context sections into one clean LLM message frame."""
+
+    def __init__(self, context: RuntimeContext) -> None:
+        self.context = context
+
+    def compile_messages(self, messages: list[BaseMessage]) -> list[BaseMessage]:
+        semantic_messages = [message for message in messages if not isinstance(message, SystemMessage)]
+        current_user_index = _last_user_index(semantic_messages)
+
+        prefix = SystemMessage(content=self.context.render_system())
+        task_context = self.context.render_task_context()
+        if task_context:
+            if current_user_index is None:
+                semantic_messages.append(HumanMessage(content=task_context))
+            else:
+                current = semantic_messages[current_user_index]
+                semantic_messages[current_user_index] = _prepend_task_context(current, task_context)
+
+        return [prefix, *semantic_messages]
+
+    def apply_to_messages(self, messages: list[BaseMessage]) -> None:
+        messages[:] = self.compile_messages(messages)
+
+
+class RuntimeContextBuilder:
+    def __init__(
+        self,
+        *,
+        config: Config,
+        workspace: str,
+        agent_prompt: str | None = None,
+        base_system_prompt: str | None = None,
+        role_prompt: str = "",
+        mode_prompt: str = "",
+        tool_contract: str = "",
+        agent: str,
+        interaction_mode: str | InteractionMode,
+        instructions: Iterable[str] = (),
+        skill_instructions: Iterable[str] = (),
+        active_skill_summaries: Iterable[str] = (),
+        summary: str | None = None,
+        current_user_text: str = "",
+        task_intent: str | TaskIntent | None = None,
+        implementation_allowed: bool | None = None,
+        intent_resolution_reason: str = "",
+        awaiting_implementation_approval: bool = False,
+        approved_scope: str = "",
+        goal: str = "",
+        goal_phase: str = "",
+        goal_status: str = "",
+        goal_turn_count: int = 0,
+        agent_id: int = -1,
+    ) -> None:
+        self.config = config
+        self.workspace = workspace
+        self.base_system_prompt = (base_system_prompt or agent_prompt or "").strip()
+        self.role_prompt = role_prompt.strip()
+        self.mode_prompt = mode_prompt.strip()
+        self.tool_contract = tool_contract.strip()
+        self.agent = agent
+        self.interaction_mode = InteractionMode.parse(interaction_mode)
+        self.instructions = [item for item in instructions if item.strip()]
+        self.skill_instructions = [item for item in skill_instructions if item.strip()]
+        self.active_skill_summaries = [item for item in active_skill_summaries if item.strip()]
+        self.summary = summary.strip() if summary else ""
+        self.current_user_text = current_user_text.strip()
+        self.task_intent = (
+            TaskIntent(task_intent)
+            if task_intent is not None
+            else infer_task_intent(self.current_user_text, self.interaction_mode)
+        )
+        self.implementation_allowed = (
+            implementation_allowed
+            if implementation_allowed is not None
+            else implementation_allowed_for_intent(self.task_intent)
+        )
+        self.intent_resolution_reason = intent_resolution_reason.strip()
+        self.awaiting_implementation_approval = awaiting_implementation_approval
+        self.approved_scope = approved_scope.strip()
+        self.goal = goal.strip()
+        self.goal_phase = goal_phase.strip()
+        self.goal_status = goal_status.strip()
+        self.goal_turn_count = goal_turn_count
+        self.agent_id = agent_id
+
+    def build(self) -> RuntimeContext:
+        date_str = datetime.now().astimezone().strftime("%Y-%m-%d %H:%M %Z")
+        envelope = RuntimeEnvelope(
+            date=date_str,
+            workspace=self.workspace,
+            provider=self.config.model.provider,
+            model=self.config.model.model,
+            interaction_mode=self.interaction_mode,
+            permission_profile=self.config.permission_mode.value,
+            execution_policy=ExecutionPolicy.from_config(self.config),
+            agent=self.agent,
+            agent_id=self.agent_id,
+        )
+
+        sections = [
+            ContextSection(name="Base System", content=self.base_system_prompt),
+        ]
+        if self.role_prompt:
+            sections.append(ContextSection(name="Role Prompt", content=self.role_prompt))
+        if self.mode_prompt:
+            sections.append(ContextSection(name="Mode Prompt", content=self.mode_prompt))
+        if self.tool_contract:
+            sections.append(ContextSection(name="Tool Contract", content=self.tool_contract))
+        sections.extend([
+            ContextSection(name="Workspace Facts", content=f"- Current workspace: {self.workspace}"),
+        ])
+
+        if self.instructions:
+            sections.append(ContextSection(
+                name="Project Facts",
+                content="\n\n".join(self.instructions),
+            ))
+        if self.summary:
+            sections.append(ContextSection(
+                name="Long Summary",
+                content=self.summary,
+            ))
+
+        sections.append(ContextSection(name="Current Date", content=date_str))
+        sections.append(ContextSection(name="Runtime State", content=_render_envelope(envelope)))
+
+        task_sections = [
+            ContextSection(name="Recent Messages", content="- Preserved as native conversation messages above."),
+        ]
+        if self.skill_instructions:
+            task_sections.append(ContextSection(
+                name="Active Skills",
+                content="\n\n".join(self.skill_instructions),
+            ))
+        task_sections.append(ContextSection(
+            name="Current Task State",
+            content=self._current_task_state(),
+        ))
+
+        return RuntimeContext(sections=sections, task_sections=task_sections)
+
+    def _current_task_state(self) -> str:
+        lines = [
+            f"- Mode: {self.interaction_mode.value}",
+            f"- Intent: {self.task_intent.value}",
+            f"- Awaiting implementation approval: {str(self.awaiting_implementation_approval).lower()}",
+            f"- Agent: {self.agent}",
+            f"- Agent ID: {self.agent_id}",
+        ]
+        if self.active_skill_summaries:
+            lines.append(f"- Active workflow skills: {'; '.join(self.active_skill_summaries)}")
+        if self.intent_resolution_reason:
+            lines.append(f"- Intent resolution: {self.intent_resolution_reason}")
+        if self.approved_scope:
+            lines.append(f"- Approved scope: {self.approved_scope}")
+        if self.interaction_mode == InteractionMode.GOAL:
+            lines.append("- Goal mode: true")
+            lines.append(f"- Goal: {self.goal or 'not set'}")
+            lines.append(f"- Goal phase: {self.goal_phase or 'clarify'}")
+            lines.append(f"- Goal status: {self.goal_status or 'idle'}")
+            lines.append(f"- Goal turn count: {self.goal_turn_count}")
+        if self.current_user_text:
+            first_line = self.current_user_text.splitlines()[0][:160]
+            lines.append(f"- Latest user request: {first_line}")
+        if self.interaction_mode == InteractionMode.PLAN:
+            lines.append("- Constraint: plan mode blocks write/edit/lsp_format, write-capable bash, and implement delegation.")
+        elif self.interaction_mode == InteractionMode.GOAL:
+            lines.append("- Constraint: goal mode should keep work scoped to the current user goal and task state.")
+        lines.append("- Permission gate: tool calls are governed by the current permission mode, sandbox, and interaction mode.")
+        return "\n".join(lines)
+
+
+def _render_sections(sections: list[ContextSection]) -> str:
+    parts = ["VOIDX_RUNTIME_CONTEXT"]
+    for section in sections:
+        if not section.content.strip():
+            continue
+        parts.append(f"## {section.name}\n{section.content.strip()}")
+    return "\n\n".join(parts)
+
+
+def _render_envelope(envelope: RuntimeEnvelope) -> str:
+    policy = envelope.execution_policy
+    lines = [
+        f"- Workspace: {envelope.workspace}",
+        f"- Model: {envelope.provider}/{envelope.model}",
+        f"- Interaction mode: {envelope.interaction_mode.value}",
+        f"- Permission profile: {envelope.permission_profile}",
+        f"- Sandbox: {policy.sandbox_mode}",
+        f"- Approval policy: {policy.approval_policy}",
+        f"- Approval reviewer: {policy.approval_reviewer}",
+        f"- Agent: {envelope.agent}",
+        f"- Agent ID: {envelope.agent_id}",
+    ]
+    if policy.extra_write_paths:
+        lines.append(f"- Extra write paths: {', '.join(policy.extra_write_paths)}")
+    return "\n".join(lines)
+
+
+def _last_user_index(messages: list[BaseMessage]) -> int | None:
+    for index in range(len(messages) - 1, -1, -1):
+        if isinstance(messages[index], HumanMessage):
+            return index
+    return None
+
+
+def _prepend_task_context(message: BaseMessage, task_context: str) -> BaseMessage:
+    content = message.content
+    header = f"{task_context}\n\n## User Message"
+    if isinstance(content, str):
+        new_content = f"{header}\n{content}"
+    elif isinstance(content, list):
+        new_content = [{"type": "text", "text": header}, *content]
+    else:
+        new_content = f"{header}\n{content}"
+    return message.model_copy(update={"content": new_content})
+
+
+def _contains_any(text: str, hints: tuple[str, ...]) -> bool:
+    return any(hint in text for hint in hints)