codenaut 0.1.0__py3-none-any.whl

agent/__init__.py

@@ -0,0 +1 @@
+"""Core agent runtime package."""

agent/agent.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+import json
+from typing import AsyncGenerator, Awaitable, Callable
+from agent.events import AgentEvent, AgentEventType
+from agent.session import Session
+from client.response import StreamEventType, TokenUsage, ToolCall, ToolResultMessage
+from config.config import Config
+from prompts.system import create_loop_breaker_prompt
+from tools.base import ToolConfirmation
+from langsmith import trace
+
+class Agent:
+    def __init__(
+        self,
+        config: Config,
+        confirmation_callback: Callable[[ToolConfirmation], bool] | None = None,
+    ):
+        self.config = config
+        self.session: Session | None = Session(self.config)
+        self.session.approval_manager.confirmation_callback = confirmation_callback
+
+    async def run(self, message: str):
+        with trace(
+            name="agent.run",
+            run_type="chain",
+            inputs={"message": message},
+            metadata={"model": self.config.model_name},
+        ) as run:
+            await self.session.hook_system.trigger_before_agent(message)
+            yield AgentEvent.agent_start(message)
+            self.session.context_manager.add_user_message(message)
+
+            final_response: str | None = None
+
+            async for event in self._agentic_loop(message):
+                yield event
+
+                if event.type == AgentEventType.TEXT_COMPLETE:
+                    final_response = event.data.get("content")
+
+            # Patch the output onto the run before the span closes
+            run.end(outputs={"response": final_response})
+
+            await self.session.hook_system.trigger_after_agent(message, final_response)
+            yield AgentEvent.agent_end(final_response)
+
+    def _should_enable_tools(self, message: str) -> bool:
+        normalized = " ".join(message.lower().strip().split())
+        if not normalized:
+            return False
+
+        simple_messages = {
+            "hi",
+            "hii",
+            "hiii",
+            "hello",
+            "hey",
+            "hlo",
+            "yo",
+            "sup",
+            "thanks",
+            "thank you",
+            "ok",
+            "okay",
+        }
+
+        return normalized not in simple_messages
+
+    async def _agentic_loop(self, latest_user_message: str) -> AsyncGenerator[AgentEvent, None]:
+        max_turns = self.config.max_turns
+        enable_tools = self._should_enable_tools(latest_user_message)
+
+        for turn_num in range(max_turns):
+            self.session.increment_turn()
+            response_text = ""
+
+            # check for context overflow
+            if self.session.context_manager.needs_compression():
+                yield AgentEvent.compaction_start(
+                    self.session.context_manager.message_count
+                )
+                summary, usage = await self.session.chat_compactor.compress(
+                    self.session.context_manager
+                )
+
+                if summary:
+                    self.session.context_manager.replace_with_summary(summary)
+                    self.session.context_manager.set_latest_usage(usage)
+                    self.session.context_manager.add_usage(usage)
+                    yield AgentEvent.compaction_complete(
+                        self.session.context_manager.message_count,
+                        usage,
+                    )
+                else:
+                    yield AgentEvent.compaction_error(
+                        self.session.chat_compactor.last_error
+                        or "Compaction failed."
+                    )
+
+            tool_schemas = self.session.tool_registry.get_schemas() if enable_tools else []
+
+            tool_calls: list[ToolCall] = []
+            usage: TokenUsage | None = None
+
+            async for event in self.session.client.chat_completion(
+                self.session.context_manager.get_messages(),
+                tools=tool_schemas if tool_schemas else None,
+            ):
+                if event.type == StreamEventType.TEXT_DELTA:
+                    if event.text_delta:
+                        content = event.text_delta.content
+                        response_text += content
+                        yield AgentEvent.text_delta(content)
+                elif event.type == StreamEventType.TOOL_CALL_COMPLETE:
+                    if event.tool_call:
+                        tool_calls.append(event.tool_call)
+                elif event.type == StreamEventType.ERROR:
+                    yield AgentEvent.agent_error(
+                        event.error or "Unknown error occurred.",
+                    )
+                elif event.type == StreamEventType.MESSAGE_COMPLETE:
+                    usage = event.usage
+
+            self.session.context_manager.add_assistant_message(
+                response_text or None,
+                (
+                    [
+                        {
+                            "id": tc.call_id,
+                            "type": "function",
+                            "function": {
+                                "name": tc.name,
+                                "arguments": json.dumps(tc.arguments),
+                            },
+                        }
+                        for tc in tool_calls
+                    ]
+                    if tool_calls
+                    else None
+                ),
+            )
+            if response_text:
+                yield AgentEvent.text_complete(response_text)
+                self.session.loop_detector.record_action(
+                    "response",
+                    text=response_text,
+                )
+
+            if not tool_calls:
+                if usage:
+                    self.session.context_manager.set_latest_usage(usage)
+                    self.session.context_manager.add_usage(usage)
+
+                self.session.context_manager.prune_tool_outputs()
+                return
+
+            enable_tools = True
+
+            tool_call_results: list[ToolResultMessage] = []
+
+            for tool_call in tool_calls:
+                with trace(
+                    name=f"tool.{tool_call.name}",
+                    run_type="tool",
+                    inputs={
+                        "tool_name": tool_call.name,
+                        "arguments": tool_call.arguments,
+                    },
+                ) as tool_run:
+                    yield AgentEvent.tool_call_start(
+                        tool_call.call_id,
+                        tool_call.name,
+                        tool_call.arguments,
+                    )
+
+                    self.session.loop_detector.record_action(
+                        "tool_call",
+                        tool_name=tool_call.name,
+                        args=tool_call.arguments,
+                    )
+
+                    result = await self.session.tool_registry.invoke(
+                        tool_call.name,
+                        tool_call.arguments,
+                        self.config.cwd,
+                        self.session.hook_system,
+                        self.session.approval_manager,
+                    )
+
+                    yield AgentEvent.tool_call_complete(
+                        tool_call.call_id,
+                        tool_call.name,
+                        result,
+                    )
+
+                    tool_call_results.append(
+                        ToolResultMessage(
+                            tool_call_id=tool_call.call_id,
+                            content=result.to_model_output(),
+                            is_error=not result.success,
+                        )
+                    )
+
+            for tool_result in tool_call_results:
+                self.session.context_manager.add_tool_result(
+                    tool_result.tool_call_id,
+                    tool_result.content,
+                )
+
+            loop_detection_error = self.session.loop_detector.check_for_loop()
+            if loop_detection_error:
+                loop_prompt = create_loop_breaker_prompt(loop_detection_error)
+                self.session.context_manager.add_user_message(loop_prompt)
+
+            if usage:
+                self.session.context_manager.set_latest_usage(usage)
+                self.session.context_manager.add_usage(usage)
+
+            self.session.context_manager.prune_tool_outputs()
+
+        yield AgentEvent.agent_error(f"Maximum turns ({max_turns}) reached")
+
+    async def __aenter__(self) -> Agent:
+        await self.session.initialize()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type,
+        exc_val,
+        exc_tb,
+    ) -> None:
+        if self.session and self.session.client and self.session.mcp_manager:
+            await self.session.client.close()
+            await self.session.mcp_manager.shutdown()
+            self.session = None

agent/events.py

@@ -0,0 +1,145 @@
+#If the method's job is to create or configure objects for the class itself, use @classmethod. If the method's job is to work on one specific object, use an instance method.
+
+
+from __future__ import annotations
+from enum import Enum
+from dataclasses import dataclass, field
+from typing import Any
+
+from client.response import TokenUsage
+from tools.base import ToolResult
+
+
+class AgentEventType(str, Enum):
+    # Agent lifecycle
+    AGENT_START = "agent_start"
+    AGENT_END = "agent_end"
+    AGENT_ERROR = "agent_error"
+
+    # Tool calls
+    TOOL_CALL_START = "tool_call_start"
+    TOOL_CALL_COMPLETE = "tool_call_complete"
+
+    # Text streaming
+    TEXT_DELTA = "text_delta"
+    TEXT_COMPLETE = "text_complete"
+
+    # Context management
+    COMPACTION_START = "compaction_start"
+    COMPACTION_COMPLETE = "compaction_complete"
+    COMPACTION_ERROR = "compaction_error"
+
+
+@dataclass
+class AgentEvent:
+    type: AgentEventType
+    data: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def agent_start(cls, message: str) -> AgentEvent:
+        return cls(
+            type=AgentEventType.AGENT_START,
+            data={"message": message},
+        )
+
+
+    #__dict__ is used to convert class var into the the json object
+
+
+    @classmethod
+    def agent_end(
+        cls,
+        response: str | None = None,
+        usage: TokenUsage | None = None,
+    ) -> AgentEvent:
+        return cls(
+            type=AgentEventType.AGENT_END,
+            data={
+                "response": response,
+                "usage": usage.__dict__ if usage else None,
+            },
+        )
+
+    @classmethod
+    def agent_error(
+        cls,
+        error: str,
+        details: dict[str, Any] | None = None,
+    ) -> AgentEvent:
+        return cls(
+            type=AgentEventType.AGENT_ERROR,
+            data={"error": error, "details": details or {}},
+        )
+
+    @classmethod
+    def text_delta(cls, content: str) -> AgentEvent:
+        return cls(
+            type=AgentEventType.TEXT_DELTA,
+            data={"content": content},
+        )
+
+    @classmethod
+    def text_complete(cls, content: str) -> AgentEvent:
+        return cls(
+            type=AgentEventType.TEXT_COMPLETE,
+            data={"content": content},
+        )
+
+    @classmethod
+    def compaction_start(cls, message_count: int) -> AgentEvent:
+        return cls(
+            type=AgentEventType.COMPACTION_START,
+            data={"message_count": message_count},
+        )
+
+    @classmethod
+    def compaction_complete(
+        cls, message_count: int, usage: TokenUsage | None = None
+    ) -> AgentEvent:
+        return cls(
+            type=AgentEventType.COMPACTION_COMPLETE,
+            data={
+                "message_count": message_count,
+                "usage": usage.__dict__ if usage else None,
+            },
+        )
+
+    @classmethod
+    def compaction_error(cls, error: str) -> AgentEvent:
+        return cls(
+            type=AgentEventType.COMPACTION_ERROR,
+            data={"error": error},
+        )
+
+    @classmethod
+    def tool_call_start(cls, call_id: str, name: str, arguments: dict[str, Any]):
+        return cls(
+            type=AgentEventType.TOOL_CALL_START,
+            data={
+                "call_id": call_id,
+                "name": name,
+                "arguments": arguments,
+            },
+        )
+
+    @classmethod
+    def tool_call_complete(
+        cls,
+        call_id: str,
+        name: str,
+        result: ToolResult,
+    ):
+        return cls(
+            type=AgentEventType.TOOL_CALL_COMPLETE,
+            data={
+                "call_id": call_id,
+                "name": name,
+                "success": result.success,
+                "output": result.output,
+                "error": result.error,
+                "metadata": result.metadata,
+                "diff": result.diff.to_diff() if result.diff else None,
+                "truncated": result.truncated,
+                "exit_code": result.exit_code,
+            },
+        )

agent/persistence.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+import json
+import os
+import tempfile
+from typing import Any
+from client.response import TokenUsage
+from config.loader import get_data_dir
+
+
+@dataclass
+class SessionSnapshot:
+    session_id: str
+    created_at: datetime
+    updated_at: datetime
+    turn_count: int
+    messages: list[dict[str, Any]]
+    total_usage: TokenUsage
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "session_id": self.session_id,
+            "created_at": self.created_at.isoformat(),
+            "updated_at": self.updated_at.isoformat(),
+            "turn_count": self.turn_count,
+            "messages": self.messages,
+            "total_usage": self.total_usage.__dict__,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> SessionSnapshot:
+        return cls(
+            session_id=data["session_id"],
+            created_at=datetime.fromisoformat(data["created_at"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+            turn_count=data["turn_count"],
+            messages=data["messages"],
+            total_usage=TokenUsage(**data["total_usage"]),
+        )
+
+
+class PersistenceManager:
+    def __init__(self):
+        self.data_dir = get_data_dir()
+        self.sessions_dir = self.data_dir / "sessions"
+        self.sessions_dir.mkdir(parents=True, exist_ok=True)
+        self.checkpoints_dir = self.data_dir / "checkpoints"
+        self.checkpoints_dir.mkdir(parents=True, exist_ok=True)
+        os.chmod(self.sessions_dir, 0o700)
+        os.chmod(self.checkpoints_dir, 0o700)
+
+    def save_session(self, snapshot: SessionSnapshot) -> None:
+        file_path = self.sessions_dir / f"{snapshot.session_id}.json"
+        self._atomic_save(file_path, snapshot)
+
+    def _atomic_save(self, file_path, snapshot: SessionSnapshot) -> None:
+        fd, temporary_path = tempfile.mkstemp(
+            prefix=f".{file_path.name}.",
+            suffix=".tmp",
+            dir=file_path.parent,
+            text=True,
+        )
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as fp:
+                json.dump(snapshot.to_dict(), fp, indent=2)
+                fp.flush()
+                os.fsync(fp.fileno())
+            os.chmod(temporary_path, 0o600)
+            os.replace(temporary_path, file_path)
+        except Exception:
+            try:
+                os.unlink(temporary_path)
+            except FileNotFoundError:
+                pass
+            raise
+
+    def load_session(self, session_id: str) -> SessionSnapshot | None:
+        file_path = self.sessions_dir / f"{session_id}.json"
+
+        if not file_path.exists():
+            return None
+
+        with open(file_path, "r", encoding="utf-8") as fp:
+            data = json.load(fp)
+
+        return SessionSnapshot.from_dict(data)
+
+    def list_sessions(self) -> list[dict[str, Any]]:
+        sessions = []
+        for file_path in self.sessions_dir.glob("*.json"):
+            with open(file_path, "r", encoding="utf-8") as fp:
+                data = json.load(fp)
+            sessions.append(
+                {
+                    "session_id": data["session_id"],
+                    "created_at": data["created_at"],
+                    "updated_at": data["updated_at"],
+                    "turn_count": data["turn_count"],
+                }
+            )
+
+        sessions.sort(key=lambda x: x["updated_at"], reverse=True)
+        return sessions
+
+    def save_checkpoint(self, snapshot: SessionSnapshot) -> str:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        checkpoint_id = f"{snapshot.session_id}_{timestamp}"
+        file_path = self.checkpoints_dir / f"{checkpoint_id}.json"
+
+        self._atomic_save(file_path, snapshot)
+        return checkpoint_id
+
+    def load_checkpoint(self, checkpoint_id: str) -> SessionSnapshot | None:
+        file_path = self.checkpoints_dir / f"{checkpoint_id}.json"
+
+        if not file_path.exists():
+            return None
+
+        with open(file_path, "r", encoding="utf-8") as fp:
+            data = json.load(fp)
+
+        return SessionSnapshot.from_dict(data)

agent/session.py

@@ -0,0 +1,99 @@
+from datetime import datetime
+import json
+from typing import Any
+import uuid
+from client.llm_client import LLMClient
+from config.config import Config
+from config.loader import get_data_dir
+from context.compaction import ChatCompactor
+from context.loop_detector import LoopDetector
+from context.manager import ContextManager
+from hooks.hook_system import HookSystem
+from safety.approval import ApprovalManager
+from skills import SkillDiscoveryManager, SkillRegistry
+from tools.discovery import ToolDiscoveryManager
+from tools.mcp.mcp_manager import MCPManager
+from tools.registry import create_default_registry
+
+
+class Session:
+    def __init__(self, config: Config):
+        self.config = config
+        self.client = LLMClient(config=config)
+        self.tool_registry = create_default_registry(config)
+        self.skill_registry = SkillRegistry(config)
+        self.context_manager: ContextManager | None = None
+        self.discovery_manager = ToolDiscoveryManager(
+            self.config,
+            self.tool_registry,
+        )
+        self.skill_discovery_manager = SkillDiscoveryManager(
+            self.config,
+            self.skill_registry,
+        )
+        self.mcp_manager = MCPManager(self.config)
+        self.chat_compactor = ChatCompactor(self.client)
+        self.approval_manager = ApprovalManager(
+            self.config.approval,
+            self.config.cwd,
+        )
+        self.loop_detector = LoopDetector()
+        self.hook_system = HookSystem(config)
+        self.session_id = str(uuid.uuid4())
+        self.created_at = datetime.now()
+        self.updated_at = datetime.now()
+
+        self.turn_count = 0
+
+    async def initialize(self) -> None:
+        await self.mcp_manager.initialize()
+        self.mcp_manager.register_tools(self.tool_registry)
+
+        self.discovery_manager.discover_all()
+        self.skill_discovery_manager.discover_all()
+        self.context_manager = ContextManager(
+            config=self.config,
+            user_memory=self._load_memory(),
+            tools=self.tool_registry.get_tools(),
+            skills=self.skill_registry.get_skills(),
+        )
+
+    def _load_memory(self) -> str | None:
+        data_dir = get_data_dir()
+        data_dir.mkdir(parents=True, exist_ok=True)
+        path = data_dir / "user_memory.json"
+
+        if not path.exists():
+            return None
+
+        try:
+            content = path.read_text(encoding="utf-8")
+            data = json.loads(content)
+            entries = data.get("entries")
+            if not entries:
+                return None
+
+            lines = ["User preferences and notes:"]
+            for key, value in entries.items():
+                lines.append(f"- {key}: {value}")
+
+            return "\n".join(lines)
+        except Exception:
+            return None
+
+    def increment_turn(self) -> int:
+        self.turn_count += 1
+        self.updated_at = datetime.now()
+
+        return self.turn_count
+
+    def get_stats(self) -> dict[str, Any]:
+        return {
+            "session_id": self.session_id,
+            "created_at": self.created_at.isoformat(),
+            "turn_count": self.turn_count,
+            "message_count": self.context_manager.message_count,
+            "token_usage": self.context_manager.total_usage,
+            "tools_count": len(self.tool_registry.get_tools()),
+            "mcp_servers": len(self.tool_registry.connected_mcp_servers),
+        }

client/__init__.py

@@ -0,0 +1 @@
+"""Provider client helpers."""