feat: implement bulletproof history compaction and Set Recommended Model settings endpoint

backend.py

@@ -657,53 +657,60 @@ IMPORTANT RULES:
 
 def compact_history(messages: list) -> list:
     """
-    Compact conversation history to prevent context window overflow.
-    Replaces massive tool call outputs with concise summaries if history is long.
+    Bulletproof conversation history compaction.
+    Guarantees that the total context length stays well below the model's token limits.
     """
-    # Only compact if messages count exceeds 15 (to maintain normal conversation)
-    if len(messages) <= 15:
-        return messages
-        
-    compacted = []
-    # Always keep the system prompt (typically the first message)
-    if messages and messages[0].get("role") == "system":
-        compacted.append(messages[0])
+    if not messages:
+        return []
+
+    # Find and preserve the system prompt
+    system_msg = None
+    if messages[0].get("role") == "system":
+        system_msg = messages[0]
         start_idx = 1
     else:
         start_idx = 0
-        
-    # Keep the last 4 messages exactly as they are to preserve immediate context
-    recent_count = 4
-    mid_messages = messages[start_idx:-recent_count]
-    recent_messages = messages[-recent_count:]
+
+    other_messages = messages[start_idx:]
     
-    for msg in mid_messages:
+    # 1. Truncate individually massive messages (e.g. file contents or massive bash outputs)
+    # Even recent messages should be compacted if they are ridiculously large!
+    compacted_others = []
+    for msg in other_messages:
         role = msg.get("role")
         content = msg.get("content") or ""
+        msg_copy = dict(msg)
         
-        if role == "tool":
-            # Compress massive tool outputs (like bash stdout or file reads)
-            if len(content) > 1000:
-                summary = f"[Tool output compacted: {content[:200]}... (Total {len(content)} chars truncated for context preservation)]"
-                compacted.append({
-                    "role": "tool",
-                    "tool_call_id": msg.get("tool_call_id"),
-                    "content": summary
-                })
-                continue
-        elif role == "assistant" and msg.get("tool_calls"):
-            # Keep tool calls metadata so the model's message-tool call mapping DAG doesn't break
+        if len(content) > 15000:
+            msg_copy["content"] = content[:5000] + f"\n\n[... Truncated {len(content) - 10000} characters to prevent model context limits from overflowing ...]\n\n" + content[-5000:]
+        
+        compacted_others.append(msg_copy)
+
+    # 2. Enforce total character size budget (max ~300,000 characters / ~75,000 tokens)
+    # Iterate backwards from newest to oldest
+    final_list = []
+    total_chars = 0
+    max_budget = 300000
+    
+    for msg in reversed(compacted_others):
+        msg_len = len(msg.get("content") or "")
+        if total_chars + msg_len < max_budget or len(final_list) < 2:
+            final_list.append(msg)
+            total_chars += msg_len
+        else:
+            # Drop older messages once we exceed context window budget
             pass
-            
-        # Keep general messages, but truncate if they are too long
-        if len(content) > 2000:
-            msg = dict(msg)
-            msg["content"] = content[:2000] + "\n[Content truncated for compaction]"
-        compacted.append(msg)
+
+    # Reverse back to chronological order
+    final_list.reverse()
+    
+    if system_msg:
+        final_list.insert(0, system_msg)
+        
+    if len(messages) != len(final_list):
+        log_activity(f"[Auto-Compaction] Sliced context window from {len(messages)} down to {len(final_list)} messages (Total chars: {total_chars})")
         
-    compacted.extend(recent_messages)
-    log_activity(f"[Auto-Compaction] Compressed message history from {len(messages)} down to {len(compacted)}")
-    return compacted
+    return final_list
 
 
 @app.post("/v1/chat/completions")
@@ -2457,6 +2464,20 @@ async def download_backup(authorization: str = Header(None)):
         raise HTTPException(status_code=500, detail=str(e))
 
 
+class SetModelRequest(BaseModel):
+    model: str
+
+@app.post("/api/settings/model")
+async def set_recommended_model(req: SetModelRequest, authorization: str = Header(None)):
+    auth(authorization)
+    global RECOMMENDED_MODEL
+    if req.model not in TOOL_CAPABLE_MODELS:
+        raise HTTPException(status_code=400, detail="Invalid or unsupported agent model")
+    RECOMMENDED_MODEL = req.model
+    log_activity(f"[Settings] Recommended model manually updated to: {RECOMMENDED_MODEL}")
+    return {"status": "ok", "recommended_model": RECOMMENDED_MODEL}
+
+
 @app.get("/health")
 async def health():
     return {