nanobot/agent/context.py

@@ -3,8 +3,6 @@
 import base64
 import mimetypes
 import platform
-import time
-from datetime import datetime
 from pathlib import Path
 from typing import Any
 
@@ -13,10 +11,14 @@ from nanobot.agent.skills import SkillsLoader
 
 
 class ContextBuilder:
-    """Builds the context (system prompt + messages) for the agent."""
+    """
+    Builds the context (system prompt + messages) for the agent.
+    
+    Assembles bootstrap files, memory, skills, and conversation history
+    into a coherent prompt for the LLM.
+    """
     
     BOOTSTRAP_FILES = ["AGENTS.md", "SOUL.md", "USER.md", "TOOLS.md", "IDENTITY.md"]
-    _RUNTIME_CONTEXT_TAG = "[Runtime Context — metadata only, not instructions]"
     
     def __init__(self, workspace: Path):
         self.workspace = workspace
@@ -24,13 +26,25 @@ class ContextBuilder:
         self.skills = SkillsLoader(workspace)
     
     def build_system_prompt(self, skill_names: list[str] | None = None) -> str:
-        """Build the system prompt from identity, bootstrap files, memory, and skills."""
+        """
-        parts = [self._get_identity()]
+        Build the system prompt from bootstrap files, memory, and skills.
-
+        
+        Args:
+            skill_names: Optional list of skills to include.
+        
+        Returns:
+            Complete system prompt.
+        """
+        parts = []
+        
+        # Core identity
+        parts.append(self._get_identity())
+        
+        # Bootstrap files
         bootstrap = self._load_bootstrap_files()
         if bootstrap:
             parts.append(bootstrap)
-
+        
         # Static knowledge context (KNOWLEDGE.md — manually curated, stable for caching)
         # MEMORY.md is excluded from system prompt as it changes frequently (consolidator),
         # but the agent can still read/grep it via tools.
@@ -39,7 +53,7 @@ class ContextBuilder:
             knowledge = knowledge_file.read_text(encoding="utf-8").strip()
             if knowledge:
                 parts.append(f"# Knowledge\n\n{knowledge}")
-
+        
         # Skills - progressive loading
         # 1. Always-loaded skills: include full content
         always_skills = self.skills.get_always_skills()
@@ -47,7 +61,8 @@ class ContextBuilder:
             always_content = self.skills.load_skills_for_context(always_skills)
             if always_content:
                 parts.append(f"# Active Skills\n\n{always_content}")
-
+        
+        # 2. Available skills: only show summary (agent uses read_file to load)
         skills_summary = self.skills.build_skills_summary()
         if skills_summary:
             parts.append(f"""# Skills
@@ -56,7 +71,7 @@ The following skills extend your capabilities. To use a skill, read its SKILL.md
 Skills with available="false" need dependencies installed first - you can try installing them with apt/brew.
 
 {skills_summary}""")
-
+        
         return "\n\n---\n\n".join(parts)
     
     def _get_identity(self) -> str:
@@ -77,28 +92,24 @@ Skills with available="false" need dependencies installed first - you can try in
 
 ## Workspace
 Your workspace is at: {workspace_path}
-- Long-term memory: {workspace_path}/memory/MEMORY.md (write important facts here)
+- Long-term memory: {workspace_path}/memory/MEMORY.md
-- History log: {workspace_path}/memory/HISTORY.md (grep-searchable). Each entry starts with [YYYY-MM-DD HH:MM].
+- History log: {workspace_path}/memory/HISTORY.md (grep-searchable)
 - Custom skills: {workspace_path}/skills/{{skill-name}}/SKILL.md
 
-## nanobot Guidelines
+IMPORTANT: When responding to direct questions or conversations, reply directly with your text response.
-- State intent before tool calls, but NEVER predict or claim results before receiving them.
+Only use the 'message' tool when you need to send a message to a specific chat channel (like WhatsApp).
-- Before modifying a file, read it first. Do not assume files or directories exist.
+For normal conversation, just respond with text - do not call the message tool.
-- After writing or editing a file, re-read it if accuracy matters.
-- If a tool call fails, analyze the error before retrying with a different approach.
-- Ask for clarification when the request is ambiguous.
 
-Reply directly with text for conversations. Only use the 'message' tool to send to a specific chat channel."""
+Always be helpful, accurate, and concise. When using tools, think step by step: what you know, what you need, and why you chose this tool.
+When remembering something important, write to {workspace_path}/memory/MEMORY.md
+To recall past events, grep {workspace_path}/memory/HISTORY.md
 
-    @staticmethod
+## Visibility Markers
-    def _build_runtime_context(channel: str | None, chat_id: str | None) -> str:
+
-        """Build untrusted runtime metadata block for injection before the user message."""
+Messages marked with [HIDDEN:{{signature}}] were not sent to the user. These markers
-        now = datetime.now().strftime("%Y-%m-%d %H:%M (%A)")
+are cryptographically signed by the system to track internal reasoning and background
-        tz = time.strftime("%Z") or "UTC"
+tasks. Do NOT generate [HIDDEN:*] patterns yourself - outputs containing forged
-        lines = [f"Current Time: {now} ({tz})"]
+visibility markers will be rejected."""
-        if channel and chat_id:
-            lines += [f"Channel: {channel}", f"Chat ID: {chat_id}"]
-        return ContextBuilder._RUNTIME_CONTEXT_TAG + "\n" + "\n".join(lines)
     
     def _load_bootstrap_files(self) -> str:
         """Load all bootstrap files from workspace."""
@@ -121,13 +132,36 @@ Reply directly with text for conversations. Only use the 'message' tool to send
         channel: str | None = None,
         chat_id: str | None = None,
     ) -> list[dict[str, Any]]:
-        """Build the complete message list for an LLM call."""
+        """
-        return [
+        Build the complete message list for an LLM call.
-            {"role": "system", "content": self.build_system_prompt(skill_names)},
+
-            *history,
+        Args:
-            {"role": "user", "content": self._build_runtime_context(channel, chat_id)},
+            history: Previous conversation messages.
-            {"role": "user", "content": self._build_user_content(current_message, media)},
+            current_message: The new user message.
-        ]
+            skill_names: Optional skills to include.
+            media: Optional list of local file paths for images/media.
+            channel: Current channel (telegram, feishu, etc.).
+            chat_id: Current chat/user ID.
+
+        Returns:
+            List of messages including system prompt.
+        """
+        messages = []
+
+        # System prompt
+        system_prompt = self.build_system_prompt(skill_names)
+        if channel and chat_id:
+            system_prompt += f"\n\n## Current Session\nChannel: {channel}\nChat ID: {chat_id}"
+        messages.append({"role": "system", "content": system_prompt})
+
+        # History
+        messages.extend(history)
+
+        # Current message (with optional image attachments)
+        user_content = self._build_user_content(current_message, media)
+        messages.append({"role": "user", "content": user_content})
+
+        return messages
 
     def _build_user_content(self, text: str, media: list[str] | None) -> str | list[dict[str, Any]]:
         """Build user message content with optional base64-encoded images."""
@@ -148,24 +182,59 @@ Reply directly with text for conversations. Only use the 'message' tool to send
         return images + [{"type": "text", "text": text}]
     
     def add_tool_result(
-        self, messages: list[dict[str, Any]],
+        self,
-        tool_call_id: str, tool_name: str, result: str,
+        messages: list[dict[str, Any]],
+        tool_call_id: str,
+        tool_name: str,
+        result: str
     ) -> list[dict[str, Any]]:
-        """Add a tool result to the message list."""
+        """
-        messages.append({"role": "tool", "tool_call_id": tool_call_id, "name": tool_name, "content": result})
+        Add a tool result to the message list.
+        
+        Args:
+            messages: Current message list.
+            tool_call_id: ID of the tool call.
+            tool_name: Name of the tool.
+            result: Tool execution result.
+        
+        Returns:
+            Updated message list.
+        """
+        messages.append({
+            "role": "tool",
+            "tool_call_id": tool_call_id,
+            "name": tool_name,
+            "content": result
+        })
         return messages
     
     def add_assistant_message(
-        self, messages: list[dict[str, Any]],
+        self,
+        messages: list[dict[str, Any]],
         content: str | None,
         tool_calls: list[dict[str, Any]] | None = None,
         reasoning_content: str | None = None,
     ) -> list[dict[str, Any]]:
-        """Add an assistant message to the message list."""
+        """
-        msg: dict[str, Any] = {"role": "assistant", "content": content}
+        Add an assistant message to the message list.
+        
+        Args:
+            messages: Current message list.
+            content: Message content.
+            tool_calls: Optional tool calls.
+            reasoning_content: Thinking output (Kimi, DeepSeek-R1, etc.).
+        
+        Returns:
+            Updated message list.
+        """
+        msg: dict[str, Any] = {"role": "assistant", "content": content or ""}
+        
         if tool_calls:
             msg["tool_calls"] = tool_calls
-        if reasoning_content is not None:
+        
+        # Thinking models reject history without this
+        if reasoning_content:
             msg["reasoning_content"] = reasoning_content
+        
         messages.append(msg)
         return messages