alpiecode 10.5.0__tar.gz → 10.5.1__tar.gz

{alpiecode-10.5.0 → alpiecode-10.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 10.5.0
+Version: 10.5.1
 Summary: AlpieCode
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-10.5.0 → alpiecode-10.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "10.5.0"
+version = "10.5.1"
 description = "AlpieCode"
 requires-python = ">=3.9"
 dependencies = [

{alpiecode-10.5.0 → alpiecode-10.5.1}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 10.5.0
+Version: 10.5.1
 Summary: AlpieCode
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-10.5.0 → alpiecode-10.5.1}/src/alpiecode.egg-info/SOURCES.txt

@@ -42,4 +42,6 @@ src/codeagent/backends/__init__.py
 src/codeagent/backends/base.py
 src/codeagent/backends/local_backend.py
 src/codeagent/backends/openai_backend.py
-src/codeagent/extension/alpiecode.vsix
+src/codeagent/extension/alpiecode.vsix
+test/test_context_and_trajectory.py
+test/test_dream_rsi.py

{alpiecode-10.5.0 → alpiecode-10.5.1}/src/codeagent/__init__.py

@@ -17,7 +17,7 @@ Supports:
 from pathlib import Path
 from typing import Optional, Any, Dict
 
-__version__ = "10.5.0"
+__version__ = "10.5.1"
 
 def run(task: str, workdir: str = ".", reasoning_level: str = "thinking", **kwargs):
     """Run an autonomous coding task programmatically."""

{alpiecode-10.5.0 → alpiecode-10.5.1}/src/codeagent/backends/local_backend.py

@@ -91,26 +91,38 @@ class LocalBackend:
             elif not isinstance(content, str):
                 content = str(content)
 
-            # For assistant messages with tool_calls, embed tool call info in content text
+            # For assistant messages, condense bulky write_file / edit_file payloads from content
+            if role == "assistant":
+                from ..compaction import compact_text_tool_calls
+                content = compact_text_tool_calls(content)
+
+            # For assistant messages with tool_calls, embed tool call info in content text ONLY if not already marked
             if role == "assistant" and msg.get("tool_calls"):
-                tc_descriptions = []
-                for tc in msg["tool_calls"]:
-                    if isinstance(tc, dict):
-                        fn = tc.get("function", {})
-                        name = fn.get("name", "unknown")
-                        args = fn.get("arguments", "{}")
-                        # Do not duplicate full file content in context history
-                        if name in ("write_file", "edit_file"):
-                            try:
-                                import json as _json
-                                a_dict = _json.loads(args) if isinstance(args, str) else args
-                                p = a_dict.get("path") or a_dict.get("filename") or ""
-                                args = f'{"path": "{p}"}'
-                            except Exception:
-                                args = "{...}"
-                        tc_descriptions.append(f"[Called tool: {name}({args})]")
-                if tc_descriptions and "<tool_call>" not in content:
-                    content = (content + "\n" + "\n".join(tc_descriptions)).strip()
+                already_marked = (
+                    "[Completed " in content
+                    or "[Incomplete" in content
+                    or "[Called tool:" in content
+                    or "<tool_call>" in content
+                )
+                if not already_marked:
+                    tc_descriptions = []
+                    for tc in msg["tool_calls"]:
+                        if isinstance(tc, dict):
+                            fn = tc.get("function", {})
+                            name = fn.get("name", "unknown")
+                            args = fn.get("arguments", "{}")
+                            # Do not duplicate full file content in context history
+                            if name in ("write_file", "edit_file", "apply_patch"):
+                                try:
+                                    import json as _json
+                                    a_dict = _json.loads(args) if isinstance(args, str) else args
+                                    p = a_dict.get("path") or a_dict.get("filename") or a_dict.get("file") or ""
+                                    args = f'{{"path": "{p}"}}'
+                                except Exception:
+                                    args = "{...}"
+                            tc_descriptions.append(f"[Called tool: {name}({args})]")
+                    if tc_descriptions:
+                        content = (content + "\n" + "\n".join(tc_descriptions)).strip()
                 # Do NOT include tool_calls key — GGUF template will crash on it
 
             clean["content"] = content

{alpiecode-10.5.0 → alpiecode-10.5.1}/src/codeagent/backends/openai_backend.py

@@ -54,9 +54,11 @@ def _repair_and_parse_json_arguments(raw_args: str) -> dict:
     # If trailing comma at end: `{"a": 1,` -> `{"a": 1`
     repaired = re.sub(r",\s*$", "", repaired)
 
+    was_truncated = False
     # Check unclosed quotes: count non-escaped double quotes
     quote_count = len(re.findall(r'(?<!\\)"', repaired))
     if quote_count % 2 != 0:
+        was_truncated = True
         dangling_bs = len(repaired) - len(repaired.rstrip('\\'))
         if dangling_bs % 2 != 0:
             repaired = repaired[:-1]
@@ -75,6 +77,8 @@ def _repair_and_parse_json_arguments(raw_args: str) -> dict:
     try:
         parsed = json.loads(repaired)
         if isinstance(parsed, dict):
+            if was_truncated:
+                parsed["_was_truncated"] = True
             return parsed
     except Exception:
         pass

{alpiecode-10.5.0 → alpiecode-10.5.1}/src/codeagent/cli.py

@@ -31,16 +31,28 @@ def _show_banner():
 def _normalize_args():
     known_commands = {"init", "serve", "run", "chat", "plan", "diff", "undo", "doctor", "explain", "dream", "version", "-h", "--help", "-v", "--version"}
     subcommand = None
-    
+
+    # Normalize common flag typos / aliases before parsing
+    for idx, arg in enumerate(sys.argv):
+        if arg in ("--offlie", "-offline"):
+            sys.argv[idx] = "--offline"
+
     # Check if a subcommand is present
     for arg in sys.argv[1:]:
         if arg in known_commands:
             subcommand = arg
             break
-            
+
     if not subcommand and len(sys.argv) > 1:
-        subcommand = "run"
-        sys.argv.insert(1, "run")
+        # Determine if any positional non-flag argument was provided
+        positional_args = [a for a in sys.argv[1:] if not a.startswith("-")]
+        if not positional_args:
+            # Flags like --offline or --thinking given without a subcommand or task -> launch chat mode
+            subcommand = "chat"
+            sys.argv.insert(1, "chat")
+        else:
+            subcommand = "run"
+            sys.argv.insert(1, "run")
     elif subcommand and subcommand not in ("-h", "--help", "-v", "--version") and sys.argv[1] != subcommand:
         # Move subcommand to index 1 so subparsers parse arguments correctly without default override
         sys.argv.remove(subcommand)
@@ -49,11 +61,11 @@ def _normalize_args():
     if subcommand in ("run", "plan", "explain") and len(sys.argv) > 2:
         cmd_idx = sys.argv.index(subcommand)
         sub_args = sys.argv[cmd_idx + 1:]
-        
+
         flags = []
         positionals = []
-        value_flags = {"--workdir", "--image", "--video", "--url", "--github", "--max-turns", "--host", "--port"}
-        
+        value_flags = {"--workdir", "--image", "--video", "--url", "--github", "--max-turns", "--host", "--port", "--ctx-size"}
+
         i = 0
         while i < len(sub_args):
             arg = sub_args[i]
@@ -67,7 +79,7 @@ def _normalize_args():
             else:
                 positionals.append(arg)
             i += 1
-            
+
         sys.argv = sys.argv[:cmd_idx + 1] + flags + positionals
 
 
@@ -87,7 +99,7 @@ def main():
     common.add_argument("--quiet", action="store_true", help="Suppress per-turn logging")
     common.add_argument("--debug", action="store_true", help="Show autonomous discovery and debug diagnostics")
     common.add_argument("--offline", "--local", dest="offline", action="store_true", help="Run using local offline GGUF model on GPU without internet")
-    common.add_argument("--ctx-size", type=int, default=None, help="Context size in tokens (default: 4096 offline, 262144 online)")
+    common.add_argument("--ctx-size", type=int, default=None, help="Context size in tokens (default: 8192 offline, 262144 online)")
 
     from . import __version__
     parser = argparse.ArgumentParser(
@@ -103,7 +115,7 @@ def main():
     sub.add_parser("init", help="Configure your VLM/OpenAI-compatible endpoint")
 
     # ── serve ──
-    serve_p = sub.add_parser("serve", help="Start the AlpieCode API server")
+    serve_p = sub.add_parser("serve", help="Start the AlpieCode API server", parents=[common])
     serve_p.add_argument("--host", default="127.0.0.1", help="Host address to bind to (default: 127.0.0.1)")
     serve_p.add_argument("--port", type=int, default=7169, help="Port to listen on (default: 7169)")
 
@@ -125,14 +137,14 @@ def main():
     undo_p = sub.add_parser("undo", help="Revert file changes made by the last AlpieCode session", parents=[common])
 
     # ── doctor ──
-    sub.add_parser("doctor", help="Run system health checks (CUDA, Python, network, dev tools)")
+    sub.add_parser("doctor", help="Run system health checks (CUDA, Python, network, dev tools)", parents=[common])
 
     # ── explain ──
     explain_p = sub.add_parser("explain", help="Explain a file, function, or codebase concept", parents=[common])
     explain_p.add_argument("target", help="File path or concept to explain")
 
     # ?? dream ??
-    dream_p = sub.add_parser('dream', help='Dream-RSI: offline recursive self-improvement simulation')
+    dream_p = sub.add_parser('dream', help='Dream-RSI: offline recursive self-improvement simulation', parents=[common])
     dream_p.add_argument('--optimize', action='store_true', help='Run offline dreaming simulation to synthesize optimal search policy')
     dream_p.add_argument('--stats', action='store_true', help='Show trajectory replay metrics and active policy status')
     dream_p.add_argument('--clear', action='store_true', help='Clear historical trajectory replay pool')
@@ -227,9 +239,9 @@ def main():
 
     if getattr(args, "offline", False):
         cfg.base_url = "offline"
-        # 4096 default fits 4.4GB model + KV cache 100% in 6GB VRAM with zero host-paging
+        # 8192 default fits 4.4GB model + KV cache 100% in 6GB VRAM (4.75GB / 6GB) with zero host-paging
         import os
-        cfg.n_ctx = int(os.environ.get("ALPIECODE_CTX_SIZE", 4096))
+        cfg.n_ctx = int(os.environ.get("ALPIECODE_CTX_SIZE", 8192))
         os.environ["ALPIECODE_BASE_URL"] = "offline"
 
     if getattr(args, "ctx_size", None):

{alpiecode-10.5.0 → alpiecode-10.5.1}/src/codeagent/compaction.py

@@ -15,6 +15,7 @@ Strategy:
 """
 
 import json
+import re
 from typing import Any, Dict, List, Optional
 
 # Our model's context window
@@ -219,27 +220,120 @@ def select_relevant_history(
     return "### Relevant Historical Anchors:\n" + "\n".join(reversed(high_value_notes))
 
 
-def compact_messages(messages: List[dict]) -> List[dict]:
+def compact_text_tool_calls(text: str) -> str:
+    """Condense bulky file content in text-based tool calls."""
+    if not text or ("write_file" not in text and "edit_file" not in text and "apply_patch" not in text):
+        return text
+
+    def _replace_block(m):
+        raw = m.group(1).strip()
+        try:
+            from .backends.openai_backend import _repair_and_parse_json_arguments
+            data = _repair_and_parse_json_arguments(raw)
+            if isinstance(data, dict) and data.get("name") in ("write_file", "edit_file", "apply_patch"):
+                args = data.get("arguments", {})
+                if isinstance(args, dict):
+                    p = args.get("path") or args.get("filename") or args.get("file") or "file"
+                    return f"[Completed {data['name']} for '{p}']"
+        except Exception:
+            pass
+        return m.group(0)
+
+    # 1. First condense complete/closed <tool_call>...</tool_call> blocks
+    text = re.sub(r"<tool_call>\s*(.*?)\s*</tool_call>", _replace_block, text, flags=re.DOTALL)
+
+    # 2. Also condense unclosed/truncated <tool_call> blocks (e.g. from token cutoff before </tool_call>)
+    if "<tool_call>" in text:
+        def _replace_unclosed(m):
+            raw = m.group(0)
+            t_name = "write_file"
+            p = "file"
+            name_m = re.search(r'"name":\s*"([^"]+)"', raw)
+            if name_m:
+                t_name = name_m.group(1)
+            path_m = re.search(r'"(?:path|filename|file)":\s*"([^"]+)"', raw)
+            if path_m:
+                p = path_m.group(1)
+            return f"[Incomplete/truncated {t_name} for '{p}']"
+
+        text = re.sub(r"<tool_call>(?:(?!</tool_call>).)*$", _replace_unclosed, text, flags=re.DOTALL)
+
+    return text
+
+
+def compact_tool_calls(tool_calls: List[Any]) -> List[Any]:
+    """Condense bulky file content in historical tool calls to conserve context tokens."""
+    if not tool_calls:
+        return []
+    compacted = []
+    for tc in tool_calls:
+        if not isinstance(tc, dict):
+            compacted.append(tc)
+            continue
+        fn = tc.get("function", {})
+        if not isinstance(fn, dict):
+            compacted.append(tc)
+            continue
+        name = fn.get("name", "")
+        raw_args = fn.get("arguments", "")
+        if name in ("write_file", "edit_file", "apply_patch"):
+            try:
+                args = json.loads(raw_args) if isinstance(raw_args, str) else dict(raw_args)
+                content = args.get("content") or args.get("patch") or ""
+                path = args.get("path") or args.get("filename") or "file"
+                if isinstance(content, str) and len(content) > 150:
+                    lines = content.splitlines()
+                    args["content"] = f"[Content saved to {path} ({len(lines)} lines, {len(content)} bytes)]"
+                    compact_tc = dict(tc)
+                    compact_tc["function"] = dict(fn)
+                    compact_tc["function"]["arguments"] = json.dumps(args) if isinstance(raw_args, str) else args
+                    compacted.append(compact_tc)
+                    continue
+            except Exception:
+                pass
+        compacted.append(tc)
+    return compacted
+
+
+def compact_messages(messages: List[dict], keep_recent: int = KEEP_RECENT_TURNS) -> List[dict]:
     """
     Compact a message list by summarizing older turns.
 
     Preserves:
       - System prompt (index 0)
       - All user messages (verbatim)
-      - Last KEEP_RECENT_TURNS messages (verbatim)
+      - Last keep_recent messages (verbatim, with older tool arguments trimmed if bulky)
 
     Summarizes:
       - Older tool results (truncated)
       - Older assistant reasoning (removed)
+      - Older write_file/edit_file payload content (condensed)
     """
-    if len(messages) <= KEEP_RECENT_TURNS + 2:
-        return messages
+    if len(messages) <= keep_recent + 2:
+        # Even if short, condense older bulky assistant tool calls while keeping latest intact
+        result = []
+        last_asst_idx = -1
+        for i in range(len(messages) - 1, -1, -1):
+            if messages[i].get("role") == "assistant":
+                last_asst_idx = i
+                break
+        for i, m in enumerate(messages):
+            if i != last_asst_idx and m.get("role") == "assistant":
+                cm = dict(m)
+                if cm.get("tool_calls"):
+                    cm["tool_calls"] = compact_tool_calls(m["tool_calls"])
+                if cm.get("content"):
+                    cm["content"] = compact_text_tool_calls(cm["content"])
+                result.append(cm)
+            else:
+                result.append(m)
+        return result
 
     # Always keep system prompt
     system = messages[0] if messages and messages[0].get("role") == "system" else None
 
     # Split into old and recent
-    cutoff = len(messages) - KEEP_RECENT_TURNS
+    cutoff = len(messages) - keep_recent
 
     # ── Tool-Call Pairing Guard ──
     # If cutoff lands on a 'tool' message, move it backwards to include
@@ -263,11 +357,11 @@ def compact_messages(messages: List[dict]) -> List[dict]:
             compacted_old.append(msg)
 
         elif role == "assistant":
-            # Compact assistant messages: keep tool calls but remove reasoning
+            # Compact assistant messages: keep tool calls (condensed) but remove reasoning
             compact_msg = {"role": "assistant"}
             if msg.get("content"):
                 # Truncate long assistant content
-                content = msg["content"]
+                content = compact_text_tool_calls(msg["content"])
                 if len(content) > 200:
                     compact_msg["content"] = content[:200] + "..."
                 else:
@@ -276,7 +370,7 @@ def compact_messages(messages: List[dict]) -> List[dict]:
                 compact_msg["content"] = None
 
             if msg.get("tool_calls"):
-                compact_msg["tool_calls"] = msg["tool_calls"]
+                compact_msg["tool_calls"] = compact_tool_calls(msg["tool_calls"])
             compacted_old.append(compact_msg)
 
         elif role == "tool":
@@ -301,11 +395,29 @@ def compact_messages(messages: List[dict]) -> List[dict]:
                 "content": _summarize_tool_result(tool_name, content),
             })
 
+    # In recent messages, also condense older assistant tool calls (except the immediate last one)
+    last_asst_idx = -1
+    for i in range(len(recent_messages) - 1, -1, -1):
+        if recent_messages[i].get("role") == "assistant":
+            last_asst_idx = i
+            break
+
+    cleaned_recent = []
+    for i, m in enumerate(recent_messages):
+        if i != last_asst_idx and m.get("role") == "assistant":
+            cm = dict(m)
+            if cm.get("tool_calls"):
+                cm["tool_calls"] = compact_tool_calls(m["tool_calls"])
+            if cm.get("content"):
+                cm["content"] = compact_text_tool_calls(cm["content"])
+            cleaned_recent.append(cm)
+        else:
+            cleaned_recent.append(m)
+
     # Rebuild message list
     result = []
     if system:
         result.append(system)
     result.extend(compacted_old)
-    result.extend(recent_messages)
-
+    result.extend(cleaned_recent)
     return result

{alpiecode-10.5.0 → alpiecode-10.5.1}/src/codeagent/config.py

@@ -158,8 +158,8 @@ def load_config() -> Config:
     # For offline mode, set high-performance 16k context (16384 tokens) for big multi-file projects
     # Fits completely in 6GB VRAM on RTX 3050 with zero paging
     if data.get("base_url") == "offline" and not any(os.environ.get(v) for v in ("ALPIECODE_N_CTX", "ALPIECODE_CTX_SIZE")):
-        if data.get("n_ctx") in (32768, 4096):
-            data["n_ctx"] = 16384
+        if data.get("n_ctx") in (32768, 4096, 16384):
+            data["n_ctx"] = 8192
         if data.get("max_tokens", 8192) > 4096:
             data["max_tokens"] = 4096
 

{alpiecode-10.5.0 → alpiecode-10.5.1}/src/codeagent/context.py

@@ -14,6 +14,8 @@ from typing import Any, Dict, List, Optional
 
 from .backends.base import ChatResponse, ToolCall
 from .compaction import (
+    compact_tool_calls,
+    compact_text_tool_calls,
     CHARS_PER_TOKEN,
     compact_messages,
     estimate_tokens,
@@ -350,25 +352,42 @@ class ContextManager:
                         context_blocks.append(dict(m))
                         break
 
+        # ── Budget Verification & Headroom Limits ──
+        effective_limit = max_tokens or self.max_tokens
+
         # ── Layer 4 & 5: Recent Messages and Current Request ──
-        if len(recent_messages) > 6:
-            for i in range(len(recent_messages) - 4):
-                m = recent_messages[i]
-                if m.get("role") == "tool":
-                    c = str(m.get("content") or "")
-                    if len(c) > 400 and "[Plan updated]" not in c and "Plan Status:" not in c:
-                        lines = c.splitlines()
-                        if len(lines) > 8:
-                            m["content"] = f"[Output: {len(lines)} lines truncated]\n" + "\n".join(lines[:3]) + "\n...\n" + "\n".join(lines[-2:])
-                        else:
-                            m["content"] = c[:200] + "... [truncated]"
+        # Condense bulky file write payloads in older assistant messages
+        last_asst_idx = -1
+        for i in range(len(recent_messages) - 1, -1, -1):
+            if recent_messages[i].get("role") == "assistant":
+                last_asst_idx = i
+                break
+
+        for i, m in enumerate(recent_messages):
+            if i != last_asst_idx and m.get("role") == "assistant":
+                if m.get("tool_calls"):
+                    m["tool_calls"] = compact_tool_calls(m["tool_calls"])
+                if m.get("content"):
+                    m["content"] = compact_text_tool_calls(m["content"])
+            elif m.get("role") == "tool":
+                c = str(m.get("content") or "")
+                if len(c) > 300 and "[Plan updated]" not in c and "Plan Status:" not in c:
+                    lines = c.splitlines()
+                    if len(lines) > 8:
+                        top = "\n".join(lines[:3])
+                        bot = "\n".join(lines[-2:])
+                        m["content"] = f"[Output: {len(lines)} lines condensed]\n{top}\n...\n{bot}"
+                    else:
+                        m["content"] = c[:180] + "... [condensed]"
 
         context_blocks.extend(recent_messages)
 
         # ── Budget Verification ──
-        effective_limit = max_tokens or self.max_tokens
-        if estimate_tokens(context_blocks) > effective_limit:
-            context_blocks = compact_messages(context_blocks)
+        reserved_headroom = 2048 if effective_limit <= 8192 else 4096
+        prompt_budget = max(1024, effective_limit - reserved_headroom)
+
+        if estimate_tokens(context_blocks) > prompt_budget:
+            context_blocks = compact_messages(context_blocks, keep_recent=4 if effective_limit <= 8192 else 8)
 
         if is_default_params:
             self._cached_context = [dict(m) for m in context_blocks]
@@ -403,6 +422,16 @@ class ContextManager:
         """Returns parallel metadata list for all messages."""
         return list(self._metadata)
 
+    def compact_for_headroom(self, target_headroom: int = 1536, n_ctx: int = 8192, tools_overhead: int = 800) -> int:
+        """
+        Actively compact context to ensure at least target_headroom tokens are available for generation.
+        Returns the new estimated token count.
+        """
+        self.invalidate_cache(reset_summary=True)
+        self._cached_summary = extract_conversation_summary(self._messages, self._metadata)
+        self._messages = compact_messages(self._messages, keep_recent=4)
+        return self.estimate_tokens()
+
     def estimate_tokens(self) -> int:
         """Estimate tokens of the active built context."""
         return estimate_tokens(self.build_context())

{alpiecode-10.5.0 → alpiecode-10.5.1}/src/codeagent/dream_rsi.py

@@ -328,8 +328,9 @@ class DreamOptimizer:
         best_stats = {}
 
         # Exploration Policy Search Grid (Dream Simulation Space)
-        syntax_thresholds = [1, 2]
-        general_thresholds = [1, 2, 3]
+        # Minimum threshold = 2 to prevent false positive loop detection on first call
+        syntax_thresholds = [2, 3]
+        general_thresholds = [2, 3, 4]
         stall_thresholds = [2, 3, 4]
         single_file_options = [True, False]
         nudge_options = [True, False]

{alpiecode-10.5.0 → alpiecode-10.5.1}/src/codeagent/executor.py

@@ -51,11 +51,13 @@ def parse_text_tool_calls(text: str) -> List[dict]:
             if isinstance(data, dict) and "name" in data:
                 args = data.get("arguments")
                 if not isinstance(args, dict) or not args:
-                    fallback_args = {k: v for k, v in data.items() if k not in ("name", "id", "type", "_raw_arguments", "_parse_error")}
+                    fallback_args = {k: v for k, v in data.items() if k not in ("name", "id", "type", "_raw_arguments", "_parse_error", "_was_truncated")}
                     if fallback_args:
                         args = fallback_args
                     elif not isinstance(args, dict):
                         args = {}
+                if data.get("_was_truncated"):
+                    args["_was_truncated"] = True
                 tool_calls.append({
                     "name": data["name"],
                     "arguments": args
@@ -148,11 +150,13 @@ def _parse_error_hint(stderr: str, stdout: str) -> str:
         )
     elif "command not found" in combined:
         cmd_match = combined.split("command not found")[0].strip().split()
-        cmd = cmd_match[-1] if cmd_match else "unknown"
-        hints.append(
-            f"Hint: Command '{cmd}' not found. It may not be installed or not in PATH. "
-            "Check available commands or install the required package."
-        )
+        cmd = cmd_match[-1].rstrip(":") if cmd_match else "unknown"
+        hint = f"Hint: Command '{cmd}' not found. It may not be installed or not in PATH."
+        if cmd in ("node", "npm", "npx"):
+            hint += " For client-side web projects (HTML/CSS/JS), files do not require node to run. Output DONE: <summary> when complete."
+        else:
+            hint += " Check available commands or install the required package."
+        hints.append(hint)
 
     return "\n".join(hints)
 

{alpiecode-10.5.0 → alpiecode-10.5.1}/src/codeagent/local_model.py

@@ -463,17 +463,34 @@ class LocalModel:
             msgs = messages
 
         # Context headroom safety guard: dynamically clamp max_tokens so prompt + max_tokens <= n_ctx
-        n_ctx_limit = getattr(self, "n_ctx", 4096)
+        n_ctx_limit = getattr(self, "n_ctx", 8192)
         try:
-            total_chars = sum(len(str(m.get("content", ""))) for m in msgs)
+            total_chars = 0
+            for m in msgs:
+                total_chars += len(str(m.get("content") or ""))
+                for tc in m.get("tool_calls") or []:
+                    if isinstance(tc, dict):
+                        fn = tc.get("function", {})
+                        total_chars += len(str(fn.get("arguments", ""))) + len(str(fn.get("name", "")))
             if tools:
                 import json
                 total_chars += len(json.dumps(tools))
-            # Conservative token estimate: 1 token ≈ 3.0 chars + tool/template overhead
-            est_prompt_tokens = int(total_chars / 3.0) + 160
-            available_tokens = n_ctx_limit - est_prompt_tokens - 48
-            if max_tokens > available_tokens:
-                max_tokens = max(64, available_tokens)
+            # Accurate token estimate: 1 token ≈ 3.2 chars + template overhead
+            est_prompt_tokens = int(total_chars / 3.2) + 120
+            available_tokens = n_ctx_limit - est_prompt_tokens - 32
+            if available_tokens < 1024 and len(msgs) > 2:
+                from .compaction import compact_messages
+                msgs = compact_messages(msgs, keep_recent=2)
+                total_chars = sum(len(str(m.get("content") or "")) for m in msgs)
+                if tools:
+                    import json
+                    total_chars += len(json.dumps(tools))
+                est_prompt_tokens = int(total_chars / 3.2) + 120
+                available_tokens = n_ctx_limit - est_prompt_tokens - 32
+
+            safe_cap = max(256, available_tokens)
+            if max_tokens > safe_cap:
+                max_tokens = safe_cap
         except Exception:
             pass
 
@@ -506,7 +523,13 @@ class LocalModel:
                             requested = int(m.group(1))
                             win = int(m.group(2))
                             excess = requested - win
-                            if cur_max - excess - 32 >= 64:
+                            if excess > 0 and len(params.get("messages", [])) > 2:
+                                from .compaction import compact_messages
+                                params["messages"] = compact_messages(params["messages"], keep_recent=2)
+                                cur_max = min(2048, max(256, win - int(requested - excess) // 2))
+                                params["max_tokens"] = cur_max
+                                continue
+                            elif cur_max - excess - 32 >= 64:
                                 cur_max = max(64, cur_max - excess - 32)
                                 continue
                     raise
@@ -526,8 +549,13 @@ class LocalModel:
                     requested = int(m.group(1))
                     win = int(m.group(2))
                     excess = requested - win
-                    new_max = max(64, params["max_tokens"] - excess - 32)
-                    params["max_tokens"] = new_max
+                    if excess > 0 and len(params.get("messages", [])) > 2:
+                        from .compaction import compact_messages
+                        params["messages"] = compact_messages(params["messages"], keep_recent=2)
+                        params["max_tokens"] = min(2048, max(512, win - int(requested - excess) // 2))
+                    else:
+                        new_max = max(128, params["max_tokens"] - excess - 32)
+                        params["max_tokens"] = new_max
                     result_dict = llm.create_chat_completion(**params)
                 else:
                     raise