@misterhuydo/sentinel 1.1.1 → 1.1.3

package/.cairn/session.json

@@ -1,6 +1,6 @@
 {
-  "message": "Auto-checkpoint at 2026-03-23T08:28:23.743Z",
-  "checkpoint_at": "2026-03-23T08:28:23.744Z",
+  "message": "Auto-checkpoint at 2026-03-23T08:30:55.526Z",
+  "checkpoint_at": "2026-03-23T08:30:55.527Z",
   "active_files": [],
   "notes": [],
   "mtime_snapshot": {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@misterhuydo/sentinel",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Sentinel — Autonomous DevOps Agent installer and manager",
   "bin": {
     "sentinel": "./bin/sentinel.js"

package/python/sentinel/sentinel_boss.py

@@ -177,7 +177,8 @@ When to act vs. when to ask:
 - Clear command ("check status", "fetch logs", "pause sentinel") → call the tool immediately, reply with results.
 - Ambiguous or exploratory ("what does get_repo_status do?", "tell me about search_logs") → explain the tool naturally, then ask: "Want me to run it?"
 - Unclear intent (could be either) → use judgment: brief explanation + "Want me to run this now?"
-Never say "Stand by" or "Requesting..." and then return nothing. Either act, or ask.
+- If a tool call will take a moment (search, fetch, pull), prefix your reply with a brief "working" line ending in "..." before the results, e.g. "Searching SSOLWA for TryDig activity..." then the actual output.
+  Never just say a working line and stop — always follow it with the results in the same message.
 
 Issue identification — before calling create_issue:
 1. Determine if the message is a REAL issue/task (bug report, feature request, investigation ask)
@@ -1721,6 +1722,80 @@ async def _handle_with_cli(
     return reply, is_done
 
 
+# ── History serialization helpers ────────────────────────────────────────────
+
+def _serialize_content(content) -> list:
+    """Convert Anthropic SDK response content (Pydantic objects) to plain dicts.
+
+    The SDK returns TextBlock / ToolUseBlock instances.  json.dumps(..., default=str)
+    turns them into useless strings like "TextBlock(type='text', text='...')".
+    This converts them to proper dicts so history round-trips through SQLite safely.
+    """
+    if not isinstance(content, list):
+        return content
+    result = []
+    for block in content:
+        if isinstance(block, dict):
+            result.append(block)
+        elif hasattr(block, "model_dump"):
+            result.append(block.model_dump())
+        elif hasattr(block, "dict"):
+            result.append(block.dict())
+        elif hasattr(block, "type"):
+            if block.type == "text":
+                result.append({"type": "text", "text": getattr(block, "text", "")})
+            elif block.type == "tool_use":
+                result.append({
+                    "type":  "tool_use",
+                    "id":    getattr(block, "id", ""),
+                    "name":  getattr(block, "name", ""),
+                    "input": getattr(block, "input", {}),
+                })
+        else:
+            result.append({"type": "text", "text": str(block)})
+    return result
+
+
+def _clean_history(history: list) -> list:
+    """Remove turns that would cause a 400 from the Anthropic API.
+
+    Strips orphaned tool_use blocks (assistant turn with tool_use but no
+    following tool_result turn) and consecutive same-role turns that result
+    from a previous session that crashed mid-tool-loop.
+    """
+    cleaned = []
+    i = 0
+    while i < len(history):
+        turn = history[i]
+        role    = turn.get("role", "")
+        content = turn.get("content", [])
+
+        # Drop assistant turns that contain tool_use if the next turn isn't tool_result
+        if role == "assistant" and isinstance(content, list):
+            has_tool_use = any(
+                (isinstance(b, dict) and b.get("type") == "tool_use")
+                for b in content
+            )
+            if has_tool_use:
+                next_turn = history[i + 1] if i + 1 < len(history) else None
+                next_content = (next_turn or {}).get("content", [])
+                has_result = isinstance(next_content, list) and any(
+                    (isinstance(b, dict) and b.get("type") == "tool_result")
+                    for b in next_content
+                )
+                if not has_result:
+                    i += 1   # skip orphaned tool_use turn
+                    continue
+
+        # Drop consecutive same-role turns (keep the last one)
+        if cleaned and cleaned[-1].get("role") == role:
+            cleaned[-1] = turn
+        else:
+            cleaned.append(turn)
+        i += 1
+    return cleaned
+
+
 # ── API-key path (structured tools, full agentic loop) ────────────────────────
 
 async def _handle_with_api(
@@ -1768,13 +1843,15 @@ async def _handle_with_api(
         user_content = attach_blocks + [{"type": "text", "text": message}]
     else:
         user_content = message
-    history.append({"role": "user", "content": user_content})
-    messages = list(history)
+
+    # Work on a local copy — only commit to history on success to prevent
+    # cascading 400s if the API rejects a malformed/corrupted history.
+    messages = list(history) + [{"role": "user", "content": user_content}]
 
     while True:
         response = client.messages.create(
             model="claude-opus-4-6",
-            max_tokens=1024,
+            max_tokens=2048,
             system=system,
             tools=_TOOLS,
             messages=messages,
@@ -1798,10 +1875,12 @@ async def _handle_with_api(
             # Heuristic override: if reply ends with a question, Claude is waiting for input
             if is_done and re.search(r'\?\s*$', reply):
                 is_done = False
-            history.append({"role": "assistant", "content": response.content})
+            # Commit to history only on success — serialize SDK objects to plain dicts
+            history.append({"role": "user", "content": user_content})
+            history.append({"role": "assistant", "content": _serialize_content(response.content)})
             return reply, is_done
 
-        messages.append({"role": "assistant", "content": response.content})
+        messages.append({"role": "assistant", "content": _serialize_content(response.content)})
         tool_results = []
         for tc in tool_blocks:
             result = await _run_tool(tc.name, tc.input, cfg_loader, store, slack_client=slack_client, user_id=user_id, channel=channel, is_admin=is_admin)

package/python/sentinel/slack_bot.py

@@ -23,7 +23,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Optional
 
-from .sentinel_boss import handle_message
+from .sentinel_boss import handle_message, _clean_history
 
 logger = logging.getLogger(__name__)
 
@@ -370,9 +370,10 @@ _MAX_HISTORY_TURNS = 20   # keep last 20 exchanges (~40 messages) to stay well w
 async def _run_turn(session: _Session, message: str, client, cfg_loader, store, attachments: list | None = None, is_admin: bool = False) -> None:
     channel = session.channel
 
-    # Load persisted history from DB on the first turn of a new session
+    # Load persisted history from DB on the first turn of a new session.
+    # Clean it to strip any orphaned tool_use turns from a previous crashed session.
     if not session.history_loaded:
-        session.history = store.load_conversation(session.user_id)
+        session.history = _clean_history(store.load_conversation(session.user_id))
         session.history_loaded = True
 
     # Trim history to avoid context overflow on long conversations