voidx 1.0.0__py3-none-any.whl

voidx/agent/graph_components/compaction.py

@@ -0,0 +1,268 @@
+"""Context compaction methods for the agent graph."""
+
+from __future__ import annotations
+
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage, ToolMessage
+
+from voidx.agent.graph_components.runtime import console, ui
+from voidx.agent.graph_components.streaming import extract_text, stream_llm
+from voidx.llm.provider import resolve_protocol
+from voidx.llm.usage import estimate_context_tokens, estimate_message_tokens, extract_token_usage
+from voidx.memory.context_frames import save_context_frame_from_messages
+from voidx.ui.console import StreamingRenderer
+from voidx.ui.dock import dock
+from voidx.ui.events import StatusFinished, StatusUpdated, ui_events
+
+
+class GraphCompactionMixin:
+    async def _maybe_compact(
+        self,
+        messages: list,
+        session_msgs: list,
+        *,
+        force: bool = False,
+        ask: bool = True,
+    ) -> tuple[list | None, str | None]:
+        """Check overflow and compact if needed."""
+        total_tokens = estimate_context_tokens(messages, self.config.model.model)
+        tokens = {"total": total_tokens, "input": total_tokens, "output": 0, "reasoning": 0}
+
+        if not force and not self._compaction.is_overflow(tokens):
+            return None, None
+
+        if not force and ask and getattr(self.config, "ask_compact", False):
+            should_compact = await self._ask_compact(total_tokens)
+            if not should_compact:
+                if dock.active and ui_events.is_running:
+                    await ui_events.emit(StatusFinished(
+                        status_id="compaction",
+                        label="Compaction skipped",
+                        remove=False,
+                    ))
+                else:
+                    ui.print("[dim]Compaction skipped[/dim]")
+                return None, None
+
+        if dock.active and ui_events.is_running:
+            await ui_events.emit(StatusUpdated(
+                status_id="compaction",
+                label="Compacting context",
+                detail=(
+                    f"{total_tokens} tokens exceed the active context budget"
+                    if not force
+                    else f"manual compaction of {len(messages)} messages"
+                ),
+                stage="compacting",
+            ))
+        else:
+            ui.print(
+                "[yellow]Context overflow — compacting...[/yellow]"
+                if not force
+                else "[yellow]Compacting context...[/yellow]"
+            )
+
+        head_msgs, tail_id = self._compaction.select(messages)
+
+        if not head_msgs or not tail_id:
+            # Hard fallback: keep only last 6 messages
+            keep = min(6, len(messages))
+            if dock.active and ui_events.is_running:
+                await ui_events.emit(StatusUpdated(
+                    status_id="compaction",
+                    label="Compacting context",
+                    detail=f"fallback truncation, keeping last {keep} messages",
+                    stage="compacting",
+                ))
+                await ui_events.emit(StatusFinished(
+                    status_id="compaction",
+                    label=f"Compaction fallback kept last {keep} messages",
+                    remove=False,
+                ))
+            else:
+                ui.print(f"[dim]Aggressive truncation: keeping last {keep} messages[/dim]")
+            # Remove old messages, keep system + last N
+            system_msgs = [m for m in messages if isinstance(m, SystemMessage)]
+            other_msgs = [m for m in messages if not isinstance(m, SystemMessage)]
+            messages.clear()
+            messages.extend(system_msgs)
+            messages.extend(other_msgs[-keep:])
+            return messages[:max(0, len(messages) - keep)], None
+
+        # Run compaction agent
+        try:
+            if dock.active and ui_events.is_running:
+                await ui_events.emit(StatusUpdated(
+                    status_id="compaction",
+                    label="Compacting context",
+                    detail=f"summarizing {len(head_msgs)} old messages",
+                    stage="compacting",
+                ))
+            previous_summary = getattr(self, "_compaction_summary", "") or None
+            summary = await self._run_compaction_agent(head_msgs, previous_summary)
+        except Exception as e:
+            if dock.active and ui_events.is_running:
+                await ui_events.emit(StatusUpdated(
+                    status_id="compaction",
+                    label="Compaction agent failed",
+                    detail=f"{e}; falling back to truncation",
+                    stage="compacting",
+                ))
+            else:
+                ui.print(f"[dim]Compaction agent failed ({e}) — aggressive truncation[/dim]")
+            keep = min(6, len(messages))
+            system_msgs = [m for m in messages if isinstance(m, SystemMessage)]
+            other_msgs = [m for m in messages if not isinstance(m, SystemMessage)]
+            messages.clear()
+            messages.extend(system_msgs)
+            messages.extend(other_msgs[-keep:])
+            if dock.active and ui_events.is_running:
+                await ui_events.emit(StatusFinished(
+                    status_id="compaction",
+                    label=f"Compaction fallback kept last {keep} messages",
+                    ok=False,
+                    remove=False,
+                ))
+            return messages[:max(0, len(messages) - keep)], None
+
+        if summary:
+            keep_from = len(head_msgs)
+            tail_msgs = messages[keep_from:]
+            messages.clear()
+            messages.extend(tail_msgs)
+            self._pending_summary = summary
+            self._compaction_summary = summary
+            self._compaction.compaction_count += 1
+            await self._persist_compaction(head_msgs)
+            if dock.active and ui_events.is_running:
+                await ui_events.emit(StatusFinished(
+                    status_id="compaction",
+                    label=f"Compacted {len(head_msgs)} messages into summary",
+                    remove=False,
+                ))
+            else:
+                ui.print(f"[dim]Compacted: {len(head_msgs)} messages → summary[/dim]")
+        elif dock.active and ui_events.is_running:
+            await ui_events.emit(StatusFinished(
+                status_id="compaction",
+                label="Compaction produced no summary",
+                ok=False,
+                remove=False,
+            ))
+            return None, None
+        else:
+            return None, None
+
+        return head_msgs, tail_id
+
+    async def _ask_compact(self, total_tokens: int) -> bool:
+        choices = [
+            ("Compact", "compact", "Summarize older context and continue"),
+            ("Skip once", "skip", "Continue without compacting this turn"),
+        ]
+        app = getattr(self, "_app", None)
+        if app:
+            choice = await app.ask_choice("Compact context?", choices)
+            return choice == "compact"
+        ui.print("")
+        ui.print(f"  [yellow]Context is large ({total_tokens} tokens); compacting automatically.[/yellow]")
+        return True
+
+    async def _persist_compaction(self, head_messages: list) -> None:
+        if getattr(self, "_session", None) is None:
+            return
+        if hasattr(self, "_persist_runtime_state"):
+            await self._persist_runtime_state()
+        last_message_id = _max_persisted_message_id(head_messages)
+        if last_message_id is None:
+            return
+        from voidx.memory.session import delete_messages_through
+
+        await delete_messages_through(self._session.id, last_message_id)
+
+    async def _compact_session_history(self, *, force: bool = True) -> bool:
+        if getattr(self, "_session", None) is None:
+            ui.print("[dim]No active session to compact.[/dim]")
+            return False
+
+        from voidx.agent.attachments import parse_structured_content
+        from voidx.memory.session import load_messages
+
+        rows = await load_messages(self._session.id)
+        messages = []
+        for row in rows:
+            msg_id = str(row.id) if row.id is not None else None
+            if row.role == "system":
+                messages.append(SystemMessage(content=row.content, id=msg_id))
+            elif row.role == "user":
+                messages.append(HumanMessage(
+                    content=parse_structured_content(row.content, row.content_format),
+                    id=msg_id,
+                ))
+            elif row.role == "assistant":
+                messages.append(AIMessage(
+                    content=parse_structured_content(row.content, row.content_format),
+                    tool_calls=row.tool_calls or [],
+                    id=msg_id,
+                ))
+            elif row.role == "tool":
+                messages.append(ToolMessage(
+                    content=row.content,
+                    tool_call_id=row.tool_call_id or "",
+                    id=msg_id,
+                ))
+
+        head, _tail_id = await self._maybe_compact(messages, rows, force=force, ask=False)
+        return bool(head)
+
+    async def _run_compaction_agent(self, head_messages: list, previous_summary: str | None) -> str | None:
+        """Run the compaction agent to generate a structured summary."""
+        from voidx.agent.agents import COMPACTION_PROMPT
+
+        if self.model is None:
+            return None
+
+        prompt = self._compaction.build_prompt(head_messages, previous_summary)
+        renderer = StreamingRenderer(console, debug=self._debug, stream_to_dock=False)
+
+        messages = [SystemMessage(content=COMPACTION_PROMPT)]
+        messages.append(HumanMessage(content=prompt))
+
+        # Use a cheap/fast call for compaction — no tools
+        context_tokens = estimate_context_tokens(messages, self.config.model.model)
+        self._usage_stats.update_context(context_tokens)
+        if self._session is not None:
+            await save_context_frame_from_messages(
+                session_id=self._session.id,
+                frame_kind="compaction",
+                agent_role="compaction",
+                provider=self.config.model.provider,
+                model=self.config.model.model,
+                messages=messages,
+                token_estimate=context_tokens,
+                metadata={
+                    "head_message_count": len(head_messages),
+                    "has_previous_summary": previous_summary is not None,
+                },
+            )
+        assistant_msg = await stream_llm(self.model, messages, renderer, resolve_protocol(self.config.model))
+        self._usage_stats.record_call(
+            extract_token_usage(assistant_msg),
+            fallback_input_tokens=context_tokens,
+            fallback_output_tokens=estimate_message_tokens(assistant_msg, self.config.model.model),
+            messages=messages,
+            model=self.config.model.model,
+            cache_key=f"{self.config.model.provider}/{self.config.model.model}",
+        )
+        text = extract_text(assistant_msg)
+        return text if text else None
+
+
+def _max_persisted_message_id(messages: list) -> int | None:
+    ids: list[int] = []
+    for message in messages:
+        raw = getattr(message, "id", None)
+        try:
+            ids.append(int(raw))
+        except (TypeError, ValueError):
+            continue
+    return max(ids) if ids else None

voidx/agent/graph_components/permissions.py

@@ -0,0 +1,139 @@
+"""Tool permission UI adapter for the agent graph."""
+
+from __future__ import annotations
+
+from voidx.agent.graph_components.runtime import ui
+from voidx.permission.engine import (
+    PermissionContext,
+    authorize_tool_call,
+    build_pattern,
+    classify_tool_call,
+)
+from voidx.ui.events import PermissionToolDetail
+
+
+class GraphPermissionMixin:
+    _needs_failure_check: dict[str, dict]
+
+    async def _authorize_tool_calls(
+        self,
+        tool_calls: list[dict],
+        agent_name: str,
+        plan_mode: bool,
+        session_id: str,
+        interaction_mode: str | None = None,
+    ) -> tuple[list[dict], list[tuple[dict, str]]]:
+        approved: list[dict] = []
+        denied: list[tuple[dict, str]] = []
+        need_ask: list[dict] = []
+
+        if not hasattr(self, '_needs_failure_check'):
+            self._needs_failure_check = {}
+
+        context = PermissionContext.from_service(
+            self._permission,
+            workspace=self._workspace,
+            interaction_mode=interaction_mode,
+            plan_mode=plan_mode,
+        )
+
+        for tc in tool_calls:
+            decision = authorize_tool_call(tc, context)
+            if decision.action == "allow":
+                approved.append(decision.tool_call)
+                if decision.failure_check:
+                    self._needs_failure_check[decision.tool_call.get("id", "")] = decision.tool_call
+            elif decision.action == "deny":
+                denied.append((decision.tool_call, decision.reason))
+            else:
+                need_ask.append(decision.tool_call)
+
+        if need_ask:
+            await self._ask_and_apply_permission(need_ask, approved, denied)
+
+        return approved, denied
+
+    async def _ask_and_apply_permission(
+        self,
+        need_ask: list[dict],
+        approved: list[dict],
+        denied: list[tuple[dict, str]],
+    ) -> None:
+        choice = await self._ask_tool_permission(need_ask)
+        if choice is None:
+            choice = "n"
+
+        if choice == "a":
+            for tc in need_ask:
+                self._permission.allow_silent(tc["name"])
+            self._notice_permission_result(f"{len(need_ask)} tools allowed for this session")
+            approved.extend(need_ask)
+        elif choice == "y":
+            self._notice_permission_result(f"{len(need_ask)} tools allowed once")
+            approved.extend(need_ask)
+        else:
+            self._notice_permission_result(f"{len(need_ask)} tools denied")
+            for tc in need_ask:
+                denied.append((tc, f"User denied: {tc['name']}"))
+
+    async def _ask_tool_permission(self, tool_calls: list[dict]) -> str | None:
+        tool_list = ", ".join(t["name"] for t in tool_calls)
+        choices = [
+            ("Yes, always", "a", "Allow these tools for this session"),
+            ("Yes", "y", "Allow this tool use once"),
+            ("No", "n", "Deny these tools"),
+        ]
+        details = [item.model_dump() for item in self._permission_tool_details(tool_calls)]
+
+        if not self._app:
+            ui.print("")
+            ui.print(f"  [yellow]Allow tools: [bold]{tool_list}[/bold]?[/yellow]")
+
+        if self._app:
+            return await self._app.ask_choice("Allow tool use?", choices, details=details)
+        return "n"
+
+    def _notice_permission_result(self, message: str) -> None:
+        if self._show_permission_output(message):
+            return
+        ui.print(f"[dim]✓ {message}[/dim]")
+
+    def _notify_tool_failure(self, tc: dict, result) -> None:
+        """Notify user when an auto-approved tool (on-failure policy) fails.
+
+        The tool was auto-allowed by the on-failure policy and then
+        actually failed.  Let the user know so they can decide whether
+        to abort or let the agent retry.
+        """
+        tool_name = tc.get("name", "unknown")
+        error_preview = str(result.output)[:200]
+        message = f"[on-failure] '{tool_name}' failed: {error_preview}"
+        if not self._show_permission_output(message):
+            ui.print(f"\n[yellow]{message}[/yellow]")
+
+    def _show_permission_output(self, message: str) -> bool:
+        app = self._app
+        if not app:
+            return False
+        show_transient = getattr(app, "show_transient_output", None)
+        if callable(show_transient):
+            show_transient(message, title="Permission")
+            return True
+        app.begin_command_output("Permission")
+        app.append_command_output(message)
+        return True
+
+    def _clear_failure_check(self, cid: str) -> None:
+        """Remove a tool call ID from on-failure tracking (used on success)."""
+        self._needs_failure_check.pop(cid, None)
+
+    def _permission_tool_details(self, tool_calls: list[dict]) -> list[PermissionToolDetail]:
+        details: list[PermissionToolDetail] = []
+        for call in tool_calls:
+            classified = classify_tool_call(call)
+            details.append(PermissionToolDetail(
+                name=classified.name,
+                pattern=build_pattern(classified.name, classified.args),
+                args=classified.args,
+            ))
+        return details