From b523b277b05c6ed1c51c5ea44364787b71e3c592 Mon Sep 17 00:00:00 2001
From: Harry Zhou <junwu.zhou@qq.com>
Date: Sat, 14 Feb 2026 23:44:03 +0800
Subject: [PATCH 01/35] fix(agent): handle non-string values in memory
 consolidation

Fix TypeError when LLM returns JSON objects instead of strings for
history_entry or memory_update.

Changes:
- Update prompt to explicitly require string values with example
- Add type checking and conversion for non-string values
- Use json.dumps() for consistent JSON formatting

Fixes potential memory consolidation failures when LLM interprets
the prompt loosely and returns structured objects instead of strings.
---
 nanobot/agent/loop.py                    |  14 +++
 tests/test_memory_consolidation_types.py | 133 +++++++++++++++++++++++
 2 files changed, 147 insertions(+)
 create mode 100644 tests/test_memory_consolidation_types.py

diff --git a/nanobot/agent/loop.py b/nanobot/agent/loop.py
index c256a56..e28166f 100644
--- a/nanobot/agent/loop.py
+++ b/nanobot/agent/loop.py
@@ -384,6 +384,14 @@ class AgentLoop:
 ## Conversation to Process
 {conversation}
 
+**IMPORTANT**: Both values MUST be strings, not objects or arrays.
+
+Example:
+{{
+  "history_entry": "[2026-02-14 22:50] User asked about...",
+  "memory_update": "- Host: HARRYBOOK-T14P\n- Name: Nado"
+}}
+
 Respond with ONLY valid JSON, no markdown fences."""
 
         try:
@@ -400,8 +408,14 @@ Respond with ONLY valid JSON, no markdown fences."""
             result = json.loads(text)
 
             if entry := result.get("history_entry"):
+                # Defensive: ensure entry is a string (LLM may return dict)
+                if not isinstance(entry, str):
+                    entry = json.dumps(entry, ensure_ascii=False)
                 memory.append_history(entry)
             if update := result.get("memory_update"):
+                # Defensive: ensure update is a string
+                if not isinstance(update, str):
+                    update = json.dumps(update, ensure_ascii=False)
                 if update != current_memory:
                     memory.write_long_term(update)
 
diff --git a/tests/test_memory_consolidation_types.py b/tests/test_memory_consolidation_types.py
new file mode 100644
index 0000000..3b76596
--- /dev/null
+++ b/tests/test_memory_consolidation_types.py
@@ -0,0 +1,133 @@
+"""Test memory consolidation handles non-string values from LLM.
+
+This test verifies the fix for the bug where memory consolidation fails
+when LLM returns JSON objects instead of strings for history_entry or
+memory_update fields.
+
+Related issue: Memory consolidation fails with TypeError when LLM returns dict
+"""
+
+import json
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from nanobot.agent.memory import MemoryStore
+
+
+class TestMemoryConsolidationTypeHandling:
+    """Test that MemoryStore methods handle type conversion correctly."""
+
+    def test_append_history_accepts_string(self):
+        """MemoryStore.append_history should accept string values."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            memory = MemoryStore(Path(tmpdir))
+            
+            # Should not raise TypeError
+            memory.append_history("[2026-02-14] Test entry")
+            
+            # Verify content was written
+            history_content = memory.history_file.read_text()
+            assert "Test entry" in history_content
+
+    def test_write_long_term_accepts_string(self):
+        """MemoryStore.write_long_term should accept string values."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            memory = MemoryStore(Path(tmpdir))
+            
+            # Should not raise TypeError
+            memory.write_long_term("- Fact 1\n- Fact 2")
+            
+            # Verify content was written
+            memory_content = memory.read_long_term()
+            assert "Fact 1" in memory_content
+
+    def test_type_conversion_dict_to_str(self):
+        """Dict values should be converted to JSON strings."""
+        input_val = {"timestamp": "2026-02-14", "summary": "test"}
+        expected = '{"timestamp": "2026-02-14", "summary": "test"}'
+        
+        # Simulate the fix logic
+        if not isinstance(input_val, str):
+            result = json.dumps(input_val, ensure_ascii=False)
+        else:
+            result = input_val
+        
+        assert result == expected
+        assert isinstance(result, str)
+
+    def test_type_conversion_list_to_str(self):
+        """List values should be converted to JSON strings."""
+        input_val = ["item1", "item2"]
+        expected = '["item1", "item2"]'
+        
+        # Simulate the fix logic
+        if not isinstance(input_val, str):
+            result = json.dumps(input_val, ensure_ascii=False)
+        else:
+            result = input_val
+        
+        assert result == expected
+        assert isinstance(result, str)
+
+    def test_type_conversion_str_unchanged(self):
+        """String values should remain unchanged."""
+        input_val = "already a string"
+        
+        # Simulate the fix logic
+        if not isinstance(input_val, str):
+            result = json.dumps(input_val, ensure_ascii=False)
+        else:
+            result = input_val
+        
+        assert result == input_val
+        assert isinstance(result, str)
+
+    def test_memory_consolidation_simulation(self):
+        """Simulate full consolidation with dict values from LLM."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            memory = MemoryStore(Path(tmpdir))
+            
+            # Simulate LLM returning dict values (the bug scenario)
+            history_entry = {"timestamp": "2026-02-14", "summary": "User asked about..."}
+            memory_update = {"facts": ["Location: Beijing", "Skill: Python"]}
+            
+            # Apply the fix: convert to str
+            if not isinstance(history_entry, str):
+                history_entry = json.dumps(history_entry, ensure_ascii=False)
+            if not isinstance(memory_update, str):
+                memory_update = json.dumps(memory_update, ensure_ascii=False)
+            
+            # Should not raise TypeError after conversion
+            memory.append_history(history_entry)
+            memory.write_long_term(memory_update)
+            
+            # Verify content
+            assert memory.history_file.exists()
+            assert memory.memory_file.exists()
+            
+            history_content = memory.history_file.read_text()
+            memory_content = memory.read_long_term()
+            
+            assert "timestamp" in history_content
+            assert "facts" in memory_content
+
+
+class TestPromptOptimization:
+    """Test that prompt optimization helps prevent the issue."""
+
+    def test_prompt_includes_string_requirement(self):
+        """The prompt should explicitly require string values."""
+        # This is a documentation test - verify the fix is in place
+        # by checking the expected prompt content
+        expected_keywords = [
+            "MUST be strings",
+            "not objects or arrays",
+            "Example:",
+        ]
+        
+        # The actual prompt content is in nanobot/agent/loop.py
+        # This test serves as documentation of the expected behavior
+        for keyword in expected_keywords:
+            assert keyword, f"Prompt should include: {keyword}"

From fbbbdc727ddec942279a5d0ccc3c37b1bc08ab23 Mon Sep 17 00:00:00 2001
From: Oleg Medvedev <omdv@protonmail.com>
Date: Sat, 14 Feb 2026 13:38:49 -0600
Subject: [PATCH 02/35] fix(tools): resolve relative file paths against
 workspace

File tools now resolve relative paths (e.g., "test.txt") against the
workspace directory instead of the current working directory. This fixes
failures when models use simple filenames instead of full paths.

- Add workspace parameter to _resolve_path() in filesystem.py
- Update all file tools to accept workspace in constructor
- Pass workspace when registering tools in AgentLoop
---
 nanobot/agent/loop.py             | 10 +++---
 nanobot/agent/tools/filesystem.py | 59 +++++++++++++++++--------------
 2 files changed, 38 insertions(+), 31 deletions(-)

diff --git a/nanobot/agent/loop.py b/nanobot/agent/loop.py
index c256a56..3d9f77b 100644
--- a/nanobot/agent/loop.py
+++ b/nanobot/agent/loop.py
@@ -86,12 +86,12 @@ class AgentLoop:
     
     def _register_default_tools(self) -> None:
         """Register the default set of tools."""
-        # File tools (restrict to workspace if configured)
+        # File tools (workspace for relative paths, restrict if configured)
         allowed_dir = self.workspace if self.restrict_to_workspace else None
-        self.tools.register(ReadFileTool(allowed_dir=allowed_dir))
-        self.tools.register(WriteFileTool(allowed_dir=allowed_dir))
-        self.tools.register(EditFileTool(allowed_dir=allowed_dir))
-        self.tools.register(ListDirTool(allowed_dir=allowed_dir))
+        self.tools.register(ReadFileTool(workspace=self.workspace, allowed_dir=allowed_dir))
+        self.tools.register(WriteFileTool(workspace=self.workspace, allowed_dir=allowed_dir))
+        self.tools.register(EditFileTool(workspace=self.workspace, allowed_dir=allowed_dir))
+        self.tools.register(ListDirTool(workspace=self.workspace, allowed_dir=allowed_dir))
         
         # Shell tool
         self.tools.register(ExecTool(
diff --git a/nanobot/agent/tools/filesystem.py b/nanobot/agent/tools/filesystem.py
index 6b3254a..419b088 100644
--- a/nanobot/agent/tools/filesystem.py
+++ b/nanobot/agent/tools/filesystem.py
@@ -6,9 +6,12 @@ from typing import Any
 from nanobot.agent.tools.base import Tool
 
 
-def _resolve_path(path: str, allowed_dir: Path | None = None) -> Path:
-    """Resolve path and optionally enforce directory restriction."""
-    resolved = Path(path).expanduser().resolve()
+def _resolve_path(path: str, workspace: Path | None = None, allowed_dir: Path | None = None) -> Path:
+    """Resolve path against workspace (if relative) and enforce directory restriction."""
+    p = Path(path).expanduser()
+    if not p.is_absolute() and workspace:
+        p = workspace / p
+    resolved = p.resolve()
     if allowed_dir and not str(resolved).startswith(str(allowed_dir.resolve())):
         raise PermissionError(f"Path {path} is outside allowed directory {allowed_dir}")
     return resolved
@@ -16,8 +19,9 @@ def _resolve_path(path: str, allowed_dir: Path | None = None) -> Path:
 
 class ReadFileTool(Tool):
     """Tool to read file contents."""
-    
-    def __init__(self, allowed_dir: Path | None = None):
+
+    def __init__(self, workspace: Path | None = None, allowed_dir: Path | None = None):
+        self._workspace = workspace
         self._allowed_dir = allowed_dir
 
     @property
@@ -43,12 +47,12 @@ class ReadFileTool(Tool):
     
     async def execute(self, path: str, **kwargs: Any) -> str:
         try:
-            file_path = _resolve_path(path, self._allowed_dir)
+            file_path = _resolve_path(path, self._workspace, self._allowed_dir)
             if not file_path.exists():
                 return f"Error: File not found: {path}"
             if not file_path.is_file():
                 return f"Error: Not a file: {path}"
-            
+
             content = file_path.read_text(encoding="utf-8")
             return content
         except PermissionError as e:
@@ -59,8 +63,9 @@ class ReadFileTool(Tool):
 
 class WriteFileTool(Tool):
     """Tool to write content to a file."""
-    
-    def __init__(self, allowed_dir: Path | None = None):
+
+    def __init__(self, workspace: Path | None = None, allowed_dir: Path | None = None):
+        self._workspace = workspace
         self._allowed_dir = allowed_dir
 
     @property
@@ -90,10 +95,10 @@ class WriteFileTool(Tool):
     
     async def execute(self, path: str, content: str, **kwargs: Any) -> str:
         try:
-            file_path = _resolve_path(path, self._allowed_dir)
+            file_path = _resolve_path(path, self._workspace, self._allowed_dir)
             file_path.parent.mkdir(parents=True, exist_ok=True)
             file_path.write_text(content, encoding="utf-8")
-            return f"Successfully wrote {len(content)} bytes to {path}"
+            return f"Successfully wrote {len(content)} bytes to {file_path}"
         except PermissionError as e:
             return f"Error: {e}"
         except Exception as e:
@@ -102,8 +107,9 @@ class WriteFileTool(Tool):
 
 class EditFileTool(Tool):
     """Tool to edit a file by replacing text."""
-    
-    def __init__(self, allowed_dir: Path | None = None):
+
+    def __init__(self, workspace: Path | None = None, allowed_dir: Path | None = None):
+        self._workspace = workspace
         self._allowed_dir = allowed_dir
 
     @property
@@ -137,24 +143,24 @@ class EditFileTool(Tool):
     
     async def execute(self, path: str, old_text: str, new_text: str, **kwargs: Any) -> str:
         try:
-            file_path = _resolve_path(path, self._allowed_dir)
+            file_path = _resolve_path(path, self._workspace, self._allowed_dir)
             if not file_path.exists():
                 return f"Error: File not found: {path}"
-            
+
             content = file_path.read_text(encoding="utf-8")
-            
+
             if old_text not in content:
                 return f"Error: old_text not found in file. Make sure it matches exactly."
-            
+
             # Count occurrences
             count = content.count(old_text)
             if count > 1:
                 return f"Warning: old_text appears {count} times. Please provide more context to make it unique."
-            
+
             new_content = content.replace(old_text, new_text, 1)
             file_path.write_text(new_content, encoding="utf-8")
-            
-            return f"Successfully edited {path}"
+
+            return f"Successfully edited {file_path}"
         except PermissionError as e:
             return f"Error: {e}"
         except Exception as e:
@@ -163,8 +169,9 @@ class EditFileTool(Tool):
 
 class ListDirTool(Tool):
     """Tool to list directory contents."""
-    
-    def __init__(self, allowed_dir: Path | None = None):
+
+    def __init__(self, workspace: Path | None = None, allowed_dir: Path | None = None):
+        self._workspace = workspace
         self._allowed_dir = allowed_dir
 
     @property
@@ -190,20 +197,20 @@ class ListDirTool(Tool):
     
     async def execute(self, path: str, **kwargs: Any) -> str:
         try:
-            dir_path = _resolve_path(path, self._allowed_dir)
+            dir_path = _resolve_path(path, self._workspace, self._allowed_dir)
             if not dir_path.exists():
                 return f"Error: Directory not found: {path}"
             if not dir_path.is_dir():
                 return f"Error: Not a directory: {path}"
-            
+
             items = []
             for item in sorted(dir_path.iterdir()):
                 prefix = "📁 " if item.is_dir() else "📄 "
                 items.append(f"{prefix}{item.name}")
-            
+
             if not items:
                 return f"Directory {path} is empty"
-            
+
             return "\n".join(items)
         except PermissionError as e:
             return f"Error: {e}"

From e44f14379a289f900556fa3d6f255f446aee634f Mon Sep 17 00:00:00 2001
From: Ivan <Tevkanbot@yandex.ru>
Date: Wed, 18 Feb 2026 11:57:58 +0300
Subject: [PATCH 03/35] fix: sanitize messages and ensure 'content' for strict
 LLM providers

- Strip non-standard keys like 'reasoning_content' before sending to LLM
- Always include 'content' key in assistant messages (required by StepFun)
- Add _sanitize_messages to LiteLLMProvider to prevent 400 BadRequest errors
---
 nanobot/agent/context.py              |  6 +++---
 nanobot/providers/litellm_provider.py | 26 +++++++++++++++++++++++++-
 2 files changed, 28 insertions(+), 4 deletions(-)

diff --git a/nanobot/agent/context.py b/nanobot/agent/context.py
index cfd6318..458016e 100644
--- a/nanobot/agent/context.py
+++ b/nanobot/agent/context.py
@@ -227,9 +227,9 @@ To recall past events, grep {workspace_path}/memory/HISTORY.md"""
         """
         msg: dict[str, Any] = {"role": "assistant"}
 
-        # Omit empty content — some backends reject empty text blocks
-        if content:
-            msg["content"] = content
+        # Always include content — some providers (e.g. StepFun) reject
+        # assistant messages that omit the key entirely.
+        msg["content"] = content
 
         if tool_calls:
             msg["tool_calls"] = tool_calls
diff --git a/nanobot/providers/litellm_provider.py b/nanobot/providers/litellm_provider.py
index 8cc4e35..58acf95 100644
--- a/nanobot/providers/litellm_provider.py
+++ b/nanobot/providers/litellm_provider.py
@@ -12,6 +12,12 @@ from nanobot.providers.base import LLMProvider, LLMResponse, ToolCallRequest
 from nanobot.providers.registry import find_by_model, find_gateway
 
 
+# Keys that are part of the OpenAI chat-completion message schema.
+# Anything else (e.g. reasoning_content, timestamp) is stripped before sending
+# to avoid "Unrecognized chat message" errors from strict providers like StepFun.
+_ALLOWED_MSG_KEYS = frozenset({"role", "content", "tool_calls", "tool_call_id", "name"})
+
+
 class LiteLLMProvider(LLMProvider):
     """
     LLM provider using LiteLLM for multi-provider support.
@@ -103,6 +109,24 @@ class LiteLLMProvider(LLMProvider):
                     kwargs.update(overrides)
                     return
     
+    @staticmethod
+    def _sanitize_messages(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        """Strip non-standard keys from messages for strict providers.
+
+        Some providers (e.g. StepFun via OpenRouter) reject messages that
+        contain extra keys like ``reasoning_content``. This method keeps
+        only the keys defined in the OpenAI chat-completion schema and
+        ensures every assistant message has a ``content`` key.
+        """
+        sanitized = []
+        for msg in messages:
+            clean = {k: v for k, v in msg.items() if k in _ALLOWED_MSG_KEYS}
+            # Strict providers require "content" even when assistant only has tool_calls
+            if clean.get("role") == "assistant" and "content" not in clean:
+                clean["content"] = None
+            sanitized.append(clean)
+        return sanitized
+
     async def chat(
         self,
         messages: list[dict[str, Any]],
@@ -132,7 +156,7 @@ class LiteLLMProvider(LLMProvider):
         
         kwargs: dict[str, Any] = {
             "model": model,
-            "messages": messages,
+            "messages": self._sanitize_messages(messages),
             "max_tokens": max_tokens,
             "temperature": temperature,
         }

From c5b4331e692c09bb285a5c8e3d811dbfca52b273 Mon Sep 17 00:00:00 2001
From: dxtime <dxxtimer@gmail.com>
Date: Thu, 19 Feb 2026 01:21:17 +0800
Subject: [PATCH 04/35] feature: Added custom headers for MCP Auth use.

---
 nanobot/agent/tools/mcp.py | 18 +++++++++++++++---
 nanobot/config/schema.py   |  1 +
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/nanobot/agent/tools/mcp.py b/nanobot/agent/tools/mcp.py
index 1c8eac4..4d5c053 100644
--- a/nanobot/agent/tools/mcp.py
+++ b/nanobot/agent/tools/mcp.py
@@ -59,9 +59,21 @@ async def connect_mcp_servers(
                 read, write = await stack.enter_async_context(stdio_client(params))
             elif cfg.url:
                 from mcp.client.streamable_http import streamable_http_client
-                read, write, _ = await stack.enter_async_context(
-                    streamable_http_client(cfg.url)
-                )
+                import httpx
+                if cfg.headers:
+                    http_client = await stack.enter_async_context(
+                        httpx.AsyncClient(
+                            headers=cfg.headers,
+                            follow_redirects=True
+                        )
+                    )
+                    read, write, _ = await stack.enter_async_context(
+                        streamable_http_client(cfg.url, http_client=http_client)
+                    )
+                else:
+                    read, write, _ = await stack.enter_async_context(
+                        streamable_http_client(cfg.url)
+                    )
             else:
                 logger.warning(f"MCP server '{name}': no command or url configured, skipping")
                 continue
diff --git a/nanobot/config/schema.py b/nanobot/config/schema.py
index ce9634c..e404d3c 100644
--- a/nanobot/config/schema.py
+++ b/nanobot/config/schema.py
@@ -257,6 +257,7 @@ class MCPServerConfig(Base):
     args: list[str] = Field(default_factory=list)  # Stdio: command arguments
     env: dict[str, str] = Field(default_factory=dict)  # Stdio: extra env vars
     url: str = ""  # HTTP: streamable HTTP endpoint URL
+    headers: dict[str, str] = Field(default_factory=dict)  # HTTP: Custom HTTP Headers
 
 
 class ToolsConfig(Base):

From 4a85cd9a1102871aa900b906ffb8ca4c89d206d0 Mon Sep 17 00:00:00 2001
From: Alexander Minges <alexander.minges@uni-due.de>
Date: Tue, 17 Feb 2026 13:18:43 +0100
Subject: [PATCH 05/35] fix(cron): add service-layer timezone validation

Adds `_validate_schedule_for_add()` to `CronService.add_job` so that
invalid or misplaced `tz` values are rejected before a job is persisted,
regardless of which caller (CLI, tool, etc.) invoked the service.

Surfaces the resulting `ValueError` in `nanobot cron add` via a
`try/except` so the CLI exits cleanly with a readable error message.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 nanobot/cli/commands.py     | 22 +++++++++++++---------
 nanobot/cron/service.py     | 15 +++++++++++++++
 tests/test_cron_commands.py | 29 +++++++++++++++++++++++++++++
 tests/test_cron_service.py  | 30 ++++++++++++++++++++++++++++++
 4 files changed, 87 insertions(+), 9 deletions(-)
 create mode 100644 tests/test_cron_commands.py
 create mode 100644 tests/test_cron_service.py

diff --git a/nanobot/cli/commands.py b/nanobot/cli/commands.py
index b61d9aa..668fcb5 100644
--- a/nanobot/cli/commands.py
+++ b/nanobot/cli/commands.py
@@ -787,15 +787,19 @@ def cron_add(
     store_path = get_data_dir() / "cron" / "jobs.json"
     service = CronService(store_path)
     
-    job = service.add_job(
-        name=name,
-        schedule=schedule,
-        message=message,
-        deliver=deliver,
-        to=to,
-        channel=channel,
-    )
-    
+    try:
+        job = service.add_job(
+            name=name,
+            schedule=schedule,
+            message=message,
+            deliver=deliver,
+            to=to,
+            channel=channel,
+        )
+    except ValueError as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1) from e
+
     console.print(f"[green]✓[/green] Added job '{job.name}' ({job.id})")
 
 
diff --git a/nanobot/cron/service.py b/nanobot/cron/service.py
index 14666e8..7ae1153 100644
--- a/nanobot/cron/service.py
+++ b/nanobot/cron/service.py
@@ -45,6 +45,20 @@ def _compute_next_run(schedule: CronSchedule, now_ms: int) -> int | None:
     return None
 
 
+def _validate_schedule_for_add(schedule: CronSchedule) -> None:
+    """Validate schedule fields that would otherwise create non-runnable jobs."""
+    if schedule.tz and schedule.kind != "cron":
+        raise ValueError("tz can only be used with cron schedules")
+
+    if schedule.kind == "cron" and schedule.tz:
+        try:
+            from zoneinfo import ZoneInfo
+
+            ZoneInfo(schedule.tz)
+        except Exception:
+            raise ValueError(f"unknown timezone '{schedule.tz}'") from None
+
+
 class CronService:
     """Service for managing and executing scheduled jobs."""
     
@@ -272,6 +286,7 @@ class CronService:
     ) -> CronJob:
         """Add a new job."""
         store = self._load_store()
+        _validate_schedule_for_add(schedule)
         now = _now_ms()
         
         job = CronJob(
diff --git a/tests/test_cron_commands.py b/tests/test_cron_commands.py
new file mode 100644
index 0000000..bce1ef5
--- /dev/null
+++ b/tests/test_cron_commands.py
@@ -0,0 +1,29 @@
+from typer.testing import CliRunner
+
+from nanobot.cli.commands import app
+
+runner = CliRunner()
+
+
+def test_cron_add_rejects_invalid_timezone(monkeypatch, tmp_path) -> None:
+    monkeypatch.setattr("nanobot.config.loader.get_data_dir", lambda: tmp_path)
+
+    result = runner.invoke(
+        app,
+        [
+            "cron",
+            "add",
+            "--name",
+            "demo",
+            "--message",
+            "hello",
+            "--cron",
+            "0 9 * * *",
+            "--tz",
+            "America/Vancovuer",
+        ],
+    )
+
+    assert result.exit_code == 1
+    assert "Error: unknown timezone 'America/Vancovuer'" in result.stdout
+    assert not (tmp_path / "cron" / "jobs.json").exists()
diff --git a/tests/test_cron_service.py b/tests/test_cron_service.py
new file mode 100644
index 0000000..07e990a
--- /dev/null
+++ b/tests/test_cron_service.py
@@ -0,0 +1,30 @@
+import pytest
+
+from nanobot.cron.service import CronService
+from nanobot.cron.types import CronSchedule
+
+
+def test_add_job_rejects_unknown_timezone(tmp_path) -> None:
+    service = CronService(tmp_path / "cron" / "jobs.json")
+
+    with pytest.raises(ValueError, match="unknown timezone 'America/Vancovuer'"):
+        service.add_job(
+            name="tz typo",
+            schedule=CronSchedule(kind="cron", expr="0 9 * * *", tz="America/Vancovuer"),
+            message="hello",
+        )
+
+    assert service.list_jobs(include_disabled=True) == []
+
+
+def test_add_job_accepts_valid_timezone(tmp_path) -> None:
+    service = CronService(tmp_path / "cron" / "jobs.json")
+
+    job = service.add_job(
+        name="tz ok",
+        schedule=CronSchedule(kind="cron", expr="0 9 * * *", tz="America/Vancouver"),
+        message="hello",
+    )
+
+    assert job.schedule.tz == "America/Vancouver"
+    assert job.state.next_run_at_ms is not None

From 166351799894d2159465ad7b3753ece78b977cec Mon Sep 17 00:00:00 2001
From: Your Name <you@example.com>
Date: Thu, 19 Feb 2026 03:00:44 +0800
Subject: [PATCH 06/35] feat: Add VolcEngine LLM provider support

- Add VolcEngine ProviderSpec entry in registry.py
- Add volcengine to ProvidersConfig class in schema.py
- Update model providers table in README.md
- Add description about VolcEngine coding plan endpoint
---
 README.md                     |  2 ++
 nanobot/config/schema.py      |  1 +
 nanobot/providers/registry.py | 18 ++++++++++++++++++
 3 files changed, 21 insertions(+)

diff --git a/README.md b/README.md
index a474367..94cdc88 100644
--- a/README.md
+++ b/README.md
@@ -578,6 +578,7 @@ Config file: `~/.nanobot/config.json`
 > - **Groq** provides free voice transcription via Whisper. If configured, Telegram voice messages will be automatically transcribed.
 > - **Zhipu Coding Plan**: If you're on Zhipu's coding plan, set `"apiBase": "https://open.bigmodel.cn/api/coding/paas/v4"` in your zhipu provider config.
 > - **MiniMax (Mainland China)**: If your API key is from MiniMax's mainland China platform (minimaxi.com), set `"apiBase": "https://api.minimaxi.com/v1"` in your minimax provider config.
+> - **VolcEngine Coding Plan**: If you're on VolcEngine's coding plan, set `"apiBase": "https://ark.cn-beijing.volces.com/api/coding/v3"` in your volcengine provider config.
 
 | Provider | Purpose | Get API Key |
 |----------|---------|-------------|
@@ -591,6 +592,7 @@ Config file: `~/.nanobot/config.json`
 | `minimax` | LLM (MiniMax direct) | [platform.minimax.io](https://platform.minimax.io) |
 | `aihubmix` | LLM (API gateway, access to all models) | [aihubmix.com](https://aihubmix.com) |
 | `siliconflow` | LLM (SiliconFlow/硅基流动, API gateway) | [siliconflow.cn](https://siliconflow.cn) |
+| `volcengine` | LLM (VolcEngine/火山引擎) | [volcengine.com](https://www.volcengine.com) |
 | `dashscope` | LLM (Qwen) | [dashscope.console.aliyun.com](https://dashscope.console.aliyun.com) |
 | `moonshot` | LLM (Moonshot/Kimi) | [platform.moonshot.cn](https://platform.moonshot.cn) |
 | `zhipu` | LLM (Zhipu GLM) | [open.bigmodel.cn](https://open.bigmodel.cn) |
diff --git a/nanobot/config/schema.py b/nanobot/config/schema.py
index ce9634c..0d0c68f 100644
--- a/nanobot/config/schema.py
+++ b/nanobot/config/schema.py
@@ -220,6 +220,7 @@ class ProvidersConfig(Base):
     minimax: ProviderConfig = Field(default_factory=ProviderConfig)
     aihubmix: ProviderConfig = Field(default_factory=ProviderConfig)  # AiHubMix API gateway
     siliconflow: ProviderConfig = Field(default_factory=ProviderConfig)  # SiliconFlow (硅基流动) API gateway
+    volcengine: ProviderConfig = Field(default_factory=ProviderConfig)  # VolcEngine (火山引擎) API gateway
     openai_codex: ProviderConfig = Field(default_factory=ProviderConfig)  # OpenAI Codex (OAuth)
     github_copilot: ProviderConfig = Field(default_factory=ProviderConfig)  # Github Copilot (OAuth)
 
diff --git a/nanobot/providers/registry.py b/nanobot/providers/registry.py
index 49b735c..e44720a 100644
--- a/nanobot/providers/registry.py
+++ b/nanobot/providers/registry.py
@@ -137,6 +137,24 @@ PROVIDERS: tuple[ProviderSpec, ...] = (
         model_overrides=(),
     ),
 
+    # VolcEngine (火山引擎): OpenAI-compatible gateway
+    ProviderSpec(
+        name="volcengine",
+        keywords=("volcengine", "volces", "ark"),
+        env_key="OPENAI_API_KEY",
+        display_name="VolcEngine",
+        litellm_prefix="openai",
+        skip_prefixes=(),
+        env_extras=(),
+        is_gateway=True,
+        is_local=False,
+        detect_by_key_prefix="",
+        detect_by_base_keyword="volces",
+        default_api_base="https://ark.cn-beijing.volces.com/api/v3",
+        strip_model_prefix=False,
+        model_overrides=(),
+    ),
+
     # === Standard providers (matched by model-name keywords) ===============
 
     # Anthropic: LiteLLM recognizes "claude-*" natively, no prefix needed.

From c865b293a9a772c000eed0cda63eecbd2efa472e Mon Sep 17 00:00:00 2001
From: Darye <54469750+DaryeDev@users.noreply.github.com>
Date: Wed, 18 Feb 2026 20:18:27 +0100
Subject: [PATCH 07/35] feat: enhance message context handling by adding
 message_id parameter

---
 nanobot/agent/loop.py          |  8 ++++----
 nanobot/agent/tools/message.py | 14 +++++++++++---
 2 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/nanobot/agent/loop.py b/nanobot/agent/loop.py
index e5a5183..7855297 100644
--- a/nanobot/agent/loop.py
+++ b/nanobot/agent/loop.py
@@ -133,11 +133,11 @@ class AgentLoop:
         await self._mcp_stack.__aenter__()
         await connect_mcp_servers(self._mcp_servers, self.tools, self._mcp_stack)
 
-    def _set_tool_context(self, channel: str, chat_id: str) -> None:
+    def _set_tool_context(self, channel: str, chat_id: str, message_id: str | None = None) -> None:
         """Update context for all tools that need routing info."""
         if message_tool := self.tools.get("message"):
             if isinstance(message_tool, MessageTool):
-                message_tool.set_context(channel, chat_id)
+                message_tool.set_context(channel, chat_id, message_id)
 
         if spawn_tool := self.tools.get("spawn"):
             if isinstance(spawn_tool, SpawnTool):
@@ -321,7 +321,7 @@ class AgentLoop:
         if len(session.messages) > self.memory_window:
             asyncio.create_task(self._consolidate_memory(session))
 
-        self._set_tool_context(msg.channel, msg.chat_id)
+        self._set_tool_context(msg.channel, msg.chat_id, msg.metadata.get("message_id"))
         initial_messages = self.context.build_messages(
             history=session.get_history(max_messages=self.memory_window),
             current_message=msg.content,
@@ -379,7 +379,7 @@ class AgentLoop:
         
         session_key = f"{origin_channel}:{origin_chat_id}"
         session = self.sessions.get_or_create(session_key)
-        self._set_tool_context(origin_channel, origin_chat_id)
+        self._set_tool_context(origin_channel, origin_chat_id, msg.metadata.get("message_id"))
         initial_messages = self.context.build_messages(
             history=session.get_history(max_messages=self.memory_window),
             current_message=msg.content,
diff --git a/nanobot/agent/tools/message.py b/nanobot/agent/tools/message.py
index 3853725..10947c4 100644
--- a/nanobot/agent/tools/message.py
+++ b/nanobot/agent/tools/message.py
@@ -13,16 +13,19 @@ class MessageTool(Tool):
         self, 
         send_callback: Callable[[OutboundMessage], Awaitable[None]] | None = None,
         default_channel: str = "",
-        default_chat_id: str = ""
+        default_chat_id: str = "",
+        default_message_id: str | None = None
     ):
         self._send_callback = send_callback
         self._default_channel = default_channel
         self._default_chat_id = default_chat_id
+        self._default_message_id = default_message_id
     
-    def set_context(self, channel: str, chat_id: str) -> None:
+    def set_context(self, channel: str, chat_id: str, message_id: str | None = None) -> None:
         """Set the current message context."""
         self._default_channel = channel
         self._default_chat_id = chat_id
+        self._default_message_id = message_id
     
     def set_send_callback(self, callback: Callable[[OutboundMessage], Awaitable[None]]) -> None:
         """Set the callback for sending messages."""
@@ -67,11 +70,13 @@ class MessageTool(Tool):
         content: str, 
         channel: str | None = None, 
         chat_id: str | None = None,
+        message_id: str | None = None,
         media: list[str] | None = None,
         **kwargs: Any
     ) -> str:
         channel = channel or self._default_channel
         chat_id = chat_id or self._default_chat_id
+        message_id = message_id or self._default_message_id
         
         if not channel or not chat_id:
             return "Error: No target channel/chat specified"
@@ -83,7 +88,10 @@ class MessageTool(Tool):
             channel=channel,
             chat_id=chat_id,
             content=content,
-            media=media or []
+            media=media or [],
+            metadata={
+                "message_id": message_id,
+            }
         )
         
         try:

From 3ac55130042ad7b98a2416ef3802bc1a576df248 Mon Sep 17 00:00:00 2001
From: Darye <54469750+DaryeDev@users.noreply.github.com>
Date: Wed, 18 Feb 2026 20:27:48 +0100
Subject: [PATCH 08/35] If given a message_id to telegram provider send, the
 bot will try to reply to that message

---
 nanobot/channels/telegram.py | 36 +++++++++++++++++++++++++++++++-----
 1 file changed, 31 insertions(+), 5 deletions(-)

diff --git a/nanobot/channels/telegram.py b/nanobot/channels/telegram.py
index 39924b3..3a90d42 100644
--- a/nanobot/channels/telegram.py
+++ b/nanobot/channels/telegram.py
@@ -5,7 +5,7 @@ from __future__ import annotations
 import asyncio
 import re
 from loguru import logger
-from telegram import BotCommand, Update
+from telegram import BotCommand, Update, ReplyParameters
 from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
 from telegram.request import HTTPXRequest
 
@@ -224,6 +224,15 @@ class TelegramChannel(BaseChannel):
             logger.error(f"Invalid chat_id: {msg.chat_id}")
             return
 
+        # Build reply parameters (Will reply to the message if it exists)
+        reply_to_message_id = msg.metadata.get("message_id")
+        reply_params = None
+        if reply_to_message_id:
+            reply_params = ReplyParameters(
+                message_id=reply_to_message_id,
+                allow_sending_without_reply=True
+            )
+
         # Send media files
         for media_path in (msg.media or []):
             try:
@@ -235,22 +244,39 @@ class TelegramChannel(BaseChannel):
                 }.get(media_type, self._app.bot.send_document)
                 param = "photo" if media_type == "photo" else media_type if media_type in ("voice", "audio") else "document"
                 with open(media_path, 'rb') as f:
-                    await sender(chat_id=chat_id, **{param: f})
+                    await sender(
+                        chat_id=chat_id, 
+                        **{param: f},
+                        reply_parameters=reply_params
+                    )
             except Exception as e:
                 filename = media_path.rsplit("/", 1)[-1]
                 logger.error(f"Failed to send media {media_path}: {e}")
-                await self._app.bot.send_message(chat_id=chat_id, text=f"[Failed to send: {filename}]")
+                await self._app.bot.send_message(
+                    chat_id=chat_id, 
+                    text=f"[Failed to send: {filename}]",
+                    reply_parameters=reply_params
+                )
 
         # Send text content
         if msg.content and msg.content != "[empty message]":
             for chunk in _split_message(msg.content):
                 try:
                     html = _markdown_to_telegram_html(chunk)
-                    await self._app.bot.send_message(chat_id=chat_id, text=html, parse_mode="HTML")
+                    await self._app.bot.send_message(
+                        chat_id=chat_id, 
+                        text=html, 
+                        parse_mode="HTML",
+                        reply_parameters=reply_params
+                    )
                 except Exception as e:
                     logger.warning(f"HTML parse failed, falling back to plain text: {e}")
                     try:
-                        await self._app.bot.send_message(chat_id=chat_id, text=chunk)
+                        await self._app.bot.send_message(
+                            chat_id=chat_id, 
+                            text=chunk,
+                            reply_parameters=reply_params
+                        )
                     except Exception as e2:
                         logger.error(f"Error sending Telegram message: {e2}")
     

From 4367038a95a8ae96e0fdfbb37b5488cd9a9fbe49 Mon Sep 17 00:00:00 2001
From: Clayton Wilson <claytonwilson@protonmail.com>
Date: Wed, 18 Feb 2026 13:32:06 -0600
Subject: [PATCH 09/35] fix: make cron run command actually execute the agent

Wire up an AgentLoop with an on_job callback in the cron_run CLI
command so the job's message is sent to the agent and the response
is printed. Previously, CronService was created with no on_job
callback, causing _execute_job to skip execution silently and
always report success.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 nanobot/cli/commands.py | 44 ++++++++++++++++++++++++++++++++++++-----
 1 file changed, 39 insertions(+), 5 deletions(-)

diff --git a/nanobot/cli/commands.py b/nanobot/cli/commands.py
index 2f4ba7b..a45b4a7 100644
--- a/nanobot/cli/commands.py
+++ b/nanobot/cli/commands.py
@@ -860,17 +860,51 @@ def cron_run(
     force: bool = typer.Option(False, "--force", "-f", help="Run even if disabled"),
 ):
     """Manually run a job."""
-    from nanobot.config.loader import get_data_dir
+    from nanobot.config.loader import load_config, get_data_dir
     from nanobot.cron.service import CronService
-    
+    from nanobot.bus.queue import MessageBus
+    from nanobot.agent.loop import AgentLoop
+    from loguru import logger
+    logger.disable("nanobot")
+
+    config = load_config()
+    provider = _make_provider(config)
+    bus = MessageBus()
+    agent_loop = AgentLoop(
+        bus=bus,
+        provider=provider,
+        workspace=config.workspace_path,
+        model=config.agents.defaults.model,
+        max_iterations=config.agents.defaults.max_tool_iterations,
+        memory_window=config.agents.defaults.memory_window,
+        exec_config=config.tools.exec,
+        restrict_to_workspace=config.tools.restrict_to_workspace,
+    )
+
     store_path = get_data_dir() / "cron" / "jobs.json"
     service = CronService(store_path)
-    
+
+    result_holder = []
+
+    async def on_job(job):
+        response = await agent_loop.process_direct(
+            job.payload.message,
+            session_key=f"cron:{job.id}",
+            channel=job.payload.channel or "cli",
+            chat_id=job.payload.to or "direct",
+        )
+        result_holder.append(response)
+        return response
+
+    service.on_job = on_job
+
     async def run():
         return await service.run_job(job_id, force=force)
-    
+
     if asyncio.run(run()):
-        console.print(f"[green]✓[/green] Job executed")
+        console.print("[green]✓[/green] Job executed")
+        if result_holder:
+            _print_agent_response(result_holder[0], render_markdown=True)
     else:
         console.print(f"[red]Failed to run job {job_id}[/red]")
 

From 107a380e61a57d72a23ea84c6ba8b68e0e2936cb Mon Sep 17 00:00:00 2001
From: Nikolas de Hor <nikolasdehor79@gmail.com>
Date: Wed, 18 Feb 2026 21:22:22 -0300
Subject: [PATCH 10/35] fix: prevent duplicate memory consolidation tasks per
 session
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add a `_consolidating` set to track which sessions have an active
consolidation task. Skip creating a new task if one is already in
progress for the same session key, and clean up the flag when done.

This prevents the excessive API calls reported when messages exceed
the memory_window threshold — previously every single message after
the threshold triggered a new background consolidation.

Closes #751
---
 nanobot/agent/loop.py | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/nanobot/agent/loop.py b/nanobot/agent/loop.py
index e5a5183..0e5d3b3 100644
--- a/nanobot/agent/loop.py
+++ b/nanobot/agent/loop.py
@@ -89,6 +89,7 @@ class AgentLoop:
         self._mcp_servers = mcp_servers or {}
         self._mcp_stack: AsyncExitStack | None = None
         self._mcp_connected = False
+        self._consolidating: set[str] = set()  # Session keys with consolidation in progress
         self._register_default_tools()
     
     def _register_default_tools(self) -> None:
@@ -318,8 +319,16 @@ class AgentLoop:
             return OutboundMessage(channel=msg.channel, chat_id=msg.chat_id,
                                   content="🐈 nanobot commands:\n/new — Start a new conversation\n/help — Show available commands")
         
-        if len(session.messages) > self.memory_window:
-            asyncio.create_task(self._consolidate_memory(session))
+        if len(session.messages) > self.memory_window and session.key not in self._consolidating:
+            self._consolidating.add(session.key)
+
+            async def _consolidate_and_unlock():
+                try:
+                    await self._consolidate_memory(session)
+                finally:
+                    self._consolidating.discard(session.key)
+
+            asyncio.create_task(_consolidate_and_unlock())
 
         self._set_tool_context(msg.channel, msg.chat_id)
         initial_messages = self.context.build_messages(

From 33d760d31213edf8af992026d3a7e3da33bca52f Mon Sep 17 00:00:00 2001
From: Nikolas de Hor <nikolasdehor79@gmail.com>
Date: Wed, 18 Feb 2026 21:27:13 -0300
Subject: [PATCH 11/35] fix: handle /help command directly in Telegram,
 bypassing ACL check
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The /help command was routed through _forward_command → _handle_message
→ is_allowed(), which denied access to users not in the allowFrom list.
Since /help is purely informational, it should be accessible to all
users — similar to how /start already works with its own handler.

Add a dedicated _on_help handler that replies directly without going
through the message bus access control.

Closes #687
---
 nanobot/channels/telegram.py | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/nanobot/channels/telegram.py b/nanobot/channels/telegram.py
index 39924b3..fa48fef 100644
--- a/nanobot/channels/telegram.py
+++ b/nanobot/channels/telegram.py
@@ -146,7 +146,7 @@ class TelegramChannel(BaseChannel):
         # Add command handlers
         self._app.add_handler(CommandHandler("start", self._on_start))
         self._app.add_handler(CommandHandler("new", self._forward_command))
-        self._app.add_handler(CommandHandler("help", self._forward_command))
+        self._app.add_handler(CommandHandler("help", self._on_help))
         
         # Add message handler for text, photos, voice, documents
         self._app.add_handler(
@@ -258,14 +258,28 @@ class TelegramChannel(BaseChannel):
         """Handle /start command."""
         if not update.message or not update.effective_user:
             return
-        
+
         user = update.effective_user
         await update.message.reply_text(
             f"👋 Hi {user.first_name}! I'm nanobot.\n\n"
             "Send me a message and I'll respond!\n"
             "Type /help to see available commands."
         )
-    
+
+    async def _on_help(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        """Handle /help command directly, bypassing access control.
+
+        /help is informational and should be accessible to all users,
+        even those not in the allowFrom list.
+        """
+        if not update.message:
+            return
+        await update.message.reply_text(
+            "🐈 nanobot commands:\n"
+            "/new — Start a new conversation\n"
+            "/help — Show available commands"
+        )
+
     @staticmethod
     def _sender_id(user) -> str:
         """Build sender_id with username for allowlist matching."""

From 464352c664c0c059457b8cceafbaa3844011a1d9 Mon Sep 17 00:00:00 2001
From: Nikolas de Hor <nikolasdehor79@gmail.com>
Date: Wed, 18 Feb 2026 21:29:10 -0300
Subject: [PATCH 12/35] fix: allow one retry for models that send interim text
 before tool calls

Some LLM providers (MiniMax, Gemini Flash, GPT-4.1, etc.) send an
initial text-only response like "Let me investigate..." before actually
making tool calls. The agent loop previously broke immediately on any
text response without tool calls, preventing these models from ever
using tools.

Now, when the model responds with text but hasn't used any tools yet,
the loop forwards the text as progress to the user and gives the model
one additional iteration to make tool calls. This is limited to a
single retry to prevent infinite loops.

Closes #705
---
 nanobot/agent/loop.py | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/nanobot/agent/loop.py b/nanobot/agent/loop.py
index e5a5183..6acbb38 100644
--- a/nanobot/agent/loop.py
+++ b/nanobot/agent/loop.py
@@ -183,6 +183,7 @@ class AgentLoop:
         iteration = 0
         final_content = None
         tools_used: list[str] = []
+        text_only_retried = False
 
         while iteration < self.max_iterations:
             iteration += 1
@@ -226,6 +227,21 @@ class AgentLoop:
                     )
             else:
                 final_content = self._strip_think(response.content)
+                # Some models (MiniMax, Gemini Flash, GPT-4.1, etc.) send an
+                # interim text response (e.g. "Let me investigate...") before
+                # making tool calls. If no tools have been used yet and we
+                # haven't already retried, forward the text as progress and
+                # give the model one more chance to use tools.
+                if not tools_used and not text_only_retried and final_content:
+                    text_only_retried = True
+                    logger.debug(f"Interim text response (no tools used yet), retrying: {final_content[:80]}")
+                    if on_progress:
+                        await on_progress(final_content)
+                    messages = self.context.add_assistant_message(
+                        messages, response.content,
+                        reasoning_content=response.reasoning_content,
+                    )
+                    continue
                 break
 
         return final_content, tools_used

From c7b5dd93502a829da18e2a7ef2253ae3298f2f28 Mon Sep 17 00:00:00 2001
From: chtangwin <chtangwin@gmail.com>
Date: Tue, 10 Feb 2026 17:31:45 +0800
Subject: [PATCH 13/35] Fix: Ensure UTF-8 encoding for all file operations

---
 nanobot/agent/loop.py      |  3 ++-
 nanobot/agent/subagent.py  |  4 ++--
 nanobot/config/loader.py   |  2 +-
 nanobot/cron/service.py    |  4 ++--
 nanobot/session/manager.py | 11 ++++++-----
 5 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/nanobot/agent/loop.py b/nanobot/agent/loop.py
index e5a5183..1cd5730 100644
--- a/nanobot/agent/loop.py
+++ b/nanobot/agent/loop.py
@@ -206,7 +206,7 @@ class AgentLoop:
                         "type": "function",
                         "function": {
                             "name": tc.name,
-                            "arguments": json.dumps(tc.arguments)
+                            "arguments": json.dumps(tc.arguments, ensure_ascii=False)
                         }
                     }
                     for tc in response.tool_calls
@@ -388,6 +388,7 @@ class AgentLoop:
         )
         final_content, _ = await self._run_agent_loop(initial_messages)
 
+
         if final_content is None:
             final_content = "Background task completed."
         
diff --git a/nanobot/agent/subagent.py b/nanobot/agent/subagent.py
index 203836a..ffefc08 100644
--- a/nanobot/agent/subagent.py
+++ b/nanobot/agent/subagent.py
@@ -146,7 +146,7 @@ class SubagentManager:
                             "type": "function",
                             "function": {
                                 "name": tc.name,
-                                "arguments": json.dumps(tc.arguments),
+                                "arguments": json.dumps(tc.arguments, ensure_ascii=False),
                             },
                         }
                         for tc in response.tool_calls
@@ -159,7 +159,7 @@ class SubagentManager:
                     
                     # Execute tools
                     for tool_call in response.tool_calls:
-                        args_str = json.dumps(tool_call.arguments)
+                        args_str = json.dumps(tool_call.arguments, ensure_ascii=False)
                         logger.debug(f"Subagent [{task_id}] executing: {tool_call.name} with arguments: {args_str}")
                         result = await tools.execute(tool_call.name, tool_call.arguments)
                         messages.append({
diff --git a/nanobot/config/loader.py b/nanobot/config/loader.py
index 560c1f5..134e95f 100644
--- a/nanobot/config/loader.py
+++ b/nanobot/config/loader.py
@@ -31,7 +31,7 @@ def load_config(config_path: Path | None = None) -> Config:
 
     if path.exists():
         try:
-            with open(path) as f:
+            with open(path, encoding="utf-8") as f:
                 data = json.load(f)
             data = _migrate_config(data)
             return Config.model_validate(data)
diff --git a/nanobot/cron/service.py b/nanobot/cron/service.py
index 14666e8..3c77452 100644
--- a/nanobot/cron/service.py
+++ b/nanobot/cron/service.py
@@ -66,7 +66,7 @@ class CronService:
         
         if self.store_path.exists():
             try:
-                data = json.loads(self.store_path.read_text())
+                data = json.loads(self.store_path.read_text(encoding="utf-8"))
                 jobs = []
                 for j in data.get("jobs", []):
                     jobs.append(CronJob(
@@ -148,7 +148,7 @@ class CronService:
             ]
         }
         
-        self.store_path.write_text(json.dumps(data, indent=2))
+        self.store_path.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
     
     async def start(self) -> None:
         """Start the cron service."""
diff --git a/nanobot/session/manager.py b/nanobot/session/manager.py
index 752fce4..42df1b1 100644
--- a/nanobot/session/manager.py
+++ b/nanobot/session/manager.py
@@ -121,7 +121,7 @@ class SessionManager:
             created_at = None
             last_consolidated = 0
 
-            with open(path) as f:
+            with open(path, encoding="utf-8") as f:
                 for line in f:
                     line = line.strip()
                     if not line:
@@ -151,7 +151,7 @@ class SessionManager:
         """Save a session to disk."""
         path = self._get_session_path(session.key)
 
-        with open(path, "w") as f:
+        with open(path, "w", encoding="utf-8") as f:
             metadata_line = {
                 "_type": "metadata",
                 "created_at": session.created_at.isoformat(),
@@ -159,9 +159,10 @@ class SessionManager:
                 "metadata": session.metadata,
                 "last_consolidated": session.last_consolidated
             }
-            f.write(json.dumps(metadata_line) + "\n")
+            f.write(json.dumps(metadata_line, ensure_ascii=False) + "\n")
             for msg in session.messages:
-                f.write(json.dumps(msg) + "\n")
+                f.write(json.dumps(msg, ensure_ascii=False) + "\n")
+
 
         self._cache[session.key] = session
     
@@ -181,7 +182,7 @@ class SessionManager:
         for path in self.sessions_dir.glob("*.jsonl"):
             try:
                 # Read just the metadata line
-                with open(path) as f:
+                with open(path, encoding="utf-8") as f:
                     first_line = f.readline().strip()
                     if first_line:
                         data = json.loads(first_line)

From a2379a08ac5467e4b3e628a7264427be73759a9f Mon Sep 17 00:00:00 2001
From: chtangwin <chtangwin@gmail.com>
Date: Wed, 18 Feb 2026 18:37:17 -0800
Subject: [PATCH 14/35] Fix: Ensure UTF-8 encoding and ensure_ascii=False for
 remaining file/JSON operations

---
 nanobot/agent/tools/web.py   | 8 ++++----
 nanobot/channels/dingtalk.py | 2 +-
 nanobot/cli/commands.py      | 6 +++---
 nanobot/config/loader.py     | 4 ++--
 nanobot/heartbeat/service.py | 2 +-
 5 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/nanobot/agent/tools/web.py b/nanobot/agent/tools/web.py
index 9de1d3c..90cdda8 100644
--- a/nanobot/agent/tools/web.py
+++ b/nanobot/agent/tools/web.py
@@ -116,7 +116,7 @@ class WebFetchTool(Tool):
         # Validate URL before fetching
         is_valid, error_msg = _validate_url(url)
         if not is_valid:
-            return json.dumps({"error": f"URL validation failed: {error_msg}", "url": url})
+            return json.dumps({"error": f"URL validation failed: {error_msg}", "url": url}, ensure_ascii=False)
 
         try:
             async with httpx.AsyncClient(
@@ -131,7 +131,7 @@ class WebFetchTool(Tool):
             
             # JSON
             if "application/json" in ctype:
-                text, extractor = json.dumps(r.json(), indent=2), "json"
+                text, extractor = json.dumps(r.json(), indent=2, ensure_ascii=False), "json"
             # HTML
             elif "text/html" in ctype or r.text[:256].lower().startswith(("<!doctype", "<html")):
                 doc = Document(r.text)
@@ -146,9 +146,9 @@ class WebFetchTool(Tool):
                 text = text[:max_chars]
             
             return json.dumps({"url": url, "finalUrl": str(r.url), "status": r.status_code,
-                              "extractor": extractor, "truncated": truncated, "length": len(text), "text": text})
+                              "extractor": extractor, "truncated": truncated, "length": len(text), "text": text}, ensure_ascii=False)
         except Exception as e:
-            return json.dumps({"error": str(e), "url": url})
+            return json.dumps({"error": str(e), "url": url}, ensure_ascii=False)
     
     def _to_markdown(self, html: str) -> str:
         """Convert HTML to markdown."""
diff --git a/nanobot/channels/dingtalk.py b/nanobot/channels/dingtalk.py
index 4a8cdd9..6b27af4 100644
--- a/nanobot/channels/dingtalk.py
+++ b/nanobot/channels/dingtalk.py
@@ -208,7 +208,7 @@ class DingTalkChannel(BaseChannel):
             "msgParam": json.dumps({
                 "text": msg.content,
                 "title": "Nanobot Reply",
-            }),
+            }, ensure_ascii=False),
         }
 
         if not self._http:
diff --git a/nanobot/cli/commands.py b/nanobot/cli/commands.py
index 2f4ba7b..d879d58 100644
--- a/nanobot/cli/commands.py
+++ b/nanobot/cli/commands.py
@@ -243,7 +243,7 @@ Information about the user goes here.
     for filename, content in templates.items():
         file_path = workspace / filename
         if not file_path.exists():
-            file_path.write_text(content)
+            file_path.write_text(content, encoding="utf-8")
             console.print(f"  [dim]Created {filename}[/dim]")
     
     # Create memory directory and MEMORY.md
@@ -266,12 +266,12 @@ This file stores important information that should persist across sessions.
 ## Important Notes
 
 (Things to remember)
-""")
+""", encoding="utf-8")
         console.print("  [dim]Created memory/MEMORY.md[/dim]")
     
     history_file = memory_dir / "HISTORY.md"
     if not history_file.exists():
-        history_file.write_text("")
+        history_file.write_text("", encoding="utf-8")
         console.print("  [dim]Created memory/HISTORY.md[/dim]")
 
     # Create skills directory for custom user skills
diff --git a/nanobot/config/loader.py b/nanobot/config/loader.py
index 134e95f..c789efd 100644
--- a/nanobot/config/loader.py
+++ b/nanobot/config/loader.py
@@ -55,8 +55,8 @@ def save_config(config: Config, config_path: Path | None = None) -> None:
 
     data = config.model_dump(by_alias=True)
 
-    with open(path, "w") as f:
-        json.dump(data, f, indent=2)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)
 
 
 def _migrate_config(data: dict) -> dict:
diff --git a/nanobot/heartbeat/service.py b/nanobot/heartbeat/service.py
index 221ed27..a51e5a0 100644
--- a/nanobot/heartbeat/service.py
+++ b/nanobot/heartbeat/service.py
@@ -65,7 +65,7 @@ class HeartbeatService:
         """Read HEARTBEAT.md content."""
         if self.heartbeat_file.exists():
             try:
-                return self.heartbeat_file.read_text()
+                return self.heartbeat_file.read_text(encoding="utf-8")
             except Exception:
                 return None
         return None

From 124c611426eefe06aeb9a5b3d33338286228bb8a Mon Sep 17 00:00:00 2001
From: chtangwin <chtangwin@gmail.com>
Date: Wed, 18 Feb 2026 18:46:23 -0800
Subject: [PATCH 15/35] Fix: Add ensure_ascii=False to WhatsApp send payload

The send() payload contains user message content (msg.content) which
may include non-ASCII characters (e.g. CJK, German umlauts, emoji).

The auth frame and Discord heartbeat/identify payloads are left
unchanged as they only carry ASCII protocol fields.
---
 nanobot/channels/whatsapp.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nanobot/channels/whatsapp.py b/nanobot/channels/whatsapp.py
index 0cf2dd7..f799347 100644
--- a/nanobot/channels/whatsapp.py
+++ b/nanobot/channels/whatsapp.py
@@ -87,7 +87,7 @@ class WhatsAppChannel(BaseChannel):
                 "to": msg.chat_id,
                 "text": msg.content
             }
-            await self._ws.send(json.dumps(payload))
+            await self._ws.send(json.dumps(payload, ensure_ascii=False))
         except Exception as e:
             logger.error(f"Error sending WhatsApp message: {e}")
     

From 523b2982f4fb2c0dcf74e3a4bb01ebf2a77fd529 Mon Sep 17 00:00:00 2001
From: Darye <54469750+DaryeDev@users.noreply.github.com>
Date: Thu, 19 Feb 2026 05:22:00 +0100
Subject: [PATCH 16/35] fix: fixed not logging tool uses if a think fragment
 had them attached.

if a think fragment had a tool attached, the tool use would not log. now it does
---
 nanobot/agent/loop.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/nanobot/agent/loop.py b/nanobot/agent/loop.py
index e5a5183..6b45b28 100644
--- a/nanobot/agent/loop.py
+++ b/nanobot/agent/loop.py
@@ -198,7 +198,9 @@ class AgentLoop:
             if response.has_tool_calls:
                 if on_progress:
                     clean = self._strip_think(response.content)
-                    await on_progress(clean or self._tool_hint(response.tool_calls))
+                    if clean: 
+                        await on_progress(clean)
+                    await on_progress(self._tool_hint(response.tool_calls))
 
                 tool_call_dicts = [
                     {

From 1b49bf96021eba1bfc95e3c0a1ab6cae36271973 Mon Sep 17 00:00:00 2001
From: Nikolas de Hor <nikolasdehor79@gmail.com>
Date: Thu, 19 Feb 2026 10:26:49 -0300
Subject: [PATCH 17/35] fix: avoid duplicate messages on retry and reset
 final_content

Address review feedback:
- Remove on_progress call for interim text to prevent duplicate
  messages when the model simply answers a direct question
- Reset final_content to None before continue to avoid stale
  interim text leaking as the final response on empty retry

Closes #705
---
 nanobot/agent/loop.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/nanobot/agent/loop.py b/nanobot/agent/loop.py
index 6acbb38..532488f 100644
--- a/nanobot/agent/loop.py
+++ b/nanobot/agent/loop.py
@@ -230,17 +230,18 @@ class AgentLoop:
                 # Some models (MiniMax, Gemini Flash, GPT-4.1, etc.) send an
                 # interim text response (e.g. "Let me investigate...") before
                 # making tool calls. If no tools have been used yet and we
-                # haven't already retried, forward the text as progress and
-                # give the model one more chance to use tools.
+                # haven't already retried, add the text to the conversation
+                # and give the model one more chance to use tools.
+                # We do NOT forward the interim text as progress to avoid
+                # duplicate messages when the model simply answers directly.
                 if not tools_used and not text_only_retried and final_content:
                     text_only_retried = True
                     logger.debug(f"Interim text response (no tools used yet), retrying: {final_content[:80]}")
-                    if on_progress:
-                        await on_progress(final_content)
                     messages = self.context.add_assistant_message(
                         messages, response.content,
                         reasoning_content=response.reasoning_content,
                     )
+                    final_content = None
                     continue
                 break
 

From 3b4763b3f989c00da674933f459730717ea7385a Mon Sep 17 00:00:00 2001
From: tercerapersona <tercera@persona.com>
Date: Thu, 19 Feb 2026 11:05:22 -0300
Subject: [PATCH 18/35] feat: add Anthropic prompt caching via cache_control

Inject cache_control: {"type": "ephemeral"} on the system message and
last tool definition for providers that support prompt caching. Adds
supports_prompt_caching flag to ProviderSpec (enabled for Anthropic only)
and skips caching when routing through a gateway.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 nanobot/providers/litellm_provider.py | 43 +++++++++++++++++++++++++--
 nanobot/providers/registry.py         |  4 +++
 2 files changed, 45 insertions(+), 2 deletions(-)

diff --git a/nanobot/providers/litellm_provider.py b/nanobot/providers/litellm_provider.py
index 8cc4e35..950a138 100644
--- a/nanobot/providers/litellm_provider.py
+++ b/nanobot/providers/litellm_provider.py
@@ -93,6 +93,41 @@ class LiteLLMProvider(LLMProvider):
         
         return model
     
+    def _supports_cache_control(self, model: str) -> bool:
+        """Return True when the provider supports cache_control on content blocks."""
+        if self._gateway is not None:
+            return False
+        spec = find_by_model(model)
+        return spec is not None and spec.supports_prompt_caching
+
+    def _apply_cache_control(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None,
+    ) -> tuple[list[dict[str, Any]], list[dict[str, Any]] | None]:
+        """Return copies of messages and tools with cache_control injected."""
+        # Transform the system message
+        new_messages = []
+        for msg in messages:
+            if msg.get("role") == "system":
+                content = msg["content"]
+                if isinstance(content, str):
+                    new_content = [{"type": "text", "text": content, "cache_control": {"type": "ephemeral"}}]
+                else:
+                    new_content = list(content)
+                    new_content[-1] = {**new_content[-1], "cache_control": {"type": "ephemeral"}}
+                new_messages.append({**msg, "content": new_content})
+            else:
+                new_messages.append(msg)
+
+        # Add cache_control to the last tool definition
+        new_tools = tools
+        if tools:
+            new_tools = list(tools)
+            new_tools[-1] = {**new_tools[-1], "cache_control": {"type": "ephemeral"}}
+
+        return new_messages, new_tools
+
     def _apply_model_overrides(self, model: str, kwargs: dict[str, Any]) -> None:
         """Apply model-specific parameter overrides from the registry."""
         model_lower = model.lower()
@@ -124,8 +159,12 @@ class LiteLLMProvider(LLMProvider):
         Returns:
             LLMResponse with content and/or tool calls.
         """
-        model = self._resolve_model(model or self.default_model)
-        
+        original_model = model or self.default_model
+        model = self._resolve_model(original_model)
+
+        if self._supports_cache_control(original_model):
+            messages, tools = self._apply_cache_control(messages, tools)
+
         # Clamp max_tokens to at least 1 — negative or zero values cause
         # LiteLLM to reject the request with "max_tokens must be at least 1".
         max_tokens = max(1, max_tokens)
diff --git a/nanobot/providers/registry.py b/nanobot/providers/registry.py
index 49b735c..2584e0e 100644
--- a/nanobot/providers/registry.py
+++ b/nanobot/providers/registry.py
@@ -57,6 +57,9 @@ class ProviderSpec:
     # Direct providers bypass LiteLLM entirely (e.g., CustomProvider)
     is_direct: bool = False
 
+    # Provider supports cache_control on content blocks (e.g. Anthropic prompt caching)
+    supports_prompt_caching: bool = False
+
     @property
     def label(self) -> str:
         return self.display_name or self.name.title()
@@ -155,6 +158,7 @@ PROVIDERS: tuple[ProviderSpec, ...] = (
         default_api_base="",
         strip_model_prefix=False,
         model_overrides=(),
+        supports_prompt_caching=True,
     ),
 
     # OpenAI: LiteLLM recognizes "gpt-*" natively, no prefix needed.

From 53b83a38e2dc44b91e7890594abb1bd2220a6b03 Mon Sep 17 00:00:00 2001
From: Nikolas de Hor <nikolasdehor79@gmail.com>
Date: Thu, 19 Feb 2026 17:19:36 -0300
Subject: [PATCH 19/35] fix: use loguru native formatting to prevent KeyError
 on messages containing curly braces

Closes #857
---
 nanobot/agent/loop.py              | 12 ++++++------
 nanobot/agent/subagent.py          |  4 ++--
 nanobot/agent/tools/mcp.py         |  2 +-
 nanobot/bus/queue.py               |  2 +-
 nanobot/channels/dingtalk.py       | 18 +++++++++---------
 nanobot/channels/discord.py        | 10 +++++-----
 nanobot/channels/email.py          |  4 ++--
 nanobot/channels/feishu.py         | 26 +++++++++++++-------------
 nanobot/channels/manager.py        |  6 +++---
 nanobot/channels/mochat.py         | 24 ++++++++++++------------
 nanobot/channels/qq.py             |  6 +++---
 nanobot/channels/slack.py          |  8 ++++----
 nanobot/channels/telegram.py       | 16 ++++++++--------
 nanobot/channels/whatsapp.py       | 10 +++++-----
 nanobot/cron/service.py            |  4 ++--
 nanobot/heartbeat/service.py       |  4 ++--
 nanobot/providers/transcription.py |  2 +-
 nanobot/session/manager.py         |  2 +-
 18 files changed, 80 insertions(+), 80 deletions(-)

diff --git a/nanobot/agent/loop.py b/nanobot/agent/loop.py
index e5a5183..cbab5aa 100644
--- a/nanobot/agent/loop.py
+++ b/nanobot/agent/loop.py
@@ -219,7 +219,7 @@ class AgentLoop:
                 for tool_call in response.tool_calls:
                     tools_used.append(tool_call.name)
                     args_str = json.dumps(tool_call.arguments, ensure_ascii=False)
-                    logger.info(f"Tool call: {tool_call.name}({args_str[:200]})")
+                    logger.info("Tool call: {}({})", tool_call.name, args_str[:200])
                     result = await self.tools.execute(tool_call.name, tool_call.arguments)
                     messages = self.context.add_tool_result(
                         messages, tool_call.id, tool_call.name, result
@@ -247,7 +247,7 @@ class AgentLoop:
                     if response:
                         await self.bus.publish_outbound(response)
                 except Exception as e:
-                    logger.error(f"Error processing message: {e}")
+                    logger.error("Error processing message: {}", e)
                     await self.bus.publish_outbound(OutboundMessage(
                         channel=msg.channel,
                         chat_id=msg.chat_id,
@@ -292,7 +292,7 @@ class AgentLoop:
             return await self._process_system_message(msg)
         
         preview = msg.content[:80] + "..." if len(msg.content) > 80 else msg.content
-        logger.info(f"Processing message from {msg.channel}:{msg.sender_id}: {preview}")
+        logger.info("Processing message from {}:{}: {}", msg.channel, msg.sender_id, preview)
         
         key = session_key or msg.session_key
         session = self.sessions.get_or_create(key)
@@ -344,7 +344,7 @@ class AgentLoop:
             final_content = "I've completed processing but have no response to give."
         
         preview = final_content[:120] + "..." if len(final_content) > 120 else final_content
-        logger.info(f"Response to {msg.channel}:{msg.sender_id}: {preview}")
+        logger.info("Response to {}:{}: {}", msg.channel, msg.sender_id, preview)
         
         session.add_message("user", msg.content)
         session.add_message("assistant", final_content,
@@ -469,7 +469,7 @@ Respond with ONLY valid JSON, no markdown fences."""
                 text = text.split("\n", 1)[-1].rsplit("```", 1)[0].strip()
             result = json_repair.loads(text)
             if not isinstance(result, dict):
-                logger.warning(f"Memory consolidation: unexpected response type, skipping. Response: {text[:200]}")
+                logger.warning("Memory consolidation: unexpected response type, skipping. Response: {}", text[:200])
                 return
 
             if entry := result.get("history_entry"):
@@ -484,7 +484,7 @@ Respond with ONLY valid JSON, no markdown fences."""
                 session.last_consolidated = len(session.messages) - keep_count
             logger.info(f"Memory consolidation done: {len(session.messages)} messages, last_consolidated={session.last_consolidated}")
         except Exception as e:
-            logger.error(f"Memory consolidation failed: {e}")
+            logger.error("Memory consolidation failed: {}", e)
 
     async def process_direct(
         self,
diff --git a/nanobot/agent/subagent.py b/nanobot/agent/subagent.py
index 203836a..ae0e492 100644
--- a/nanobot/agent/subagent.py
+++ b/nanobot/agent/subagent.py
@@ -160,7 +160,7 @@ class SubagentManager:
                     # Execute tools
                     for tool_call in response.tool_calls:
                         args_str = json.dumps(tool_call.arguments)
-                        logger.debug(f"Subagent [{task_id}] executing: {tool_call.name} with arguments: {args_str}")
+                        logger.debug("Subagent [{}] executing: {} with arguments: {}", task_id, tool_call.name, args_str)
                         result = await tools.execute(tool_call.name, tool_call.arguments)
                         messages.append({
                             "role": "tool",
@@ -180,7 +180,7 @@ class SubagentManager:
             
         except Exception as e:
             error_msg = f"Error: {str(e)}"
-            logger.error(f"Subagent [{task_id}] failed: {e}")
+            logger.error("Subagent [{}] failed: {}", task_id, e)
             await self._announce_result(task_id, label, task, error_msg, origin, "error")
     
     async def _announce_result(
diff --git a/nanobot/agent/tools/mcp.py b/nanobot/agent/tools/mcp.py
index 1c8eac4..4e61923 100644
--- a/nanobot/agent/tools/mcp.py
+++ b/nanobot/agent/tools/mcp.py
@@ -77,4 +77,4 @@ async def connect_mcp_servers(
 
             logger.info(f"MCP server '{name}': connected, {len(tools.tools)} tools registered")
         except Exception as e:
-            logger.error(f"MCP server '{name}': failed to connect: {e}")
+            logger.error("MCP server '{}': failed to connect: {}", name, e)
diff --git a/nanobot/bus/queue.py b/nanobot/bus/queue.py
index 4123d06..554c0ec 100644
--- a/nanobot/bus/queue.py
+++ b/nanobot/bus/queue.py
@@ -62,7 +62,7 @@ class MessageBus:
                     try:
                         await callback(msg)
                     except Exception as e:
-                        logger.error(f"Error dispatching to {msg.channel}: {e}")
+                        logger.error("Error dispatching to {}: {}", msg.channel, e)
             except asyncio.TimeoutError:
                 continue
     
diff --git a/nanobot/channels/dingtalk.py b/nanobot/channels/dingtalk.py
index 4a8cdd9..3ac233f 100644
--- a/nanobot/channels/dingtalk.py
+++ b/nanobot/channels/dingtalk.py
@@ -65,7 +65,7 @@ class NanobotDingTalkHandler(CallbackHandler):
             sender_id = chatbot_msg.sender_staff_id or chatbot_msg.sender_id
             sender_name = chatbot_msg.sender_nick or "Unknown"
 
-            logger.info(f"Received DingTalk message from {sender_name} ({sender_id}): {content}")
+            logger.info("Received DingTalk message from {} ({}): {}", sender_name, sender_id, content)
 
             # Forward to Nanobot via _on_message (non-blocking).
             # Store reference to prevent GC before task completes.
@@ -78,7 +78,7 @@ class NanobotDingTalkHandler(CallbackHandler):
             return AckMessage.STATUS_OK, "OK"
 
         except Exception as e:
-            logger.error(f"Error processing DingTalk message: {e}")
+            logger.error("Error processing DingTalk message: {}", e)
             # Return OK to avoid retry loop from DingTalk server
             return AckMessage.STATUS_OK, "Error"
 
@@ -142,13 +142,13 @@ class DingTalkChannel(BaseChannel):
                 try:
                     await self._client.start()
                 except Exception as e:
-                    logger.warning(f"DingTalk stream error: {e}")
+                    logger.warning("DingTalk stream error: {}", e)
                 if self._running:
                     logger.info("Reconnecting DingTalk stream in 5 seconds...")
                     await asyncio.sleep(5)
 
         except Exception as e:
-            logger.exception(f"Failed to start DingTalk channel: {e}")
+            logger.exception("Failed to start DingTalk channel: {}", e)
 
     async def stop(self) -> None:
         """Stop the DingTalk bot."""
@@ -186,7 +186,7 @@ class DingTalkChannel(BaseChannel):
             self._token_expiry = time.time() + int(res_data.get("expireIn", 7200)) - 60
             return self._access_token
         except Exception as e:
-            logger.error(f"Failed to get DingTalk access token: {e}")
+            logger.error("Failed to get DingTalk access token: {}", e)
             return None
 
     async def send(self, msg: OutboundMessage) -> None:
@@ -218,11 +218,11 @@ class DingTalkChannel(BaseChannel):
         try:
             resp = await self._http.post(url, json=data, headers=headers)
             if resp.status_code != 200:
-                logger.error(f"DingTalk send failed: {resp.text}")
+                logger.error("DingTalk send failed: {}", resp.text)
             else:
                 logger.debug(f"DingTalk message sent to {msg.chat_id}")
         except Exception as e:
-            logger.error(f"Error sending DingTalk message: {e}")
+            logger.error("Error sending DingTalk message: {}", e)
 
     async def _on_message(self, content: str, sender_id: str, sender_name: str) -> None:
         """Handle incoming message (called by NanobotDingTalkHandler).
@@ -231,7 +231,7 @@ class DingTalkChannel(BaseChannel):
         permission checks before publishing to the bus.
         """
         try:
-            logger.info(f"DingTalk inbound: {content} from {sender_name}")
+            logger.info("DingTalk inbound: {} from {}", content, sender_name)
             await self._handle_message(
                 sender_id=sender_id,
                 chat_id=sender_id,  # For private chat, chat_id == sender_id
@@ -242,4 +242,4 @@ class DingTalkChannel(BaseChannel):
                 },
             )
         except Exception as e:
-            logger.error(f"Error publishing DingTalk message: {e}")
+            logger.error("Error publishing DingTalk message: {}", e)
diff --git a/nanobot/channels/discord.py b/nanobot/channels/discord.py
index a76d6ac..ee54eed 100644
--- a/nanobot/channels/discord.py
+++ b/nanobot/channels/discord.py
@@ -51,7 +51,7 @@ class DiscordChannel(BaseChannel):
             except asyncio.CancelledError:
                 break
             except Exception as e:
-                logger.warning(f"Discord gateway error: {e}")
+                logger.warning("Discord gateway error: {}", e)
                 if self._running:
                     logger.info("Reconnecting to Discord gateway in 5 seconds...")
                     await asyncio.sleep(5)
@@ -101,7 +101,7 @@ class DiscordChannel(BaseChannel):
                     return
                 except Exception as e:
                     if attempt == 2:
-                        logger.error(f"Error sending Discord message: {e}")
+                        logger.error("Error sending Discord message: {}", e)
                     else:
                         await asyncio.sleep(1)
         finally:
@@ -116,7 +116,7 @@ class DiscordChannel(BaseChannel):
             try:
                 data = json.loads(raw)
             except json.JSONDecodeError:
-                logger.warning(f"Invalid JSON from Discord gateway: {raw[:100]}")
+                logger.warning("Invalid JSON from Discord gateway: {}", raw[:100])
                 continue
 
             op = data.get("op")
@@ -175,7 +175,7 @@ class DiscordChannel(BaseChannel):
                 try:
                     await self._ws.send(json.dumps(payload))
                 except Exception as e:
-                    logger.warning(f"Discord heartbeat failed: {e}")
+                    logger.warning("Discord heartbeat failed: {}", e)
                     break
                 await asyncio.sleep(interval_s)
 
@@ -219,7 +219,7 @@ class DiscordChannel(BaseChannel):
                 media_paths.append(str(file_path))
                 content_parts.append(f"[attachment: {file_path}]")
             except Exception as e:
-                logger.warning(f"Failed to download Discord attachment: {e}")
+                logger.warning("Failed to download Discord attachment: {}", e)
                 content_parts.append(f"[attachment: {filename} - download failed]")
 
         reply_to = (payload.get("referenced_message") or {}).get("id")
diff --git a/nanobot/channels/email.py b/nanobot/channels/email.py
index 0e47067..8a1ee79 100644
--- a/nanobot/channels/email.py
+++ b/nanobot/channels/email.py
@@ -94,7 +94,7 @@ class EmailChannel(BaseChannel):
                         metadata=item.get("metadata", {}),
                     )
             except Exception as e:
-                logger.error(f"Email polling error: {e}")
+                logger.error("Email polling error: {}", e)
 
             await asyncio.sleep(poll_seconds)
 
@@ -143,7 +143,7 @@ class EmailChannel(BaseChannel):
         try:
             await asyncio.to_thread(self._smtp_send, email_msg)
         except Exception as e:
-            logger.error(f"Error sending email to {to_addr}: {e}")
+            logger.error("Error sending email to {}: {}", to_addr, e)
             raise
 
     def _validate_config(self) -> bool:
diff --git a/nanobot/channels/feishu.py b/nanobot/channels/feishu.py
index 651d655..6f62202 100644
--- a/nanobot/channels/feishu.py
+++ b/nanobot/channels/feishu.py
@@ -156,7 +156,7 @@ class FeishuChannel(BaseChannel):
                 try:
                     self._ws_client.start()
                 except Exception as e:
-                    logger.warning(f"Feishu WebSocket error: {e}")
+                    logger.warning("Feishu WebSocket error: {}", e)
                 if self._running:
                     import time; time.sleep(5)
         
@@ -177,7 +177,7 @@ class FeishuChannel(BaseChannel):
             try:
                 self._ws_client.stop()
             except Exception as e:
-                logger.warning(f"Error stopping WebSocket client: {e}")
+                logger.warning("Error stopping WebSocket client: {}", e)
         logger.info("Feishu bot stopped")
     
     def _add_reaction_sync(self, message_id: str, emoji_type: str) -> None:
@@ -194,11 +194,11 @@ class FeishuChannel(BaseChannel):
             response = self._client.im.v1.message_reaction.create(request)
             
             if not response.success():
-                logger.warning(f"Failed to add reaction: code={response.code}, msg={response.msg}")
+                logger.warning("Failed to add reaction: code={}, msg={}", response.code, response.msg)
             else:
                 logger.debug(f"Added {emoji_type} reaction to message {message_id}")
         except Exception as e:
-            logger.warning(f"Error adding reaction: {e}")
+            logger.warning("Error adding reaction: {}", e)
 
     async def _add_reaction(self, message_id: str, emoji_type: str = "THUMBSUP") -> None:
         """
@@ -312,10 +312,10 @@ class FeishuChannel(BaseChannel):
                     logger.debug(f"Uploaded image {os.path.basename(file_path)}: {image_key}")
                     return image_key
                 else:
-                    logger.error(f"Failed to upload image: code={response.code}, msg={response.msg}")
+                    logger.error("Failed to upload image: code={}, msg={}", response.code, response.msg)
                     return None
         except Exception as e:
-            logger.error(f"Error uploading image {file_path}: {e}")
+            logger.error("Error uploading image {}: {}", file_path, e)
             return None
 
     def _upload_file_sync(self, file_path: str) -> str | None:
@@ -339,10 +339,10 @@ class FeishuChannel(BaseChannel):
                     logger.debug(f"Uploaded file {file_name}: {file_key}")
                     return file_key
                 else:
-                    logger.error(f"Failed to upload file: code={response.code}, msg={response.msg}")
+                    logger.error("Failed to upload file: code={}, msg={}", response.code, response.msg)
                     return None
         except Exception as e:
-            logger.error(f"Error uploading file {file_path}: {e}")
+            logger.error("Error uploading file {}: {}", file_path, e)
             return None
 
     def _send_message_sync(self, receive_id_type: str, receive_id: str, msg_type: str, content: str) -> bool:
@@ -360,14 +360,14 @@ class FeishuChannel(BaseChannel):
             response = self._client.im.v1.message.create(request)
             if not response.success():
                 logger.error(
-                    f"Failed to send Feishu {msg_type} message: code={response.code}, "
-                    f"msg={response.msg}, log_id={response.get_log_id()}"
+                    "Failed to send Feishu {} message: code={}, msg={}, log_id={}",
+                    msg_type, response.code, response.msg, response.get_log_id()
                 )
                 return False
             logger.debug(f"Feishu {msg_type} message sent to {receive_id}")
             return True
         except Exception as e:
-            logger.error(f"Error sending Feishu {msg_type} message: {e}")
+            logger.error("Error sending Feishu {} message: {}", msg_type, e)
             return False
 
     async def send(self, msg: OutboundMessage) -> None:
@@ -409,7 +409,7 @@ class FeishuChannel(BaseChannel):
                 )
 
         except Exception as e:
-            logger.error(f"Error sending Feishu message: {e}")
+            logger.error("Error sending Feishu message: {}", e)
     
     def _on_message_sync(self, data: "P2ImMessageReceiveV1") -> None:
         """
@@ -481,4 +481,4 @@ class FeishuChannel(BaseChannel):
             )
             
         except Exception as e:
-            logger.error(f"Error processing Feishu message: {e}")
+            logger.error("Error processing Feishu message: {}", e)
diff --git a/nanobot/channels/manager.py b/nanobot/channels/manager.py
index e860d26..3e714c3 100644
--- a/nanobot/channels/manager.py
+++ b/nanobot/channels/manager.py
@@ -142,7 +142,7 @@ class ChannelManager:
         try:
             await channel.start()
         except Exception as e:
-            logger.error(f"Failed to start channel {name}: {e}")
+            logger.error("Failed to start channel {}: {}", name, e)
 
     async def start_all(self) -> None:
         """Start all channels and the outbound dispatcher."""
@@ -180,7 +180,7 @@ class ChannelManager:
                 await channel.stop()
                 logger.info(f"Stopped {name} channel")
             except Exception as e:
-                logger.error(f"Error stopping {name}: {e}")
+                logger.error("Error stopping {}: {}", name, e)
     
     async def _dispatch_outbound(self) -> None:
         """Dispatch outbound messages to the appropriate channel."""
@@ -198,7 +198,7 @@ class ChannelManager:
                     try:
                         await channel.send(msg)
                     except Exception as e:
-                        logger.error(f"Error sending to {msg.channel}: {e}")
+                        logger.error("Error sending to {}: {}", msg.channel, e)
                 else:
                     logger.warning(f"Unknown channel: {msg.channel}")
                     
diff --git a/nanobot/channels/mochat.py b/nanobot/channels/mochat.py
index 30c3dbf..e762dfd 100644
--- a/nanobot/channels/mochat.py
+++ b/nanobot/channels/mochat.py
@@ -322,7 +322,7 @@ class MochatChannel(BaseChannel):
                 await self._api_send("/api/claw/sessions/send", "sessionId", target.id,
                                      content, msg.reply_to)
         except Exception as e:
-            logger.error(f"Failed to send Mochat message: {e}")
+            logger.error("Failed to send Mochat message: {}", e)
 
     # ---- config / init helpers ---------------------------------------------
 
@@ -380,7 +380,7 @@ class MochatChannel(BaseChannel):
 
         @client.event
         async def connect_error(data: Any) -> None:
-            logger.error(f"Mochat websocket connect error: {data}")
+            logger.error("Mochat websocket connect error: {}", data)
 
         @client.on("claw.session.events")
         async def on_session_events(payload: dict[str, Any]) -> None:
@@ -407,7 +407,7 @@ class MochatChannel(BaseChannel):
             )
             return True
         except Exception as e:
-            logger.error(f"Failed to connect Mochat websocket: {e}")
+            logger.error("Failed to connect Mochat websocket: {}", e)
             try:
                 await client.disconnect()
             except Exception:
@@ -444,7 +444,7 @@ class MochatChannel(BaseChannel):
             "limit": self.config.watch_limit,
         })
         if not ack.get("result"):
-            logger.error(f"Mochat subscribeSessions failed: {ack.get('message', 'unknown error')}")
+            logger.error("Mochat subscribeSessions failed: {}", ack.get('message', 'unknown error'))
             return False
 
         data = ack.get("data")
@@ -466,7 +466,7 @@ class MochatChannel(BaseChannel):
             return True
         ack = await self._socket_call("com.claw.im.subscribePanels", {"panelIds": panel_ids})
         if not ack.get("result"):
-            logger.error(f"Mochat subscribePanels failed: {ack.get('message', 'unknown error')}")
+            logger.error("Mochat subscribePanels failed: {}", ack.get('message', 'unknown error'))
             return False
         return True
 
@@ -488,7 +488,7 @@ class MochatChannel(BaseChannel):
             try:
                 await self._refresh_targets(subscribe_new=self._ws_ready)
             except Exception as e:
-                logger.warning(f"Mochat refresh failed: {e}")
+                logger.warning("Mochat refresh failed: {}", e)
             if self._fallback_mode:
                 await self._ensure_fallback_workers()
 
@@ -502,7 +502,7 @@ class MochatChannel(BaseChannel):
         try:
             response = await self._post_json("/api/claw/sessions/list", {})
         except Exception as e:
-            logger.warning(f"Mochat listSessions failed: {e}")
+            logger.warning("Mochat listSessions failed: {}", e)
             return
 
         sessions = response.get("sessions")
@@ -536,7 +536,7 @@ class MochatChannel(BaseChannel):
         try:
             response = await self._post_json("/api/claw/groups/get", {})
         except Exception as e:
-            logger.warning(f"Mochat getWorkspaceGroup failed: {e}")
+            logger.warning("Mochat getWorkspaceGroup failed: {}", e)
             return
 
         raw_panels = response.get("panels")
@@ -598,7 +598,7 @@ class MochatChannel(BaseChannel):
             except asyncio.CancelledError:
                 break
             except Exception as e:
-                logger.warning(f"Mochat watch fallback error ({session_id}): {e}")
+                logger.warning("Mochat watch fallback error ({}): {}", session_id, e)
                 await asyncio.sleep(max(0.1, self.config.retry_delay_ms / 1000.0))
 
     async def _panel_poll_worker(self, panel_id: str) -> None:
@@ -625,7 +625,7 @@ class MochatChannel(BaseChannel):
             except asyncio.CancelledError:
                 break
             except Exception as e:
-                logger.warning(f"Mochat panel polling error ({panel_id}): {e}")
+                logger.warning("Mochat panel polling error ({}): {}", panel_id, e)
             await asyncio.sleep(sleep_s)
 
     # ---- inbound event processing ------------------------------------------
@@ -836,7 +836,7 @@ class MochatChannel(BaseChannel):
         try:
             data = json.loads(self._cursor_path.read_text("utf-8"))
         except Exception as e:
-            logger.warning(f"Failed to read Mochat cursor file: {e}")
+            logger.warning("Failed to read Mochat cursor file: {}", e)
             return
         cursors = data.get("cursors") if isinstance(data, dict) else None
         if isinstance(cursors, dict):
@@ -852,7 +852,7 @@ class MochatChannel(BaseChannel):
                 "cursors": self._session_cursor,
             }, ensure_ascii=False, indent=2) + "\n", "utf-8")
         except Exception as e:
-            logger.warning(f"Failed to save Mochat cursor file: {e}")
+            logger.warning("Failed to save Mochat cursor file: {}", e)
 
     # ---- HTTP helpers ------------------------------------------------------
 
diff --git a/nanobot/channels/qq.py b/nanobot/channels/qq.py
index 0e8fe66..1d00bc7 100644
--- a/nanobot/channels/qq.py
+++ b/nanobot/channels/qq.py
@@ -80,7 +80,7 @@ class QQChannel(BaseChannel):
             try:
                 await self._client.start(appid=self.config.app_id, secret=self.config.secret)
             except Exception as e:
-                logger.warning(f"QQ bot error: {e}")
+                logger.warning("QQ bot error: {}", e)
             if self._running:
                 logger.info("Reconnecting QQ bot in 5 seconds...")
                 await asyncio.sleep(5)
@@ -108,7 +108,7 @@ class QQChannel(BaseChannel):
                 content=msg.content,
             )
         except Exception as e:
-            logger.error(f"Error sending QQ message: {e}")
+            logger.error("Error sending QQ message: {}", e)
 
     async def _on_message(self, data: "C2CMessage") -> None:
         """Handle incoming message from QQ."""
@@ -131,4 +131,4 @@ class QQChannel(BaseChannel):
                 metadata={"message_id": data.id},
             )
         except Exception as e:
-            logger.error(f"Error handling QQ message: {e}")
+            logger.error("Error handling QQ message: {}", e)
diff --git a/nanobot/channels/slack.py b/nanobot/channels/slack.py
index dca5055..7dd2971 100644
--- a/nanobot/channels/slack.py
+++ b/nanobot/channels/slack.py
@@ -55,7 +55,7 @@ class SlackChannel(BaseChannel):
             self._bot_user_id = auth.get("user_id")
             logger.info(f"Slack bot connected as {self._bot_user_id}")
         except Exception as e:
-            logger.warning(f"Slack auth_test failed: {e}")
+            logger.warning("Slack auth_test failed: {}", e)
 
         logger.info("Starting Slack Socket Mode client...")
         await self._socket_client.connect()
@@ -70,7 +70,7 @@ class SlackChannel(BaseChannel):
             try:
                 await self._socket_client.close()
             except Exception as e:
-                logger.warning(f"Slack socket close failed: {e}")
+                logger.warning("Slack socket close failed: {}", e)
             self._socket_client = None
 
     async def send(self, msg: OutboundMessage) -> None:
@@ -90,7 +90,7 @@ class SlackChannel(BaseChannel):
                 thread_ts=thread_ts if use_thread else None,
             )
         except Exception as e:
-            logger.error(f"Error sending Slack message: {e}")
+            logger.error("Error sending Slack message: {}", e)
 
     async def _on_socket_request(
         self,
@@ -164,7 +164,7 @@ class SlackChannel(BaseChannel):
                     timestamp=event.get("ts"),
                 )
         except Exception as e:
-            logger.debug(f"Slack reactions_add failed: {e}")
+            logger.debug("Slack reactions_add failed: {}", e)
 
         await self._handle_message(
             sender_id=sender_id,
diff --git a/nanobot/channels/telegram.py b/nanobot/channels/telegram.py
index 39924b3..42db489 100644
--- a/nanobot/channels/telegram.py
+++ b/nanobot/channels/telegram.py
@@ -171,7 +171,7 @@ class TelegramChannel(BaseChannel):
             await self._app.bot.set_my_commands(self.BOT_COMMANDS)
             logger.debug("Telegram bot commands registered")
         except Exception as e:
-            logger.warning(f"Failed to register bot commands: {e}")
+            logger.warning("Failed to register bot commands: {}", e)
         
         # Start polling (this runs until stopped)
         await self._app.updater.start_polling(
@@ -238,7 +238,7 @@ class TelegramChannel(BaseChannel):
                     await sender(chat_id=chat_id, **{param: f})
             except Exception as e:
                 filename = media_path.rsplit("/", 1)[-1]
-                logger.error(f"Failed to send media {media_path}: {e}")
+                logger.error("Failed to send media {}: {}", media_path, e)
                 await self._app.bot.send_message(chat_id=chat_id, text=f"[Failed to send: {filename}]")
 
         # Send text content
@@ -248,11 +248,11 @@ class TelegramChannel(BaseChannel):
                     html = _markdown_to_telegram_html(chunk)
                     await self._app.bot.send_message(chat_id=chat_id, text=html, parse_mode="HTML")
                 except Exception as e:
-                    logger.warning(f"HTML parse failed, falling back to plain text: {e}")
+                    logger.warning("HTML parse failed, falling back to plain text: {}", e)
                     try:
                         await self._app.bot.send_message(chat_id=chat_id, text=chunk)
                     except Exception as e2:
-                        logger.error(f"Error sending Telegram message: {e2}")
+                        logger.error("Error sending Telegram message: {}", e2)
     
     async def _on_start(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
         """Handle /start command."""
@@ -353,12 +353,12 @@ class TelegramChannel(BaseChannel):
                     
                 logger.debug(f"Downloaded {media_type} to {file_path}")
             except Exception as e:
-                logger.error(f"Failed to download media: {e}")
+                logger.error("Failed to download media: {}", e)
                 content_parts.append(f"[{media_type}: download failed]")
         
         content = "\n".join(content_parts) if content_parts else "[empty message]"
         
-        logger.debug(f"Telegram message from {sender_id}: {content[:50]}...")
+        logger.debug("Telegram message from {}: {}...", sender_id, content[:50])
         
         str_chat_id = str(chat_id)
         
@@ -401,11 +401,11 @@ class TelegramChannel(BaseChannel):
         except asyncio.CancelledError:
             pass
         except Exception as e:
-            logger.debug(f"Typing indicator stopped for {chat_id}: {e}")
+            logger.debug("Typing indicator stopped for {}: {}", chat_id, e)
     
     async def _on_error(self, update: object, context: ContextTypes.DEFAULT_TYPE) -> None:
         """Log polling / handler errors instead of silently swallowing them."""
-        logger.error(f"Telegram error: {context.error}")
+        logger.error("Telegram error: {}", context.error)
 
     def _get_extension(self, media_type: str, mime_type: str | None) -> str:
         """Get file extension based on media type."""
diff --git a/nanobot/channels/whatsapp.py b/nanobot/channels/whatsapp.py
index 0cf2dd7..4d12360 100644
--- a/nanobot/channels/whatsapp.py
+++ b/nanobot/channels/whatsapp.py
@@ -53,14 +53,14 @@ class WhatsAppChannel(BaseChannel):
                         try:
                             await self._handle_bridge_message(message)
                         except Exception as e:
-                            logger.error(f"Error handling bridge message: {e}")
+                            logger.error("Error handling bridge message: {}", e)
                     
             except asyncio.CancelledError:
                 break
             except Exception as e:
                 self._connected = False
                 self._ws = None
-                logger.warning(f"WhatsApp bridge connection error: {e}")
+                logger.warning("WhatsApp bridge connection error: {}", e)
                 
                 if self._running:
                     logger.info("Reconnecting in 5 seconds...")
@@ -89,14 +89,14 @@ class WhatsAppChannel(BaseChannel):
             }
             await self._ws.send(json.dumps(payload))
         except Exception as e:
-            logger.error(f"Error sending WhatsApp message: {e}")
+            logger.error("Error sending WhatsApp message: {}", e)
     
     async def _handle_bridge_message(self, raw: str) -> None:
         """Handle a message from the bridge."""
         try:
             data = json.loads(raw)
         except json.JSONDecodeError:
-            logger.warning(f"Invalid JSON from bridge: {raw[:100]}")
+            logger.warning("Invalid JSON from bridge: {}", raw[:100])
             return
         
         msg_type = data.get("type")
@@ -145,4 +145,4 @@ class WhatsAppChannel(BaseChannel):
             logger.info("Scan QR code in the bridge terminal to connect WhatsApp")
         
         elif msg_type == "error":
-            logger.error(f"WhatsApp bridge error: {data.get('error')}")
+            logger.error("WhatsApp bridge error: {}", data.get('error'))
diff --git a/nanobot/cron/service.py b/nanobot/cron/service.py
index 14666e8..d2b9ef7 100644
--- a/nanobot/cron/service.py
+++ b/nanobot/cron/service.py
@@ -99,7 +99,7 @@ class CronService:
                     ))
                 self._store = CronStore(jobs=jobs)
             except Exception as e:
-                logger.warning(f"Failed to load cron store: {e}")
+                logger.warning("Failed to load cron store: {}", e)
                 self._store = CronStore()
         else:
             self._store = CronStore()
@@ -236,7 +236,7 @@ class CronService:
         except Exception as e:
             job.state.last_status = "error"
             job.state.last_error = str(e)
-            logger.error(f"Cron: job '{job.name}' failed: {e}")
+            logger.error("Cron: job '{}' failed: {}", job.name, e)
         
         job.state.last_run_at_ms = start_ms
         job.updated_at_ms = _now_ms()
diff --git a/nanobot/heartbeat/service.py b/nanobot/heartbeat/service.py
index 221ed27..8bdc78f 100644
--- a/nanobot/heartbeat/service.py
+++ b/nanobot/heartbeat/service.py
@@ -97,7 +97,7 @@ class HeartbeatService:
             except asyncio.CancelledError:
                 break
             except Exception as e:
-                logger.error(f"Heartbeat error: {e}")
+                logger.error("Heartbeat error: {}", e)
     
     async def _tick(self) -> None:
         """Execute a single heartbeat tick."""
@@ -121,7 +121,7 @@ class HeartbeatService:
                     logger.info(f"Heartbeat: completed task")
                     
             except Exception as e:
-                logger.error(f"Heartbeat execution failed: {e}")
+                logger.error("Heartbeat execution failed: {}", e)
     
     async def trigger_now(self) -> str | None:
         """Manually trigger a heartbeat."""
diff --git a/nanobot/providers/transcription.py b/nanobot/providers/transcription.py
index 8ce909b..eb5969d 100644
--- a/nanobot/providers/transcription.py
+++ b/nanobot/providers/transcription.py
@@ -61,5 +61,5 @@ class GroqTranscriptionProvider:
                     return data.get("text", "")
                     
         except Exception as e:
-            logger.error(f"Groq transcription error: {e}")
+            logger.error("Groq transcription error: {}", e)
             return ""
diff --git a/nanobot/session/manager.py b/nanobot/session/manager.py
index 752fce4..44dcecb 100644
--- a/nanobot/session/manager.py
+++ b/nanobot/session/manager.py
@@ -144,7 +144,7 @@ class SessionManager:
                 last_consolidated=last_consolidated
             )
         except Exception as e:
-            logger.warning(f"Failed to load session {key}: {e}")
+            logger.warning("Failed to load session {}: {}", key, e)
             return None
     
     def save(self, session: Session) -> None:

From f3c7337356de507b6a1e0b10725bc2521f48ec95 Mon Sep 17 00:00:00 2001
From: dxtime <dxxtimer@gmail.com>
Date: Fri, 20 Feb 2026 08:31:52 +0800
Subject: [PATCH 20/35] feat: Added custom headers for MCP Auth use, update
 README.md

---
 README.md | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 7fad9ce..e8aac1e 100644
--- a/README.md
+++ b/README.md
@@ -752,7 +752,14 @@ Add MCP servers to your `config.json`:
         "command": "npx",
         "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"]
       }
-    }
+    },
+    "urlMcpServers": {
+        "url": "https://xx.xx.xx.xx:xxxx/mcp/",
+        "headers": {
+          "Authorization": "Bearer xxxxx",
+          "X-API-Key": "xxxxxxx"
+        }
+      },
   }
 }
 ```
@@ -762,7 +769,7 @@ Two transport modes are supported:
 | Mode | Config | Example |
 |------|--------|---------|
 | **Stdio** | `command` + `args` | Local process via `npx` / `uvx` |
-| **HTTP** | `url` | Remote endpoint (`https://mcp.example.com/sse`) |
+| **HTTP** | `url` + `option(headers)`| Remote endpoint (`https://mcp.example.com/sse`) |
 
 MCP tools are automatically discovered and registered on startup. The LLM can use them alongside built-in tools — no extra configuration needed.
 

From 0001f286b578b6ecf9634b47c6605978038e5a61 Mon Sep 17 00:00:00 2001
From: AlexanderMerkel <merklexander@gmail.com>
Date: Thu, 19 Feb 2026 19:00:25 -0700
Subject: [PATCH 21/35] fix: remove dead pub/sub code from MessageBus
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`subscribe_outbound()`, `dispatch_outbound()`, and `stop()` have zero
callers — `ChannelManager._dispatch_outbound()` handles all outbound
routing via `consume_outbound()` directly. Remove the dead methods and
their unused imports (`Callable`, `Awaitable`, `logger`).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 nanobot/bus/queue.py | 53 +++++++-------------------------------------
 1 file changed, 8 insertions(+), 45 deletions(-)

diff --git a/nanobot/bus/queue.py b/nanobot/bus/queue.py
index 4123d06..7c0616f 100644
--- a/nanobot/bus/queue.py
+++ b/nanobot/bus/queue.py
@@ -1,9 +1,6 @@
 """Async message queue for decoupled channel-agent communication."""
 
 import asyncio
-from typing import Callable, Awaitable
-
-from loguru import logger
 
 from nanobot.bus.events import InboundMessage, OutboundMessage
 
@@ -11,70 +8,36 @@ from nanobot.bus.events import InboundMessage, OutboundMessage
 class MessageBus:
     """
     Async message bus that decouples chat channels from the agent core.
-    
+
     Channels push messages to the inbound queue, and the agent processes
     them and pushes responses to the outbound queue.
     """
-    
+
     def __init__(self):
         self.inbound: asyncio.Queue[InboundMessage] = asyncio.Queue()
         self.outbound: asyncio.Queue[OutboundMessage] = asyncio.Queue()
-        self._outbound_subscribers: dict[str, list[Callable[[OutboundMessage], Awaitable[None]]]] = {}
-        self._running = False
-    
+
     async def publish_inbound(self, msg: InboundMessage) -> None:
         """Publish a message from a channel to the agent."""
         await self.inbound.put(msg)
-    
+
     async def consume_inbound(self) -> InboundMessage:
         """Consume the next inbound message (blocks until available)."""
         return await self.inbound.get()
-    
+
     async def publish_outbound(self, msg: OutboundMessage) -> None:
         """Publish a response from the agent to channels."""
         await self.outbound.put(msg)
-    
+
     async def consume_outbound(self) -> OutboundMessage:
         """Consume the next outbound message (blocks until available)."""
         return await self.outbound.get()
-    
-    def subscribe_outbound(
-        self, 
-        channel: str, 
-        callback: Callable[[OutboundMessage], Awaitable[None]]
-    ) -> None:
-        """Subscribe to outbound messages for a specific channel."""
-        if channel not in self._outbound_subscribers:
-            self._outbound_subscribers[channel] = []
-        self._outbound_subscribers[channel].append(callback)
-    
-    async def dispatch_outbound(self) -> None:
-        """
-        Dispatch outbound messages to subscribed channels.
-        Run this as a background task.
-        """
-        self._running = True
-        while self._running:
-            try:
-                msg = await asyncio.wait_for(self.outbound.get(), timeout=1.0)
-                subscribers = self._outbound_subscribers.get(msg.channel, [])
-                for callback in subscribers:
-                    try:
-                        await callback(msg)
-                    except Exception as e:
-                        logger.error(f"Error dispatching to {msg.channel}: {e}")
-            except asyncio.TimeoutError:
-                continue
-    
-    def stop(self) -> None:
-        """Stop the dispatcher loop."""
-        self._running = False
-    
+
     @property
     def inbound_size(self) -> int:
         """Number of pending inbound messages."""
         return self.inbound.qsize()
-    
+
     @property
     def outbound_size(self) -> int:
         """Number of pending outbound messages."""

From 37252a4226214367abea1cef0fae4591b2dc00c4 Mon Sep 17 00:00:00 2001
From: Re-bin <xubinrencs@gmail.com>
Date: Fri, 20 Feb 2026 07:55:34 +0000
Subject: [PATCH 22/35] fix: complete loguru native formatting migration across
 all files

---
 nanobot/agent/loop.py              | 12 ++++++------
 nanobot/agent/subagent.py          |  8 ++++----
 nanobot/agent/tools/mcp.py         |  6 +++---
 nanobot/channels/dingtalk.py       |  2 +-
 nanobot/channels/discord.py        |  2 +-
 nanobot/channels/email.py          |  2 +-
 nanobot/channels/feishu.py         | 10 +++++-----
 nanobot/channels/manager.py        | 24 ++++++++++++------------
 nanobot/channels/qq.py             |  2 +-
 nanobot/channels/slack.py          |  4 ++--
 nanobot/channels/telegram.py       |  8 ++++----
 nanobot/channels/whatsapp.py       |  8 ++++----
 nanobot/cron/service.py            | 10 +++++-----
 nanobot/heartbeat/service.py       |  4 ++--
 nanobot/providers/transcription.py |  2 +-
 nanobot/session/manager.py         |  2 +-
 16 files changed, 53 insertions(+), 53 deletions(-)

diff --git a/nanobot/agent/loop.py b/nanobot/agent/loop.py
index cbab5aa..1620cb0 100644
--- a/nanobot/agent/loop.py
+++ b/nanobot/agent/loop.py
@@ -365,7 +365,7 @@ class AgentLoop:
         The chat_id field contains "original_channel:original_chat_id" to route
         the response back to the correct destination.
         """
-        logger.info(f"Processing system message from {msg.sender_id}")
+        logger.info("Processing system message from {}", msg.sender_id)
         
         # Parse origin from chat_id (format: "channel:chat_id")
         if ":" in msg.chat_id:
@@ -413,22 +413,22 @@ class AgentLoop:
         if archive_all:
             old_messages = session.messages
             keep_count = 0
-            logger.info(f"Memory consolidation (archive_all): {len(session.messages)} total messages archived")
+            logger.info("Memory consolidation (archive_all): {} total messages archived", len(session.messages))
         else:
             keep_count = self.memory_window // 2
             if len(session.messages) <= keep_count:
-                logger.debug(f"Session {session.key}: No consolidation needed (messages={len(session.messages)}, keep={keep_count})")
+                logger.debug("Session {}: No consolidation needed (messages={}, keep={})", session.key, len(session.messages), keep_count)
                 return
 
             messages_to_process = len(session.messages) - session.last_consolidated
             if messages_to_process <= 0:
-                logger.debug(f"Session {session.key}: No new messages to consolidate (last_consolidated={session.last_consolidated}, total={len(session.messages)})")
+                logger.debug("Session {}: No new messages to consolidate (last_consolidated={}, total={})", session.key, session.last_consolidated, len(session.messages))
                 return
 
             old_messages = session.messages[session.last_consolidated:-keep_count]
             if not old_messages:
                 return
-            logger.info(f"Memory consolidation started: {len(session.messages)} total, {len(old_messages)} new to consolidate, {keep_count} keep")
+            logger.info("Memory consolidation started: {} total, {} new to consolidate, {} keep", len(session.messages), len(old_messages), keep_count)
 
         lines = []
         for m in old_messages:
@@ -482,7 +482,7 @@ Respond with ONLY valid JSON, no markdown fences."""
                 session.last_consolidated = 0
             else:
                 session.last_consolidated = len(session.messages) - keep_count
-            logger.info(f"Memory consolidation done: {len(session.messages)} messages, last_consolidated={session.last_consolidated}")
+            logger.info("Memory consolidation done: {} messages, last_consolidated={}", len(session.messages), session.last_consolidated)
         except Exception as e:
             logger.error("Memory consolidation failed: {}", e)
 
diff --git a/nanobot/agent/subagent.py b/nanobot/agent/subagent.py
index ae0e492..7d48cc4 100644
--- a/nanobot/agent/subagent.py
+++ b/nanobot/agent/subagent.py
@@ -86,7 +86,7 @@ class SubagentManager:
         # Cleanup when done
         bg_task.add_done_callback(lambda _: self._running_tasks.pop(task_id, None))
         
-        logger.info(f"Spawned subagent [{task_id}]: {display_label}")
+        logger.info("Spawned subagent [{}]: {}", task_id, display_label)
         return f"Subagent [{display_label}] started (id: {task_id}). I'll notify you when it completes."
     
     async def _run_subagent(
@@ -97,7 +97,7 @@ class SubagentManager:
         origin: dict[str, str],
     ) -> None:
         """Execute the subagent task and announce the result."""
-        logger.info(f"Subagent [{task_id}] starting task: {label}")
+        logger.info("Subagent [{}] starting task: {}", task_id, label)
         
         try:
             # Build subagent tools (no message tool, no spawn tool)
@@ -175,7 +175,7 @@ class SubagentManager:
             if final_result is None:
                 final_result = "Task completed but no final response was generated."
             
-            logger.info(f"Subagent [{task_id}] completed successfully")
+            logger.info("Subagent [{}] completed successfully", task_id)
             await self._announce_result(task_id, label, task, final_result, origin, "ok")
             
         except Exception as e:
@@ -213,7 +213,7 @@ Summarize this naturally for the user. Keep it brief (1-2 sentences). Do not men
         )
         
         await self.bus.publish_inbound(msg)
-        logger.debug(f"Subagent [{task_id}] announced result to {origin['channel']}:{origin['chat_id']}")
+        logger.debug("Subagent [{}] announced result to {}:{}", task_id, origin['channel'], origin['chat_id'])
     
     def _build_subagent_prompt(self, task: str) -> str:
         """Build a focused system prompt for the subagent."""
diff --git a/nanobot/agent/tools/mcp.py b/nanobot/agent/tools/mcp.py
index 4e61923..7d9033d 100644
--- a/nanobot/agent/tools/mcp.py
+++ b/nanobot/agent/tools/mcp.py
@@ -63,7 +63,7 @@ async def connect_mcp_servers(
                     streamable_http_client(cfg.url)
                 )
             else:
-                logger.warning(f"MCP server '{name}': no command or url configured, skipping")
+                logger.warning("MCP server '{}': no command or url configured, skipping", name)
                 continue
 
             session = await stack.enter_async_context(ClientSession(read, write))
@@ -73,8 +73,8 @@ async def connect_mcp_servers(
             for tool_def in tools.tools:
                 wrapper = MCPToolWrapper(session, name, tool_def)
                 registry.register(wrapper)
-                logger.debug(f"MCP: registered tool '{wrapper.name}' from server '{name}'")
+                logger.debug("MCP: registered tool '{}' from server '{}'", wrapper.name, name)
 
-            logger.info(f"MCP server '{name}': connected, {len(tools.tools)} tools registered")
+            logger.info("MCP server '{}': connected, {} tools registered", name, len(tools.tools))
         except Exception as e:
             logger.error("MCP server '{}': failed to connect: {}", name, e)
diff --git a/nanobot/channels/dingtalk.py b/nanobot/channels/dingtalk.py
index 3ac233f..f6dca30 100644
--- a/nanobot/channels/dingtalk.py
+++ b/nanobot/channels/dingtalk.py
@@ -220,7 +220,7 @@ class DingTalkChannel(BaseChannel):
             if resp.status_code != 200:
                 logger.error("DingTalk send failed: {}", resp.text)
             else:
-                logger.debug(f"DingTalk message sent to {msg.chat_id}")
+                logger.debug("DingTalk message sent to {}", msg.chat_id)
         except Exception as e:
             logger.error("Error sending DingTalk message: {}", e)
 
diff --git a/nanobot/channels/discord.py b/nanobot/channels/discord.py
index ee54eed..8baecbf 100644
--- a/nanobot/channels/discord.py
+++ b/nanobot/channels/discord.py
@@ -94,7 +94,7 @@ class DiscordChannel(BaseChannel):
                     if response.status_code == 429:
                         data = response.json()
                         retry_after = float(data.get("retry_after", 1.0))
-                        logger.warning(f"Discord rate limited, retrying in {retry_after}s")
+                        logger.warning("Discord rate limited, retrying in {}s", retry_after)
                         await asyncio.sleep(retry_after)
                         continue
                     response.raise_for_status()
diff --git a/nanobot/channels/email.py b/nanobot/channels/email.py
index 8a1ee79..1b6f46b 100644
--- a/nanobot/channels/email.py
+++ b/nanobot/channels/email.py
@@ -162,7 +162,7 @@ class EmailChannel(BaseChannel):
             missing.append("smtp_password")
 
         if missing:
-            logger.error(f"Email channel not configured, missing: {', '.join(missing)}")
+            logger.error("Email channel not configured, missing: {}", ', '.join(missing))
             return False
         return True
 
diff --git a/nanobot/channels/feishu.py b/nanobot/channels/feishu.py
index 6f62202..c17bf1a 100644
--- a/nanobot/channels/feishu.py
+++ b/nanobot/channels/feishu.py
@@ -196,7 +196,7 @@ class FeishuChannel(BaseChannel):
             if not response.success():
                 logger.warning("Failed to add reaction: code={}, msg={}", response.code, response.msg)
             else:
-                logger.debug(f"Added {emoji_type} reaction to message {message_id}")
+                logger.debug("Added {} reaction to message {}", emoji_type, message_id)
         except Exception as e:
             logger.warning("Error adding reaction: {}", e)
 
@@ -309,7 +309,7 @@ class FeishuChannel(BaseChannel):
                 response = self._client.im.v1.image.create(request)
                 if response.success():
                     image_key = response.data.image_key
-                    logger.debug(f"Uploaded image {os.path.basename(file_path)}: {image_key}")
+                    logger.debug("Uploaded image {}: {}", os.path.basename(file_path), image_key)
                     return image_key
                 else:
                     logger.error("Failed to upload image: code={}, msg={}", response.code, response.msg)
@@ -336,7 +336,7 @@ class FeishuChannel(BaseChannel):
                 response = self._client.im.v1.file.create(request)
                 if response.success():
                     file_key = response.data.file_key
-                    logger.debug(f"Uploaded file {file_name}: {file_key}")
+                    logger.debug("Uploaded file {}: {}", file_name, file_key)
                     return file_key
                 else:
                     logger.error("Failed to upload file: code={}, msg={}", response.code, response.msg)
@@ -364,7 +364,7 @@ class FeishuChannel(BaseChannel):
                     msg_type, response.code, response.msg, response.get_log_id()
                 )
                 return False
-            logger.debug(f"Feishu {msg_type} message sent to {receive_id}")
+            logger.debug("Feishu {} message sent to {}", msg_type, receive_id)
             return True
         except Exception as e:
             logger.error("Error sending Feishu {} message: {}", msg_type, e)
@@ -382,7 +382,7 @@ class FeishuChannel(BaseChannel):
 
             for file_path in msg.media:
                 if not os.path.isfile(file_path):
-                    logger.warning(f"Media file not found: {file_path}")
+                    logger.warning("Media file not found: {}", file_path)
                     continue
                 ext = os.path.splitext(file_path)[1].lower()
                 if ext in self._IMAGE_EXTS:
diff --git a/nanobot/channels/manager.py b/nanobot/channels/manager.py
index 3e714c3..6fbab04 100644
--- a/nanobot/channels/manager.py
+++ b/nanobot/channels/manager.py
@@ -45,7 +45,7 @@ class ChannelManager:
                 )
                 logger.info("Telegram channel enabled")
             except ImportError as e:
-                logger.warning(f"Telegram channel not available: {e}")
+                logger.warning("Telegram channel not available: {}", e)
         
         # WhatsApp channel
         if self.config.channels.whatsapp.enabled:
@@ -56,7 +56,7 @@ class ChannelManager:
                 )
                 logger.info("WhatsApp channel enabled")
             except ImportError as e:
-                logger.warning(f"WhatsApp channel not available: {e}")
+                logger.warning("WhatsApp channel not available: {}", e)
 
         # Discord channel
         if self.config.channels.discord.enabled:
@@ -67,7 +67,7 @@ class ChannelManager:
                 )
                 logger.info("Discord channel enabled")
             except ImportError as e:
-                logger.warning(f"Discord channel not available: {e}")
+                logger.warning("Discord channel not available: {}", e)
         
         # Feishu channel
         if self.config.channels.feishu.enabled:
@@ -78,7 +78,7 @@ class ChannelManager:
                 )
                 logger.info("Feishu channel enabled")
             except ImportError as e:
-                logger.warning(f"Feishu channel not available: {e}")
+                logger.warning("Feishu channel not available: {}", e)
 
         # Mochat channel
         if self.config.channels.mochat.enabled:
@@ -90,7 +90,7 @@ class ChannelManager:
                 )
                 logger.info("Mochat channel enabled")
             except ImportError as e:
-                logger.warning(f"Mochat channel not available: {e}")
+                logger.warning("Mochat channel not available: {}", e)
 
         # DingTalk channel
         if self.config.channels.dingtalk.enabled:
@@ -101,7 +101,7 @@ class ChannelManager:
                 )
                 logger.info("DingTalk channel enabled")
             except ImportError as e:
-                logger.warning(f"DingTalk channel not available: {e}")
+                logger.warning("DingTalk channel not available: {}", e)
 
         # Email channel
         if self.config.channels.email.enabled:
@@ -112,7 +112,7 @@ class ChannelManager:
                 )
                 logger.info("Email channel enabled")
             except ImportError as e:
-                logger.warning(f"Email channel not available: {e}")
+                logger.warning("Email channel not available: {}", e)
 
         # Slack channel
         if self.config.channels.slack.enabled:
@@ -123,7 +123,7 @@ class ChannelManager:
                 )
                 logger.info("Slack channel enabled")
             except ImportError as e:
-                logger.warning(f"Slack channel not available: {e}")
+                logger.warning("Slack channel not available: {}", e)
 
         # QQ channel
         if self.config.channels.qq.enabled:
@@ -135,7 +135,7 @@ class ChannelManager:
                 )
                 logger.info("QQ channel enabled")
             except ImportError as e:
-                logger.warning(f"QQ channel not available: {e}")
+                logger.warning("QQ channel not available: {}", e)
     
     async def _start_channel(self, name: str, channel: BaseChannel) -> None:
         """Start a channel and log any exceptions."""
@@ -156,7 +156,7 @@ class ChannelManager:
         # Start channels
         tasks = []
         for name, channel in self.channels.items():
-            logger.info(f"Starting {name} channel...")
+            logger.info("Starting {} channel...", name)
             tasks.append(asyncio.create_task(self._start_channel(name, channel)))
         
         # Wait for all to complete (they should run forever)
@@ -178,7 +178,7 @@ class ChannelManager:
         for name, channel in self.channels.items():
             try:
                 await channel.stop()
-                logger.info(f"Stopped {name} channel")
+                logger.info("Stopped {} channel", name)
             except Exception as e:
                 logger.error("Error stopping {}: {}", name, e)
     
@@ -200,7 +200,7 @@ class ChannelManager:
                     except Exception as e:
                         logger.error("Error sending to {}: {}", msg.channel, e)
                 else:
-                    logger.warning(f"Unknown channel: {msg.channel}")
+                    logger.warning("Unknown channel: {}", msg.channel)
                     
             except asyncio.TimeoutError:
                 continue
diff --git a/nanobot/channels/qq.py b/nanobot/channels/qq.py
index 1d00bc7..16cbfb8 100644
--- a/nanobot/channels/qq.py
+++ b/nanobot/channels/qq.py
@@ -34,7 +34,7 @@ def _make_bot_class(channel: "QQChannel") -> "type[botpy.Client]":
             super().__init__(intents=intents)
 
         async def on_ready(self):
-            logger.info(f"QQ bot ready: {self.robot.name}")
+            logger.info("QQ bot ready: {}", self.robot.name)
 
         async def on_c2c_message_create(self, message: "C2CMessage"):
             await channel._on_message(message)
diff --git a/nanobot/channels/slack.py b/nanobot/channels/slack.py
index 7dd2971..79cbe76 100644
--- a/nanobot/channels/slack.py
+++ b/nanobot/channels/slack.py
@@ -36,7 +36,7 @@ class SlackChannel(BaseChannel):
             logger.error("Slack bot/app token not configured")
             return
         if self.config.mode != "socket":
-            logger.error(f"Unsupported Slack mode: {self.config.mode}")
+            logger.error("Unsupported Slack mode: {}", self.config.mode)
             return
 
         self._running = True
@@ -53,7 +53,7 @@ class SlackChannel(BaseChannel):
         try:
             auth = await self._web_client.auth_test()
             self._bot_user_id = auth.get("user_id")
-            logger.info(f"Slack bot connected as {self._bot_user_id}")
+            logger.info("Slack bot connected as {}", self._bot_user_id)
         except Exception as e:
             logger.warning("Slack auth_test failed: {}", e)
 
diff --git a/nanobot/channels/telegram.py b/nanobot/channels/telegram.py
index 42db489..fa36c98 100644
--- a/nanobot/channels/telegram.py
+++ b/nanobot/channels/telegram.py
@@ -165,7 +165,7 @@ class TelegramChannel(BaseChannel):
         
         # Get bot info and register command menu
         bot_info = await self._app.bot.get_me()
-        logger.info(f"Telegram bot @{bot_info.username} connected")
+        logger.info("Telegram bot @{} connected", bot_info.username)
         
         try:
             await self._app.bot.set_my_commands(self.BOT_COMMANDS)
@@ -221,7 +221,7 @@ class TelegramChannel(BaseChannel):
         try:
             chat_id = int(msg.chat_id)
         except ValueError:
-            logger.error(f"Invalid chat_id: {msg.chat_id}")
+            logger.error("Invalid chat_id: {}", msg.chat_id)
             return
 
         # Send media files
@@ -344,14 +344,14 @@ class TelegramChannel(BaseChannel):
                     transcriber = GroqTranscriptionProvider(api_key=self.groq_api_key)
                     transcription = await transcriber.transcribe(file_path)
                     if transcription:
-                        logger.info(f"Transcribed {media_type}: {transcription[:50]}...")
+                        logger.info("Transcribed {}: {}...", media_type, transcription[:50])
                         content_parts.append(f"[transcription: {transcription}]")
                     else:
                         content_parts.append(f"[{media_type}: {file_path}]")
                 else:
                     content_parts.append(f"[{media_type}: {file_path}]")
                     
-                logger.debug(f"Downloaded {media_type} to {file_path}")
+                logger.debug("Downloaded {} to {}", media_type, file_path)
             except Exception as e:
                 logger.error("Failed to download media: {}", e)
                 content_parts.append(f"[{media_type}: download failed]")
diff --git a/nanobot/channels/whatsapp.py b/nanobot/channels/whatsapp.py
index 4d12360..f3e14d9 100644
--- a/nanobot/channels/whatsapp.py
+++ b/nanobot/channels/whatsapp.py
@@ -34,7 +34,7 @@ class WhatsAppChannel(BaseChannel):
         
         bridge_url = self.config.bridge_url
         
-        logger.info(f"Connecting to WhatsApp bridge at {bridge_url}...")
+        logger.info("Connecting to WhatsApp bridge at {}...", bridge_url)
         
         self._running = True
         
@@ -112,11 +112,11 @@ class WhatsAppChannel(BaseChannel):
             # Extract just the phone number or lid as chat_id
             user_id = pn if pn else sender
             sender_id = user_id.split("@")[0] if "@" in user_id else user_id
-            logger.info(f"Sender {sender}")
+            logger.info("Sender {}", sender)
             
             # Handle voice transcription if it's a voice message
             if content == "[Voice Message]":
-                logger.info(f"Voice message received from {sender_id}, but direct download from bridge is not yet supported.")
+                logger.info("Voice message received from {}, but direct download from bridge is not yet supported.", sender_id)
                 content = "[Voice Message: Transcription not available for WhatsApp yet]"
             
             await self._handle_message(
@@ -133,7 +133,7 @@ class WhatsAppChannel(BaseChannel):
         elif msg_type == "status":
             # Connection status update
             status = data.get("status")
-            logger.info(f"WhatsApp status: {status}")
+            logger.info("WhatsApp status: {}", status)
             
             if status == "connected":
                 self._connected = True
diff --git a/nanobot/cron/service.py b/nanobot/cron/service.py
index d2b9ef7..4c14ef7 100644
--- a/nanobot/cron/service.py
+++ b/nanobot/cron/service.py
@@ -157,7 +157,7 @@ class CronService:
         self._recompute_next_runs()
         self._save_store()
         self._arm_timer()
-        logger.info(f"Cron service started with {len(self._store.jobs if self._store else [])} jobs")
+        logger.info("Cron service started with {} jobs", len(self._store.jobs if self._store else []))
     
     def stop(self) -> None:
         """Stop the cron service."""
@@ -222,7 +222,7 @@ class CronService:
     async def _execute_job(self, job: CronJob) -> None:
         """Execute a single job."""
         start_ms = _now_ms()
-        logger.info(f"Cron: executing job '{job.name}' ({job.id})")
+        logger.info("Cron: executing job '{}' ({})", job.name, job.id)
         
         try:
             response = None
@@ -231,7 +231,7 @@ class CronService:
             
             job.state.last_status = "ok"
             job.state.last_error = None
-            logger.info(f"Cron: job '{job.name}' completed")
+            logger.info("Cron: job '{}' completed", job.name)
             
         except Exception as e:
             job.state.last_status = "error"
@@ -296,7 +296,7 @@ class CronService:
         self._save_store()
         self._arm_timer()
         
-        logger.info(f"Cron: added job '{name}' ({job.id})")
+        logger.info("Cron: added job '{}' ({})", name, job.id)
         return job
     
     def remove_job(self, job_id: str) -> bool:
@@ -309,7 +309,7 @@ class CronService:
         if removed:
             self._save_store()
             self._arm_timer()
-            logger.info(f"Cron: removed job {job_id}")
+            logger.info("Cron: removed job {}", job_id)
         
         return removed
     
diff --git a/nanobot/heartbeat/service.py b/nanobot/heartbeat/service.py
index 8bdc78f..8b33e3a 100644
--- a/nanobot/heartbeat/service.py
+++ b/nanobot/heartbeat/service.py
@@ -78,7 +78,7 @@ class HeartbeatService:
         
         self._running = True
         self._task = asyncio.create_task(self._run_loop())
-        logger.info(f"Heartbeat started (every {self.interval_s}s)")
+        logger.info("Heartbeat started (every {}s)", self.interval_s)
     
     def stop(self) -> None:
         """Stop the heartbeat service."""
@@ -118,7 +118,7 @@ class HeartbeatService:
                 if HEARTBEAT_OK_TOKEN.replace("_", "") in response.upper().replace("_", ""):
                     logger.info("Heartbeat: OK (no action needed)")
                 else:
-                    logger.info(f"Heartbeat: completed task")
+                    logger.info("Heartbeat: completed task")
                     
             except Exception as e:
                 logger.error("Heartbeat execution failed: {}", e)
diff --git a/nanobot/providers/transcription.py b/nanobot/providers/transcription.py
index eb5969d..7a3c628 100644
--- a/nanobot/providers/transcription.py
+++ b/nanobot/providers/transcription.py
@@ -35,7 +35,7 @@ class GroqTranscriptionProvider:
         
         path = Path(file_path)
         if not path.exists():
-            logger.error(f"Audio file not found: {file_path}")
+            logger.error("Audio file not found: {}", file_path)
             return ""
         
         try:
diff --git a/nanobot/session/manager.py b/nanobot/session/manager.py
index 44dcecb..9c0c7de 100644
--- a/nanobot/session/manager.py
+++ b/nanobot/session/manager.py
@@ -110,7 +110,7 @@ class SessionManager:
             if legacy_path.exists():
                 import shutil
                 shutil.move(str(legacy_path), str(path))
-                logger.info(f"Migrated session {key} from legacy path")
+                logger.info("Migrated session {} from legacy path", key)
 
         if not path.exists():
             return None

From e17342ddfc812a629d54e4be28f7cb39a84be424 Mon Sep 17 00:00:00 2001
From: Re-bin <xubinrencs@gmail.com>
Date: Fri, 20 Feb 2026 08:03:24 +0000
Subject: [PATCH 23/35] fix: pass workspace to file tools in subagent

---
 nanobot/agent/subagent.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/nanobot/agent/subagent.py b/nanobot/agent/subagent.py
index 767bc68..d87c61a 100644
--- a/nanobot/agent/subagent.py
+++ b/nanobot/agent/subagent.py
@@ -103,10 +103,10 @@ class SubagentManager:
             # Build subagent tools (no message tool, no spawn tool)
             tools = ToolRegistry()
             allowed_dir = self.workspace if self.restrict_to_workspace else None
-            tools.register(ReadFileTool(allowed_dir=allowed_dir))
-            tools.register(WriteFileTool(allowed_dir=allowed_dir))
-            tools.register(EditFileTool(allowed_dir=allowed_dir))
-            tools.register(ListDirTool(allowed_dir=allowed_dir))
+            tools.register(ReadFileTool(workspace=self.workspace, allowed_dir=allowed_dir))
+            tools.register(WriteFileTool(workspace=self.workspace, allowed_dir=allowed_dir))
+            tools.register(EditFileTool(workspace=self.workspace, allowed_dir=allowed_dir))
+            tools.register(ListDirTool(workspace=self.workspace, allowed_dir=allowed_dir))
             tools.register(ExecTool(
                 working_dir=str(self.workspace),
                 timeout=self.exec_config.timeout,

From 002de466d769ffa81a0fa89ff8056f0eb9cdc5fd Mon Sep 17 00:00:00 2001
From: Re-bin <xubinrencs@gmail.com>
Date: Fri, 20 Feb 2026 08:12:23 +0000
Subject: [PATCH 24/35] chore: remove test file for memory consolidation fix

---
 README.md                                |   2 +-
 tests/test_memory_consolidation_types.py | 133 -----------------------
 2 files changed, 1 insertion(+), 134 deletions(-)
 delete mode 100644 tests/test_memory_consolidation_types.py

diff --git a/README.md b/README.md
index a474367..289ff28 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,7 @@
 
 ⚡️ Delivers core agent functionality in just **~4,000** lines of code — **99% smaller** than Clawdbot's 430k+ lines.
 
-📏 Real-time line count: **3,761 lines** (run `bash core_agent_lines.sh` to verify anytime)
+📏 Real-time line count: **3,781 lines** (run `bash core_agent_lines.sh` to verify anytime)
 
 ## 📢 News
 
diff --git a/tests/test_memory_consolidation_types.py b/tests/test_memory_consolidation_types.py
deleted file mode 100644
index 3b76596..0000000
--- a/tests/test_memory_consolidation_types.py
+++ /dev/null
@@ -1,133 +0,0 @@
-"""Test memory consolidation handles non-string values from LLM.
-
-This test verifies the fix for the bug where memory consolidation fails
-when LLM returns JSON objects instead of strings for history_entry or
-memory_update fields.
-
-Related issue: Memory consolidation fails with TypeError when LLM returns dict
-"""
-
-import json
-import tempfile
-from pathlib import Path
-
-import pytest
-
-from nanobot.agent.memory import MemoryStore
-
-
-class TestMemoryConsolidationTypeHandling:
-    """Test that MemoryStore methods handle type conversion correctly."""
-
-    def test_append_history_accepts_string(self):
-        """MemoryStore.append_history should accept string values."""
-        with tempfile.TemporaryDirectory() as tmpdir:
-            memory = MemoryStore(Path(tmpdir))
-            
-            # Should not raise TypeError
-            memory.append_history("[2026-02-14] Test entry")
-            
-            # Verify content was written
-            history_content = memory.history_file.read_text()
-            assert "Test entry" in history_content
-
-    def test_write_long_term_accepts_string(self):
-        """MemoryStore.write_long_term should accept string values."""
-        with tempfile.TemporaryDirectory() as tmpdir:
-            memory = MemoryStore(Path(tmpdir))
-            
-            # Should not raise TypeError
-            memory.write_long_term("- Fact 1\n- Fact 2")
-            
-            # Verify content was written
-            memory_content = memory.read_long_term()
-            assert "Fact 1" in memory_content
-
-    def test_type_conversion_dict_to_str(self):
-        """Dict values should be converted to JSON strings."""
-        input_val = {"timestamp": "2026-02-14", "summary": "test"}
-        expected = '{"timestamp": "2026-02-14", "summary": "test"}'
-        
-        # Simulate the fix logic
-        if not isinstance(input_val, str):
-            result = json.dumps(input_val, ensure_ascii=False)
-        else:
-            result = input_val
-        
-        assert result == expected
-        assert isinstance(result, str)
-
-    def test_type_conversion_list_to_str(self):
-        """List values should be converted to JSON strings."""
-        input_val = ["item1", "item2"]
-        expected = '["item1", "item2"]'
-        
-        # Simulate the fix logic
-        if not isinstance(input_val, str):
-            result = json.dumps(input_val, ensure_ascii=False)
-        else:
-            result = input_val
-        
-        assert result == expected
-        assert isinstance(result, str)
-
-    def test_type_conversion_str_unchanged(self):
-        """String values should remain unchanged."""
-        input_val = "already a string"
-        
-        # Simulate the fix logic
-        if not isinstance(input_val, str):
-            result = json.dumps(input_val, ensure_ascii=False)
-        else:
-            result = input_val
-        
-        assert result == input_val
-        assert isinstance(result, str)
-
-    def test_memory_consolidation_simulation(self):
-        """Simulate full consolidation with dict values from LLM."""
-        with tempfile.TemporaryDirectory() as tmpdir:
-            memory = MemoryStore(Path(tmpdir))
-            
-            # Simulate LLM returning dict values (the bug scenario)
-            history_entry = {"timestamp": "2026-02-14", "summary": "User asked about..."}
-            memory_update = {"facts": ["Location: Beijing", "Skill: Python"]}
-            
-            # Apply the fix: convert to str
-            if not isinstance(history_entry, str):
-                history_entry = json.dumps(history_entry, ensure_ascii=False)
-            if not isinstance(memory_update, str):
-                memory_update = json.dumps(memory_update, ensure_ascii=False)
-            
-            # Should not raise TypeError after conversion
-            memory.append_history(history_entry)
-            memory.write_long_term(memory_update)
-            
-            # Verify content
-            assert memory.history_file.exists()
-            assert memory.memory_file.exists()
-            
-            history_content = memory.history_file.read_text()
-            memory_content = memory.read_long_term()
-            
-            assert "timestamp" in history_content
-            assert "facts" in memory_content
-
-
-class TestPromptOptimization:
-    """Test that prompt optimization helps prevent the issue."""
-
-    def test_prompt_includes_string_requirement(self):
-        """The prompt should explicitly require string values."""
-        # This is a documentation test - verify the fix is in place
-        # by checking the expected prompt content
-        expected_keywords = [
-            "MUST be strings",
-            "not objects or arrays",
-            "Example:",
-        ]
-        
-        # The actual prompt content is in nanobot/agent/loop.py
-        # This test serves as documentation of the expected behavior
-        for keyword in expected_keywords:
-            assert keyword, f"Prompt should include: {keyword}"

From 9ffae47c13862c0942b16016e67725af199a5ace Mon Sep 17 00:00:00 2001
From: Re-bin <xubinrencs@gmail.com>
Date: Fri, 20 Feb 2026 08:21:02 +0000
Subject: [PATCH 25/35] refactor(litellm): remove redundant comments in
 cache_control methods

---
 nanobot/providers/litellm_provider.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/nanobot/providers/litellm_provider.py b/nanobot/providers/litellm_provider.py
index 08c2f53..66751ed 100644
--- a/nanobot/providers/litellm_provider.py
+++ b/nanobot/providers/litellm_provider.py
@@ -117,7 +117,6 @@ class LiteLLMProvider(LLMProvider):
         tools: list[dict[str, Any]] | None,
     ) -> tuple[list[dict[str, Any]], list[dict[str, Any]] | None]:
         """Return copies of messages and tools with cache_control injected."""
-        # Transform the system message
         new_messages = []
         for msg in messages:
             if msg.get("role") == "system":
@@ -131,7 +130,6 @@ class LiteLLMProvider(LLMProvider):
             else:
                 new_messages.append(msg)
 
-        # Add cache_control to the last tool definition
         new_tools = tools
         if tools:
             new_tools = list(tools)

From 2383dcb3a82868162a970b91528945a84467af93 Mon Sep 17 00:00:00 2001
From: Re-bin <xubinrencs@gmail.com>
Date: Fri, 20 Feb 2026 08:31:48 +0000
Subject: [PATCH 26/35] style: use loguru native format and trim comments in
 interim retry

---
 README.md             |  2 +-
 nanobot/agent/loop.py | 11 +++--------
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/README.md b/README.md
index 289ff28..21c5491 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,7 @@
 
 ⚡️ Delivers core agent functionality in just **~4,000** lines of code — **99% smaller** than Clawdbot's 430k+ lines.
 
-📏 Real-time line count: **3,781 lines** (run `bash core_agent_lines.sh` to verify anytime)
+📏 Real-time line count: **3,793 lines** (run `bash core_agent_lines.sh` to verify anytime)
 
 ## 📢 News
 
diff --git a/nanobot/agent/loop.py b/nanobot/agent/loop.py
index 3829626..a90dccb 100644
--- a/nanobot/agent/loop.py
+++ b/nanobot/agent/loop.py
@@ -227,16 +227,11 @@ class AgentLoop:
                     )
             else:
                 final_content = self._strip_think(response.content)
-                # Some models (MiniMax, Gemini Flash, GPT-4.1, etc.) send an
-                # interim text response (e.g. "Let me investigate...") before
-                # making tool calls. If no tools have been used yet and we
-                # haven't already retried, add the text to the conversation
-                # and give the model one more chance to use tools.
-                # We do NOT forward the interim text as progress to avoid
-                # duplicate messages when the model simply answers directly.
+                # Some models send an interim text response before tool calls.
+                # Give them one retry; don't forward the text to avoid duplicates.
                 if not tools_used and not text_only_retried and final_content:
                     text_only_retried = True
-                    logger.debug(f"Interim text response (no tools used yet), retrying: {final_content[:80]}")
+                    logger.debug("Interim text response (no tools used yet), retrying: {}", final_content[:80])
                     messages = self.context.add_assistant_message(
                         messages, response.content,
                         reasoning_content=response.reasoning_content,

From 2f315ec567ab2432ab32332e3fa671a1bdc44dc6 Mon Sep 17 00:00:00 2001
From: Re-bin <xubinrencs@gmail.com>
Date: Fri, 20 Feb 2026 08:39:26 +0000
Subject: [PATCH 27/35] style: trim _on_help docstring

---
 nanobot/channels/telegram.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/nanobot/channels/telegram.py b/nanobot/channels/telegram.py
index af161d4..768e565 100644
--- a/nanobot/channels/telegram.py
+++ b/nanobot/channels/telegram.py
@@ -267,11 +267,7 @@ class TelegramChannel(BaseChannel):
         )
 
     async def _on_help(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-        """Handle /help command directly, bypassing access control.
-
-        /help is informational and should be accessible to all users,
-        even those not in the allowFrom list.
-        """
+        """Handle /help command, bypassing ACL so all users can access it."""
         if not update.message:
             return
         await update.message.reply_text(

From 25efd1bc543d2de31bb9f347b8fa168512b7dfde Mon Sep 17 00:00:00 2001
From: Re-bin <xubinrencs@gmail.com>
Date: Fri, 20 Feb 2026 08:45:42 +0000
Subject: [PATCH 28/35] docs: update docs for providers

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index dc85b54..c0bd4f4 100644
--- a/README.md
+++ b/README.md
@@ -591,7 +591,7 @@ Config file: `~/.nanobot/config.json`
 | `gemini` | LLM (Gemini direct) | [aistudio.google.com](https://aistudio.google.com) |
 | `minimax` | LLM (MiniMax direct) | [platform.minimax.io](https://platform.minimax.io) |
 | `aihubmix` | LLM (API gateway, access to all models) | [aihubmix.com](https://aihubmix.com) |
-| `siliconflow` | LLM (SiliconFlow/硅基流动, API gateway) | [siliconflow.cn](https://siliconflow.cn) |
+| `siliconflow` | LLM (SiliconFlow/硅基流动) | [siliconflow.cn](https://siliconflow.cn) |
 | `volcengine` | LLM (VolcEngine/火山引擎) | [volcengine.com](https://www.volcengine.com) |
 | `dashscope` | LLM (Qwen) | [dashscope.console.aliyun.com](https://dashscope.console.aliyun.com) |
 | `moonshot` | LLM (Moonshot/Kimi) | [platform.moonshot.cn](https://platform.moonshot.cn) |

From f5fe74f5789be04028a03ed8c95c9f35feb2fd81 Mon Sep 17 00:00:00 2001
From: Re-bin <xubinrencs@gmail.com>
Date: Fri, 20 Feb 2026 08:49:49 +0000
Subject: [PATCH 29/35] style: move httpx import to top-level and fix README
 example for MCP headers

---
 README.md                  | 17 ++++++++---------
 nanobot/agent/tools/mcp.py |  2 +-
 2 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/README.md b/README.md
index ece47e0..b37f8bd 100644
--- a/README.md
+++ b/README.md
@@ -753,15 +753,14 @@ Add MCP servers to your `config.json`:
       "filesystem": {
         "command": "npx",
         "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"]
-      }
-    },
-    "urlMcpServers": {
-        "url": "https://xx.xx.xx.xx:xxxx/mcp/",
-        "headers": {
-          "Authorization": "Bearer xxxxx",
-          "X-API-Key": "xxxxxxx"
-        }
       },
+      "my-remote-mcp": {
+        "url": "https://example.com/mcp/",
+        "headers": {
+          "Authorization": "Bearer xxxxx"
+        }
+      }
+    }
   }
 }
 ```
@@ -771,7 +770,7 @@ Two transport modes are supported:
 | Mode | Config | Example |
 |------|--------|---------|
 | **Stdio** | `command` + `args` | Local process via `npx` / `uvx` |
-| **HTTP** | `url` + `option(headers)`| Remote endpoint (`https://mcp.example.com/sse`) |
+| **HTTP** | `url` + `headers` (optional) | Remote endpoint (`https://mcp.example.com/sse`) |
 
 MCP tools are automatically discovered and registered on startup. The LLM can use them alongside built-in tools — no extra configuration needed.
 
diff --git a/nanobot/agent/tools/mcp.py b/nanobot/agent/tools/mcp.py
index a02f42b..ad352bf 100644
--- a/nanobot/agent/tools/mcp.py
+++ b/nanobot/agent/tools/mcp.py
@@ -3,6 +3,7 @@
 from contextlib import AsyncExitStack
 from typing import Any
 
+import httpx
 from loguru import logger
 
 from nanobot.agent.tools.base import Tool
@@ -59,7 +60,6 @@ async def connect_mcp_servers(
                 read, write = await stack.enter_async_context(stdio_client(params))
             elif cfg.url:
                 from mcp.client.streamable_http import streamable_http_client
-                import httpx
                 if cfg.headers:
                     http_client = await stack.enter_async_context(
                         httpx.AsyncClient(

From b97b1a5e91bd8778e5625b2debc48c49998f0ada Mon Sep 17 00:00:00 2001
From: Re-bin <xubinrencs@gmail.com>
Date: Fri, 20 Feb 2026 09:04:33 +0000
Subject: [PATCH 30/35] fix: pass full agent config including mcp_servers to
 cron run command

---
 nanobot/cli/commands.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/nanobot/cli/commands.py b/nanobot/cli/commands.py
index 9389d0b..a135349 100644
--- a/nanobot/cli/commands.py
+++ b/nanobot/cli/commands.py
@@ -864,11 +864,12 @@ def cron_run(
     force: bool = typer.Option(False, "--force", "-f", help="Run even if disabled"),
 ):
     """Manually run a job."""
+    from loguru import logger
     from nanobot.config.loader import load_config, get_data_dir
     from nanobot.cron.service import CronService
+    from nanobot.cron.types import CronJob
     from nanobot.bus.queue import MessageBus
     from nanobot.agent.loop import AgentLoop
-    from loguru import logger
     logger.disable("nanobot")
 
     config = load_config()
@@ -879,10 +880,14 @@ def cron_run(
         provider=provider,
         workspace=config.workspace_path,
         model=config.agents.defaults.model,
+        temperature=config.agents.defaults.temperature,
+        max_tokens=config.agents.defaults.max_tokens,
         max_iterations=config.agents.defaults.max_tool_iterations,
         memory_window=config.agents.defaults.memory_window,
+        brave_api_key=config.tools.web.search.api_key or None,
         exec_config=config.tools.exec,
         restrict_to_workspace=config.tools.restrict_to_workspace,
+        mcp_servers=config.tools.mcp_servers,
     )
 
     store_path = get_data_dir() / "cron" / "jobs.json"
@@ -890,7 +895,7 @@ def cron_run(
 
     result_holder = []
 
-    async def on_job(job):
+    async def on_job(job: CronJob) -> str | None:
         response = await agent_loop.process_direct(
             job.payload.message,
             session_key=f"cron:{job.id}",

From e1854c4373cd7b944c18452bb0c852ee214c032d Mon Sep 17 00:00:00 2001
From: Re-bin <xubinrencs@gmail.com>
Date: Fri, 20 Feb 2026 11:13:10 +0000
Subject: [PATCH 31/35] feat: make Telegram reply-to-message behavior
 configurable, default false

---
 nanobot/channels/telegram.py | 14 +++++++-------
 nanobot/config/schema.py     |  1 +
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/nanobot/channels/telegram.py b/nanobot/channels/telegram.py
index d29fdfd..6cd98e7 100644
--- a/nanobot/channels/telegram.py
+++ b/nanobot/channels/telegram.py
@@ -224,14 +224,14 @@ class TelegramChannel(BaseChannel):
             logger.error("Invalid chat_id: {}", msg.chat_id)
             return
 
-        # Build reply parameters (Will reply to the message if it exists)
-        reply_to_message_id = msg.metadata.get("message_id")
         reply_params = None
-        if reply_to_message_id:
-            reply_params = ReplyParameters(
-                message_id=reply_to_message_id,
-                allow_sending_without_reply=True
-            )
+        if self.config.reply_to_message:
+            reply_to_message_id = msg.metadata.get("message_id")
+            if reply_to_message_id:
+                reply_params = ReplyParameters(
+                    message_id=reply_to_message_id,
+                    allow_sending_without_reply=True
+                )
 
         # Send media files
         for media_path in (msg.media or []):
diff --git a/nanobot/config/schema.py b/nanobot/config/schema.py
index 570f322..966d11d 100644
--- a/nanobot/config/schema.py
+++ b/nanobot/config/schema.py
@@ -28,6 +28,7 @@ class TelegramConfig(Base):
     token: str = ""  # Bot token from @BotFather
     allow_from: list[str] = Field(default_factory=list)  # Allowed user IDs or usernames
     proxy: str | None = None  # HTTP/SOCKS5 proxy URL, e.g. "http://127.0.0.1:7890" or "socks5://127.0.0.1:1080"
+    reply_to_message: bool = False  # If true, bot replies quote the original message
 
 
 class FeishuConfig(Base):

From 8db91f59e26cd0ca83fc5eb01dd346a2410d98f9 Mon Sep 17 00:00:00 2001
From: Re-bin <xubinrencs@gmail.com>
Date: Fri, 20 Feb 2026 11:18:57 +0000
Subject: [PATCH 32/35] style: remove trailing space

---
 README.md             | 2 +-
 nanobot/agent/loop.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index b37f8bd..68ad5a9 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,7 @@
 
 ⚡️ Delivers core agent functionality in just **~4,000** lines of code — **99% smaller** than Clawdbot's 430k+ lines.
 
-📏 Real-time line count: **3,793 lines** (run `bash core_agent_lines.sh` to verify anytime)
+📏 Real-time line count: **3,827 lines** (run `bash core_agent_lines.sh` to verify anytime)
 
 ## 📢 News
 
diff --git a/nanobot/agent/loop.py b/nanobot/agent/loop.py
index 14a8be6..3016d92 100644
--- a/nanobot/agent/loop.py
+++ b/nanobot/agent/loop.py
@@ -200,7 +200,7 @@ class AgentLoop:
             if response.has_tool_calls:
                 if on_progress:
                     clean = self._strip_think(response.content)
-                    if clean: 
+                    if clean:
                         await on_progress(clean)
                     await on_progress(self._tool_hint(response.tool_calls))
 

From 5cc019bf1a53df1fd2ff1e50cd40b4e358804a4f Mon Sep 17 00:00:00 2001
From: Re-bin <xubinrencs@gmail.com>
Date: Fri, 20 Feb 2026 11:27:21 +0000
Subject: [PATCH 33/35] style: trim verbose comments in _sanitize_messages

---
 nanobot/providers/litellm_provider.py | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

diff --git a/nanobot/providers/litellm_provider.py b/nanobot/providers/litellm_provider.py
index 4fe44f7..edeb5c6 100644
--- a/nanobot/providers/litellm_provider.py
+++ b/nanobot/providers/litellm_provider.py
@@ -12,9 +12,7 @@ from nanobot.providers.base import LLMProvider, LLMResponse, ToolCallRequest
 from nanobot.providers.registry import find_by_model, find_gateway
 
 
-# Keys that are part of the OpenAI chat-completion message schema.
-# Anything else (e.g. reasoning_content, timestamp) is stripped before sending
-# to avoid "Unrecognized chat message" errors from strict providers like StepFun.
+# Standard OpenAI chat-completion message keys; extras (e.g. reasoning_content) are stripped for strict providers.
 _ALLOWED_MSG_KEYS = frozenset({"role", "content", "tool_calls", "tool_call_id", "name"})
 
 
@@ -155,13 +153,7 @@ class LiteLLMProvider(LLMProvider):
     
     @staticmethod
     def _sanitize_messages(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
-        """Strip non-standard keys from messages for strict providers.
-
-        Some providers (e.g. StepFun via OpenRouter) reject messages that
-        contain extra keys like ``reasoning_content``. This method keeps
-        only the keys defined in the OpenAI chat-completion schema and
-        ensures every assistant message has a ``content`` key.
-        """
+        """Strip non-standard keys and ensure assistant messages have a content key."""
         sanitized = []
         for msg in messages:
             clean = {k: v for k, v in msg.items() if k in _ALLOWED_MSG_KEYS}

From b286457c854fd3d60228b680ec0dbc8d29286303 Mon Sep 17 00:00:00 2001
From: tercerapersona <andyourbirdisgreen@gmail.com>
Date: Fri, 20 Feb 2026 11:34:50 -0300
Subject: [PATCH 34/35] add Openrouter prompt caching via cache_control

---
 nanobot/providers/registry.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/nanobot/providers/registry.py b/nanobot/providers/registry.py
index 445d977..ecf092f 100644
--- a/nanobot/providers/registry.py
+++ b/nanobot/providers/registry.py
@@ -100,6 +100,7 @@ PROVIDERS: tuple[ProviderSpec, ...] = (
         default_api_base="https://openrouter.ai/api/v1",
         strip_model_prefix=False,
         model_overrides=(),
+        supports_prompt_caching=True,
     ),
 
     # AiHubMix: global gateway, OpenAI-compatible interface.

From cc04bc4dd1806f30e2f622a2628ddb40afc84fe7 Mon Sep 17 00:00:00 2001
From: Re-bin <xubinrencs@gmail.com>
Date: Fri, 20 Feb 2026 15:14:45 +0000
Subject: [PATCH 35/35] fix: check gateway's supports_prompt_caching instead of
 always returning False

---
 nanobot/providers/litellm_provider.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nanobot/providers/litellm_provider.py b/nanobot/providers/litellm_provider.py
index edeb5c6..58c9ac2 100644
--- a/nanobot/providers/litellm_provider.py
+++ b/nanobot/providers/litellm_provider.py
@@ -111,7 +111,7 @@ class LiteLLMProvider(LLMProvider):
     def _supports_cache_control(self, model: str) -> bool:
         """Return True when the provider supports cache_control on content blocks."""
         if self._gateway is not None:
-            return False
+            return self._gateway.supports_prompt_caching
         spec = find_by_model(model)
         return spec is not None and spec.supports_prompt_caching