deer-agent-framework 0.2a1__tar.gz → 0.2.3__tar.gz

{deer_agent_framework-0.2a1/deer_agent_framework.egg-info → deer_agent_framework-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deer-agent-framework
-Version: 0.2a1
+Version: 0.2.3
 Summary: DEER - Deterministic Executable Engine for Runtime-agents
 Author: Yeison
 License: BSD-2-Clause

{deer_agent_framework-0.2a1/deer/builtins/agents → deer_agent_framework-0.2.3/deer/builtins_agents}/__init__.py

@@ -1,6 +1,6 @@
 import os
 
-available_agents = {
+agents = {
     "python_architect": os.path.join(os.path.dirname(__file__), "python_architect.py"),
     "operating_system": os.path.join(os.path.dirname(__file__), "operating_system.py"),
 }

{deer_agent_framework-0.2a1/deer/builtins/agents → deer_agent_framework-0.2.3/deer/builtins_agents}/operating_system.py

@@ -15,7 +15,7 @@ registry = ToolRegistry(Preset.SYSTEM_ADMIN | {HTTPClient})
 working_dir = get_path_from_parser() or Path.cwd()
 
 agent = DeterministicAgent(
-    description="OS Agent",
+    description="Advanced OS Agent for secure system management.",
     identity=(
         "You are a capable Operating System Agent. "
         "Your goal is to assist the user by managing the system, executing tasks, and solving problems efficiently. "

{deer_agent_framework-0.2a1 → deer_agent_framework-0.2.3}/deer/cli/main.py

@@ -1,13 +1,13 @@
 from rich.text import Text
 from deer.utils.console import console, error, info
-from deer.builtins.agents import available_agents
+from deer.builtins_agents import agents
 import importlib.util
 import sys
 import logging
 
 from .parser import drivers_parser
 
-logger = logging.getLogger("DEER")
+logger = logging.getLogger(f"DEER.{__name__}")
 
 
 def title():
@@ -28,13 +28,13 @@ def title():
 def agents_list():
     console.print()
     console.print("[bold]Available agents[/bold]")
-    for name in available_agents:
+    for name in agents:
         console.print(f"  • [green]{name}[/green]")
     console.print()
 
 
 def example():
-    console.print(f"[dim]Example:[/dim] deer {list(available_agents.keys())[0]}")
+    console.print(f"[dim]Example:[/dim] deer {list(agents.keys())[0]}")
 
 
 def run_agent_in_process(agent_path, backend=None, model=None):
@@ -64,11 +64,9 @@ def main():
 
     if selected_agent := args.agent:
 
-        if selected_agent in available_agents:
+        if selected_agent in agents:
             info(f"Launching agent '{selected_agent}'")
-            run_agent_in_process(
-                available_agents[selected_agent], args.backend, args.model
-            )
+            run_agent_in_process(agents[selected_agent], args.backend, args.model)
             sys.exit(0)
 
         error(f"Unknown agent '{selected_agent}'")

deer_agent_framework-0.2.3/deer/cli/repl.py

@@ -0,0 +1,368 @@
+import sys
+import pickle
+import logging
+import subprocess
+
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.table import Table
+from rich.text import Text
+from prompt_toolkit import prompt, PromptSession
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.history import InMemoryHistory
+from prompt_toolkit.completion import Completer, WordCompleter
+
+from deer.core import DeterministicAgent
+from deer import __version__
+
+logger = logging.getLogger(f"DEER.{__name__}")
+
+COMMANDS = {
+    "/tools": "Show tools and capabilities",
+    "/clear": "Clear the console and reset the session",
+    "/exit": "Terminate the session",
+    "/rollback": "Revert the system to the last stable state",
+    "/trace": "Display the detailed execution trace and variable resolution of the last plan.",
+    "/history": "Display the history of messages and commands",
+    "/clearhistory": "Purge all session history and reset memory state.",
+    # "/vhistory": "Display the history of verifier messages and commands",
+    "/infocontext": "Displays context memory usage information.",
+    "/loadcontext": "Restore a saved session context",
+    "/savecontext": "Save the current session context",
+}
+
+WELCOME_MESSAGE = """
+# DEER - Deterministic Executable Engine for Runtime Agents - v{version}
+
+An LLM agent orchestration framework built for:  
+- Strict runtime control
+- Enforced tool contracts
+- Full execution traceability
+- Guaranteed reproducibility
+
+## Runtime Pipeline
+
+1. Plan      → Generate a structured execution strategy
+2. Validate  → Verify contracts, dependencies, and safety
+3. Execute   → Run approved tools and workflows
+4. Verify    → Validate outputs against expected objectives
+
+## System Guarantees
+
+- Deterministic execution flow
+- Typed tool interfaces
+- Structured validation layers
+- Full execution traceability
+- Backend-governed orchestration
+
+## Commands
+
+{commands}
+
+## System Escapes
+
+- `!<command>` → Execute an OS shell command (e.g., `!ls -la` or `!pwd`)
+
+## Shortcuts
+
+- `Tab`        → Auto-complete commands and navigate suggestions
+- `Ctrl+C`     → Stop processing the current task
+"""
+
+
+class SmartCommandCompleter(Completer):
+    def __init__(self, commands):
+        self.base_completer = WordCompleter(commands, ignore_case=False)
+
+    def get_completions(self, document, complete_event):
+        word_before_cursor = document.get_word_before_cursor()
+        if not word_before_cursor:
+            return []
+        return self.base_completer.get_completions(document, complete_event)
+
+
+class AgentREPL:
+
+    def __init__(self, agent: DeterministicAgent):
+        self.agent = agent
+
+        self.prompt_history: InMemoryHistory
+        self.load_prompt_history()
+
+        self.console = Console()
+
+    @property
+    def completer(self):
+        internal_commands = list(COMMANDS.keys())
+        return SmartCommandCompleter(internal_commands)
+
+    def load_prompt_history(self):
+        history_file = self.agent.agent_dir / "prompt_history"
+
+        if not history_file.exists():
+            self.prompt_history = InMemoryHistory()
+            return
+
+        with open(history_file, "rb") as f:
+            self.prompt_history = pickle.load(f)
+        return
+
+    def save_prompt_history(self):
+        history_file = self.agent.agent_dir / "prompt_history"
+        with open(history_file, "wb") as f:
+            pickle.dump(self.prompt_history, f)
+
+    def clear_history(self):
+        self.history = []
+        self.trace = []
+
+    def pretty_print(self, out: str):
+        self.console.print(Markdown(out))
+
+    def show_identity(self):
+        self.pretty_print(
+            f">**Agent Profile**  \n"
+            f"*{self.agent.description}*  \n"
+            f"root: {self.agent.tool_registry.jail_path}  \n"
+            f"{self.agent.driver}: {self.agent.driver.model_name}  \n"
+        )
+        print("")
+
+    def show_welcome(self):
+        commands_formated = ""
+        for command in COMMANDS:
+            commands_formated += (
+                f"- {('`'+command+'`').ljust(12, ' ')} → {COMMANDS[command]}\n "
+            )
+
+        self.console.clear()
+        self.pretty_print(
+            WELCOME_MESSAGE.format(version=__version__, commands=commands_formated)
+        )
+        self.show_identity()
+
+    def run_command(self, command):
+        match command:
+            case "/exit":
+                self.agent.persist_state()
+                self.console.print(
+                    "[dim]Context state persisted to disk.[/dim]\n",
+                    Markdown("----"),
+                )
+                sys.exit(0)
+
+            case "/clear":
+                self.console.clear()
+                self.show_identity()
+                self.console.print(
+                    "[dim]Console buffer cleared. Session state persists. Use /clearhistory for a full purge.[/dim]\n",
+                )
+
+            case "/clearhistory":
+                self.clear_history()
+                self.console.clear()
+                self.agent.clear_agent_history()
+                self.agent.clear_traces()
+                self.agent.persist_state()
+                self.show_identity()
+                self.console.print(
+                    "[dim]Session history purged. Memory state reset.[/dim]\n",
+                )
+
+            case "/tools":
+                tools_description = self.agent.tool_registry.describe()
+                self.console.print(
+                    Markdown(tools_description),
+                    "\n",
+                    f"[dim]Tool registry: {len(self.agent.tool_registry._tools)} modules active.[/dim]\n",
+                    f"[dim]Registry description payload: {self.agent.format_bytes(len(tools_description))}[/dim]\n",
+                    sep="",
+                )
+
+            case "/rollback":
+                self.console.print(
+                    "[dim][bold]Rollback executed.[/bold] System reverted to the last stable state.[/dim]\n",
+                )
+
+            case "/trace":
+                trace = self.agent.traces["solution"]
+                for i, step in enumerate(trace):
+                    self.console.print(f"[bold yellow]Trace {i+1}:[/bold yellow]")
+                    print(f"{step}\n")
+
+            case "/history":
+                for i, chat in enumerate(self.agent.agent_history[1:]):
+                    self.console.print(f"[bold yellow]Chat {i+1}:[/bold yellow]")
+                    print(f"{chat}\n")
+                self.console.print(
+                    f"[dim]Session history payload: {self.agent.format_bytes(len(str(self.agent.agent_history)))}[/dim]\n",
+                )
+
+            # case "/vhistory":
+            #     for i, chat in enumerate(self.agent.verificator_history[1:]):
+            #         self.console.print(f"[bold yellow]Chat {i+1}:[/bold yellow]")
+            #         print(f"{chat}\n")
+
+            case "/infocontext":
+                bytes = sum(len(str(item)) for item in self.agent.agent_history)
+                self.console.print(
+                    f"[dim][bold]History:[/bold] {len(self.agent.agent_history)} messages[/dim]\n",
+                    f"[dim][bold]Context size:[/bold] ~{self.agent.format_bytes(bytes)}[/dim]\n",
+                    sep="",
+                )
+
+            case "/savecontext":
+                try:
+                    self.agent.persist_state()
+                    self.console.print("[dim]Context state persisted to disk.[/dim]\n")
+                except Exception as e:
+                    self.console.print(
+                        f"[bold red]Context persistence error:[/bold red] {e}\n"
+                    )
+
+            case "/loadcontext":
+                try:
+                    self.agent.restore_state()
+                    self.console.print(
+                        "[dim]Context recovered. Session state synchronized.[/dim]\n"
+                    )
+                except Exception as e:
+                    self.console.print(
+                        f"[bold red]Context restoration error:[/bold red] {e}\n"
+                    )
+
+        self.console.print(
+            Markdown("----"),
+            end="",
+        )
+
+    def repl(self):
+        logger.setLevel(logging.CRITICAL)
+        self.show_welcome()
+        self.pretty_print(f"----")
+
+        session = PromptSession(
+            erase_when_done=True,
+            history=self.prompt_history,
+            completer=self.completer,
+            mouse_support=True,
+        )
+
+        def as_table(prompt, message="", color="cyan"):
+            table = Table.grid(expand=True)
+            table.add_column(width=len(prompt) + 1)
+            table.add_column()
+
+            table.add_row(
+                Text(prompt, style=f"bold {color}"),
+                Markdown(message),
+            )
+            return table
+
+        input_prompt = "&gt;&gt;&gt; "  # >>>
+        input_prompt_history = "USER |"
+        output_prompt_history = "DEER |"
+
+        while True:
+            try:
+                msg = session.prompt(
+                    HTML(f"<ansicyan><b>{input_prompt}</b></ansicyan>")
+                )
+                self.save_prompt_history()
+
+                if self.agent.load_context:
+                    self.agent.persist_state()
+
+            except KeyboardInterrupt:
+                continue
+            except EOFError:
+                break
+
+            msg = msg.strip()
+            if not msg:
+                continue
+
+            match msg:
+                case command if command in COMMANDS:
+                    self.console.print(
+                        as_table(f"[{command}]", color="cyan"),
+                        Text("\n"),
+                        end="",
+                    )
+                    self.run_command(command)
+
+                case command if command.startswith("!"):
+                    # Remove the '!' from the start to get only the command
+                    cmd_to_run = command[1:].strip()
+
+                    self.console.print(
+                        as_table(f"[{cmd_to_run}]", color="cyan"),
+                        Text("\n"),
+                        end="",
+                    )
+
+                    try:
+                        # Execute the command
+                        result = subprocess.run(
+                            cmd_to_run,
+                            shell=True,
+                            capture_output=True,
+                            text=True,
+                            check=True,
+                        )
+                        self.console.print(
+                            Text(result.stdout),
+                            Markdown("----"),
+                            sep="",
+                        )
+
+                    except subprocess.CalledProcessError as e:
+                        self.console.print(
+                            f"[dim]Error executing command: {e.stderr}[/dim]",
+                            Markdown("----"),
+                            sep="",
+                        )
+                    except Exception as e:
+                        self.console.print(
+                            f"[dim]An unexpected error occurred: {e}[/dim]",
+                            Markdown("----"),
+                            sep="",
+                        )
+
+                case _:
+                    if msg.startswith("/"):
+                        self.pretty_print(
+                            f"Command `{msg}` not recognized. Did you mean one of these: {list(COMMANDS)}"
+                        )
+                        continue
+                    with self.console.status(
+                        "[dim]processing request[/]",
+                        spinner="point",
+                        spinner_style="dim",
+                    ):
+                        try:
+                            self.console.print(
+                                as_table(input_prompt_history, msg),
+                                Text("\n"),
+                                end="",
+                            )
+
+                            # Call the LLM model
+                            response = self.agent.run(msg)
+
+                            self.console.print(
+                                as_table(output_prompt_history, response),
+                                Text("\n"),
+                                Markdown("----"),
+                                end="",
+                            )
+
+                        except KeyboardInterrupt:
+                            self.console.print(
+                                "[dim]Command aborted by user[/dim]\n",
+                                Markdown("----"),
+                                sep="",
+                            )
+                            continue
+                        except EOFError:
+                            break

{deer_agent_framework-0.2a1 → deer_agent_framework-0.2.3}/deer/core/agent.py

@@ -17,7 +17,7 @@ from .validator import PlanValidator
 
 import pickle
 
-logger = logging.getLogger("DEER")
+logger = logging.getLogger(f"DEER.{__name__}")
 
 
 class DeterministicAgent:
@@ -32,6 +32,7 @@ class DeterministicAgent:
         vector_memory: Optional[VectorMemory] = None,
         max_attempts: int = 3,
         enable_verification: bool = True,
+        load_context: bool = False,
     ):
 
         # Context
@@ -41,6 +42,7 @@ class DeterministicAgent:
         self.agent_dir = (working_dir / ".deer").resolve()
         self.working_dir = working_dir.resolve()
         self.enable_verification = enable_verification
+        self.contex_file = self.agent_dir / "context"
 
         # LLMDriver
         self.driver = driver
@@ -78,13 +80,18 @@ class DeterministicAgent:
         # Pipeline Executer
         self.pipeline_executor = PipelineExecutor(tool_registry=self.tool_registry)
 
-        # Agent History
-        self.agent_history: list[ChatMessage] = []
-        self.clear_agent_history()
+        self.load_context = load_context
+        if load_context:
+            self.persist_state()
 
-        # Validator History
-        self.verificator_history: list[ChatMessage] = []
-        self.clear_verificator_history()
+        else:
+            # Agent History
+            self.agent_history: list[ChatMessage] = []
+            self.clear_agent_history()
+
+            # Validator History
+            self.verificator_history: list[ChatMessage] = []
+            self.clear_verificator_history()
 
         # Traces
         self.traces: dict[Literal["solution", "verification"], list[Any]] = {}
@@ -116,6 +123,31 @@ class DeterministicAgent:
             )
         ]
 
+    def format_bytes(self, size):
+        for unit in ["B", "KB", "MB", "GB"]:
+            if size < 1024:
+                return f"{size:.1f} {unit}"
+            size /= 1024
+
+    def persist_state(self):
+        context = {
+            "agent_history": self.agent_history,
+            "verificator_history": self.verificator_history,
+        }
+        with self.contex_file.open("wb") as f:
+            pickle.dump(context, f)
+
+    def restore_state(self):
+        if not self.contex_file.exists():
+            return
+
+        with self.contex_file.open("rb") as f:
+            context = pickle.load(f)
+            self.agent_history = context.get("agent_history", self.agent_history)
+            self.verificator_history = context.get(
+                "verificator_history", self.verificator_history
+            )
+
     def save_trace(self):
         obj = {
             "tools": list(self.tool_registry.list_tools()),
@@ -222,11 +254,20 @@ class DeterministicAgent:
             trace_verification = self.run_verification(goal)
             self.save_trace_verification(trace_verification)
 
+        if (
+            not trace_solution.steps
+            and not self.enable_verification
+            and trace_solution.response
+        ):
+            # Return a response without validation when the request does not have steps
+            return trace_solution.response
+
         # Conclusion
+        # The request has steps and validation is requested
         conclusion = self.generate_conclusion(goal, trace_solution, trace_verification)
 
         if conclusion.goal_achieved:
-            # self.clear_verificator_history()
+            # The conclusion finds that the goal has been achieved
             return conclusion.user_message
         else:
             if iteration >= self.max_attempts:
@@ -267,7 +308,7 @@ class DeterministicAgent:
         goal: str,
         trace_solution: ExecutionTrace,
         trace_verification: ExecutionTrace,
-    ) -> str:
+    ) -> AgentConclusion:
 
         messages = [
             ChatMessage(

{deer_agent_framework-0.2a1 → deer_agent_framework-0.2.3}/deer/core/executor.py

@@ -4,7 +4,7 @@ from typing import Any, Dict
 from deer.tools import ToolRegistry
 from deer.models import ExecutionPlan, ExecutionTrace, StepTrace
 
-logger = logging.getLogger("DEER-LLM")
+logger = logging.getLogger(f"DEER.{__name__}")
 
 
 class PipelineExecutor:

{deer_agent_framework-0.2a1 → deer_agent_framework-0.2.3}/deer/core/planner.py

@@ -5,7 +5,7 @@ from typing import List, Dict
 from deer.tools import ToolRegistry
 from deer.models import ExecutionPlan, ChatMessage, Role
 
-logger = logging.getLogger("DEER-LLM")
+logger = logging.getLogger(f"DEER.{__name__}")
 
 
 class Planner:
@@ -55,7 +55,7 @@ class Planner:
             "Respond exclusively with the JSON object. Do NOT wrap the response in markdown code blocks or add any introductory text."
         )
 
-    def build_conclusion_prompt(self, goal, trace_solution, trace_verification):
+    def build_conclusion_prompt(self, goal, trace_solution, trace_verification) -> str:
 
         if not trace_verification:
             verification = "VERIFICATION NO NEEDED"

{deer_agent_framework-0.2a1 → deer_agent_framework-0.2.3}/deer/core/validator.py

@@ -7,7 +7,7 @@ import logging
 from deer.tools.registry import ToolRegistry
 from deer.models import ExecutionPlan
 
-logger = logging.getLogger("DEER")
+logger = logging.getLogger(f"DEER.{__name__}")
 
 
 class Rules:

{deer_agent_framework-0.2a1 → deer_agent_framework-0.2.3}/deer/drivers/base.py

@@ -10,7 +10,7 @@ from deer.models import ChatMessage
 from pydantic import BaseModel
 
 T = TypeVar("T", bound=BaseModel)
-logger = logging.getLogger("DEER-LLM")
+logger = logging.getLogger(f"DEER.{__name__}")
 
 
 class LLMDriver(ABC):
@@ -90,8 +90,10 @@ class LLMDriver(ABC):
 
     @abstractmethod
     def generate(
-        self, messages: list[ChatMessage], response_model: Optional[Type[T]] = None
-    ) -> Union[str, T]:
+        self,
+        messages: list[ChatMessage],
+        response_model: type[T] | None = None,
+    ) -> str | T:
         pass
 
     @abstractmethod
@@ -104,7 +106,7 @@ class LLMDriver(ABC):
         """
         pass
 
-    def extract_json(self, text: str) -> dict:
+    def extract_json(self, text: str) -> str:
         text = text.strip()
         text = re.sub(r"^```(?:json)?\s*", "", text)
         text = re.sub(r"^json\s*", "", text)

{deer_agent_framework-0.2a1 → deer_agent_framework-0.2.3}/deer/drivers/ollama.py

@@ -1,8 +1,8 @@
 import json
-from typing import TypeVar, Type, Optional, Union, Generator
-from pydantic import BaseModel
+from typing import Generator, TypeVar
 from .base import LLMDriver, logger
 from deer.models import ChatMessage
+from pydantic import BaseModel
 
 T = TypeVar("T", bound=BaseModel)
 
@@ -26,8 +26,10 @@ class OllamaDriver(LLMDriver):
         return "Ollama"
 
     def generate(
-        self, messages: list[ChatMessage], response_model: Optional[Type[T]] = None
-    ) -> Union[str, T]:
+        self,
+        messages: list[ChatMessage],
+        response_model: type[T] | None = None,
+    ) -> str | T:
         """
         Generates a response from Ollama.
         If response_model is provided, it forces the model to follow the schema.
@@ -72,7 +74,8 @@ class OllamaDriver(LLMDriver):
             )
 
     def generate_stream(
-        self, messages: list[dict[str, str]]
+        self,
+        messages: list[ChatMessage],
     ) -> Generator[str, None, None]:
         """
         Implementation of streaming for Ollama.

{deer_agent_framework-0.2a1 → deer_agent_framework-0.2.3}/deer/memory/vector.py

@@ -6,7 +6,7 @@ import logging
 from typing import Any, Optional, Union
 from pathlib import Path
 
-logger = logging.getLogger(__name__)
+logger = logging.getLogger(f"DEER.{__name__}")
 
 
 class VectorMemory:

{deer_agent_framework-0.2a1 → deer_agent_framework-0.2.3}/deer/models.py

@@ -26,7 +26,7 @@ class ChatMessage(BaseModel):
     content: str = Field(..., description="The actual text content of the message.")
 
     def __str__(self) -> str:
-        return f"Role: {self.role.value}\n" f"Content: {self.content}"
+        return f"Role: {self.role.value}\n" f"Content: {self.content.strip()}"
 
 
 class ToolStep(BaseModel):
@@ -87,7 +87,7 @@ class StepTrace(BaseModel):
 
     def __str__(self):
         if self.error:
-            line = f"Error: {self.error}\n"
+            line = f"\nError: {self.error}"
         else:
             line = ""
         return (
@@ -95,7 +95,7 @@ class StepTrace(BaseModel):
             f"Resolved args: {self.resolved_args}\n"
             f"Output: {self.output}\n"
             f"Status: {self.status}\n"
-            f"Execution time: {self.execution_time}\n"
+            f"Execution time: {self.execution_time}"
             f"{line}"
         )
 

{deer_agent_framework-0.2a1 → deer_agent_framework-0.2.3/deer_agent_framework.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deer-agent-framework
-Version: 0.2a1
+Version: 0.2.3
 Summary: DEER - Deterministic Executable Engine for Runtime-agents
 Author: Yeison
 License: BSD-2-Clause

{deer_agent_framework-0.2a1 → deer_agent_framework-0.2.3}/deer_agent_framework.egg-info/SOURCES.txt

@@ -3,9 +3,9 @@ README.md
 pyproject.toml
 deer/__init__.py
 deer/models.py
-deer/builtins/agents/__init__.py
-deer/builtins/agents/operating_system.py
-deer/builtins/agents/python_architect.py
+deer/builtins_agents/__init__.py
+deer/builtins_agents/operating_system.py
+deer/builtins_agents/python_architect.py
 deer/cli/__init__.py
 deer/cli/main.py
 deer/cli/parser.py

{deer_agent_framework-0.2a1 → deer_agent_framework-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deer-agent-framework"
-version = "0.2a1"
+version = "0.2.3"
 description = "DEER - Deterministic Executable Engine for Runtime-agents"
 authors = [{ name = "Yeison" }]
 license = { text = "BSD-2-Clause" }

deer_agent_framework-0.2a1/deer/cli/repl.py

@@ -1,263 +0,0 @@
-import json
-import sys
-import logging
-
-from deer.core import DeterministicAgent
-import pickle
-from prompt_toolkit import prompt
-from prompt_toolkit.formatted_text import HTML
-from prompt_toolkit.history import InMemoryHistory
-from prompt_toolkit.completion import WordCompleter
-from rich.console import Console
-from rich.markdown import Markdown
-import subprocess
-
-from prompt_toolkit.completion import Completer, WordCompleter
-
-
-from deer import __version__
-
-logger = logging.getLogger("DEER")
-
-COMMANDS = {
-    "/tools": "Show tools and capabilities",
-    "/clear": "Clear the console and reset the session",
-    "/exit": "Terminate the session",
-    "/rollback": "Revert the system to the last stable state",
-    "/trace": "Display the detailed execution trace and variable resolution of the last plan.",
-    "/history": "Display the history of messages and commands",
-    "/vhistory": "Display the history of verifier messages and commands",
-}
-
-WELCOME_MESSAGE = """
-# DEER - Deterministic Executable Engine for Runtime Agents - v{version}
-
-An LLM agent orchestration framework built for:  
-- Strict runtime control
-- Enforced tool contracts
-- Full execution traceability
-- Guaranteed reproducibility
-
-## Runtime Pipeline
-
-1. Plan      → Generate a structured execution strategy
-2. Validate  → Verify contracts, dependencies, and safety
-3. Execute   → Run approved tools and workflows
-4. Verify    → Validate outputs against expected objectives
-
-## System Guarantees
-
-- Deterministic execution flow
-- Typed tool interfaces
-- Structured validation layers
-- Full execution traceability
-- Backend-governed orchestration
-
-## Commands
-
-{commands}
-
-## System Escapes
-
-- `!<command>` → Execute an OS shell command (e.g., `!ls -la` or `!pwd`)
-
-## Shortcuts
-
-- `Tab`        → Auto-complete commands and navigate suggestions
-- `Ctrl+C`     → Stop processing the current task
-"""
-
-
-class SmartCommandCompleter(Completer):
-    def __init__(self, commands):
-        self.base_completer = WordCompleter(commands, ignore_case=False)
-
-    def get_completions(self, document, complete_event):
-        word_before_cursor = document.get_word_before_cursor()
-        if not word_before_cursor:
-            return []
-        return self.base_completer.get_completions(document, complete_event)
-
-
-class AgentREPL:
-
-    def __init__(self, agent: DeterministicAgent):
-        self.agent = agent
-
-        self.prompt_history: InMemoryHistory
-        self.load_prompt_history()
-
-        self.console = Console()
-
-    @property
-    def completer(self):
-        internal_commands = list(COMMANDS.keys())
-        return SmartCommandCompleter(internal_commands)
-
-    def load_prompt_history(self):
-        history_file = self.agent.agent_dir / "prompt_history"
-
-        if not history_file.exists():
-            self.prompt_history = InMemoryHistory()
-            return
-
-        with open(history_file, "rb") as f:
-            self.prompt_history = pickle.load(f)
-        return
-
-    def save_history(self):
-        history_file = self.agent.agent_dir / "prompt_history"
-        with open(history_file, "wb") as f:
-            pickle.dump(self.prompt_history, f)
-
-    def clear_history(self):
-        self.history = []
-        self.trace = []
-
-    def pretty_print(self, out: str):
-        self.console.print(Markdown(out))
-
-    def show_welcome(self):
-        commands_formated = ""
-        for command in COMMANDS:
-            commands_formated += (
-                f"- {('`'+command+'`').ljust(12, ' ')} → {COMMANDS[command]}\n "
-            )
-
-        self.console.clear()
-        self.pretty_print(
-            WELCOME_MESSAGE.format(version=__version__, commands=commands_formated)
-        )
-        self.pretty_print(
-            f">**Agent Profile**  \n"
-            f"*{self.agent.description}*  \n"
-            f"root: {self.agent.tool_registry.jail_path}  \n"
-            f"{self.agent.driver}: {self.agent.driver.model_name}  \n"
-        )
-        print("\n")
-
-    def run_command(self, command):
-        match command:
-            case "/exit":
-                sys.exit(0)
-
-            case "/clear":
-                self.clear_history()
-                self.console.clear()
-                self.agent.clear_agent_history()
-                self.agent.clear_traces()
-                self.pretty_print(f">**Agent Profile**  \n*{self.agent.description}*")
-                print("\n")
-
-            case "/tools":
-                self.pretty_print(self.agent.tool_registry.describe())
-                print("\n")
-
-            case "/rollback":
-                # self.state_restore()
-                self.pretty_print(
-                    "**Rollback executed.** System reverted to the last stable state."
-                )
-                print("\n")
-
-            case "/trace":
-                trace = self.agent.traces["solution"]
-                for i, step in enumerate(trace):
-                    self.console.print(f"[bold yellow]Trace {i+1}:[/bold yellow]")
-                    print(f"{step}")
-                    # self.pretty_print(str(step))
-                    print("\n")
-
-            case "/history":
-                for i, chat in enumerate(self.agent.agent_history[1:]):
-                    self.console.print(f"[bold yellow]Chat {i+1}:[/bold yellow]")
-                    print(f"{chat}")
-                    # self.pretty_print(str(chat))
-                    print("\n")
-
-            case "/vhistory":
-                for i, chat in enumerate(self.agent.verificator_history[1:]):
-                    self.console.print(f"[bold yellow]Chat {i+1}:[/bold yellow]")
-                    print(f"{chat}")
-                    # self.pretty_print(str(chat))
-                    print("\n")
-
-    def repl(self):
-        logger.setLevel(logging.CRITICAL)
-        self.show_welcome()
-
-        while True:
-            try:
-                msg = prompt(
-                    HTML("<ansicyan><b>&gt;&gt;&gt; </b></ansicyan>"),
-                    history=self.prompt_history,
-                    completer=self.completer,
-                    # multiline=True,
-                )
-                self.save_history()
-            except KeyboardInterrupt:
-                continue
-            except EOFError:
-                break
-
-            msg = msg.strip()
-            if not msg:
-                continue
-
-            match msg:
-                case command if command in COMMANDS:
-                    self.run_command(command)
-
-                case command if command.startswith("!"):
-                    # Remove the '!' from the start to get only the command
-                    cmd_to_run = command[1:].strip()
-
-                    try:
-                        # Execute the command
-                        result = subprocess.run(
-                            cmd_to_run,
-                            shell=True,
-                            capture_output=True,
-                            text=True,
-                            check=True,
-                        )
-                        print(result.stdout)
-                    except subprocess.CalledProcessError as e:
-                        print(f"Error executing command: {e.stderr}")
-                    except Exception as e:
-                        print(f"An unexpected error occurred: {e}")
-
-                case _:
-                    if msg.startswith("/"):
-                        self.pretty_print(
-                            f"Command `{msg}` not recognized. Did you mean one of these: {list(COMMANDS)}"
-                        )
-                        continue
-                    with self.console.status(
-                        "[dim]processing request[/]",
-                        spinner="point",
-                        spinner_style="dim",
-                    ):
-                        try:
-                            output = self.send(msg)
-                            self.pretty_print(f"    {output}")
-
-                            print("\n")
-                        except KeyboardInterrupt:
-                            self.console.print("[dim]Command aborted by user[/]\n")
-                            # self.state_restore()
-                            continue
-                        except EOFError:
-                            break
-
-    def send(self, message, print_chat: bool = False):
-
-        if print_chat:
-            print(f">>> {message}")
-
-        response = self.agent.run(message)
-
-        if print_chat:
-            print(f"    {response}")
-
-        return response