alpiecode 9.0.4__tar.gz → 9.0.6__tar.gz

{alpiecode-9.0.4 → alpiecode-9.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 9.0.4
+Version: 9.0.6
 Summary: AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-9.0.4 → alpiecode-9.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "9.0.4"
+version = "9.0.6"
 description = "AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM"
 requires-python = ">=3.9"
 dependencies = [

{alpiecode-9.0.4 → alpiecode-9.0.6}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 9.0.4
+Version: 9.0.6
 Summary: AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-9.0.4 → alpiecode-9.0.6}/src/alpiecode.egg-info/SOURCES.txt

@@ -40,7 +40,10 @@ src/codeagent/backends/base.py
 src/codeagent/backends/local_backend.py
 src/codeagent/backends/openai_backend.py
 src/codeagent/extension/alpiecode.vsix
+test/test_audit_fixes.py
+test/test_chat_mode.py
 test/test_claude_codex_capabilities.py
+test/test_offline_mode.py
 test/test_phase1.py
 test/test_phase2.py
 test/test_phase3.py

{alpiecode-9.0.4 → alpiecode-9.0.6}/src/codeagent/__init__.py

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

{alpiecode-9.0.4 → alpiecode-9.0.6}/src/codeagent/agent.py

@@ -213,11 +213,15 @@ def run_agent(
     # CLI-as-Client check: auto-detect if local/remote server is running
     from .client import AlpieCodeClient
     target_server = server_url or getattr(cfg, "server_url", None)
-    if not target_server:
-        # Check default local server
-        local_client = AlpieCodeClient("http://127.0.0.1:7169")
-        if local_client.health().get("status") == "online":
-            target_server = "http://127.0.0.1:7169"
+    if not target_server and cfg.base_url != "offline" and not getattr(cfg, "offline", False):
+        # Check default local server (online mode only)
+        try:
+            local_client = AlpieCodeClient("http://127.0.0.1:7169")
+            h = local_client.health()
+            if h.get("status") == "online" and h.get("mode") != "offline":
+                target_server = "http://127.0.0.1:7169"
+        except Exception:
+            pass
 
     if target_server:
         client = AlpieCodeClient(target_server)
@@ -234,7 +238,7 @@ def run_agent(
         backend = resolve_backend(cfg)
         orchestrator = AgentOrchestrator(backend)
         session_mgr = SessionManager()
-        session = session_mgr.create_session(workdir, max_tokens=cfg.n_ctx if not backend.is_available else 262_144)
+        session = session_mgr.create_session(workdir, max_tokens=backend.context_window if hasattr(backend, 'context_window') and backend.context_window else (cfg.n_ctx if cfg.base_url == 'offline' else 262_144))
         event_stream = orchestrator.run_task(
             session=session,
             task=task,
@@ -467,7 +471,7 @@ def run_agent(
     return session.context.messages if "session" in locals() else []
 
 
-def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
+def run_chat(workdir: Path, cfg: Config, verbose: bool = True, debug: bool = False) -> None:
     """Run interactive chat session with Rich presentation."""
     workdir = workdir.resolve()
     _ensure_git(workdir)
@@ -475,7 +479,7 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
     backend = resolve_backend(cfg)
     orchestrator = AgentOrchestrator(backend)
     session_mgr = SessionManager()
-    session = session_mgr.create_session(workdir, max_tokens=cfg.n_ctx if not backend.is_available else 262_144)
+    session = session_mgr.create_session(workdir, max_tokens=backend.context_window if hasattr(backend, 'context_window') and backend.context_window else (cfg.n_ctx if cfg.base_url == 'offline' else 262_144))
 
     is_offline = isinstance(backend, LocalBackend) or not backend.is_available
     active_tools = PromptBuilder().get_tools(is_offline=is_offline)
@@ -513,7 +517,50 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
             console.print("Goodbye! 👋")
             break
 
+        # In-chat slash commands
+        if user_input.lower() in ("/clear", "/reset"):
+            session = session_mgr.create_session(
+                workdir,
+                max_tokens=backend.context_window if hasattr(backend, 'context_window') and backend.context_window else (cfg.n_ctx if cfg.base_url == 'offline' else 262_144)
+            )
+            if HAS_RICH:
+                console.print("[bold green]✨ Conversation context reset.[/bold green]")
+            else:
+                print("✨ Conversation context reset.")
+            continue
+
+        if user_input.lower() in ("/info", "/status"):
+            mode_str = "OFFLINE (Local GGUF)" if is_offline else "ONLINE (Cloud API)"
+            ctx_tokens = backend.context_window if hasattr(backend, 'context_window') and backend.context_window else cfg.n_ctx
+            user_turns = len([m for m in session.context.messages if m.get("role") == "user"])
+            info_msg = (
+                f"[bold]AlpieCode Session Info[/bold]\n"
+                f" • Mode: {mode_str}\n"
+                f" • Working Dir: {workdir}\n"
+                f" • Context Window: {ctx_tokens} tokens\n"
+                f" • Session Turns: {user_turns}"
+            )
+            if HAS_RICH:
+                console.print(Panel(info_msg, border_style="cyan", title="ℹ️ Status"))
+            else:
+                print(info_msg)
+            continue
+
+        if user_input.lower() in ("/help", "/?"):
+            help_msg = (
+                "Available commands:\n"
+                " • /clear, /reset  - Reset conversation memory\n"
+                " • /info, /status  - View current model and session diagnostics\n"
+                " • exit, quit, q   - Exit interactive chat"
+            )
+            if HAS_RICH:
+                console.print(Panel(help_msg, border_style="dim", title="Help"))
+            else:
+                print(help_msg)
+            continue
+
         has_streamed_chat = False
+        has_printed_chat = False
         for event in orchestrator.run_task(session, user_input, cfg):
             if event.type == "token":
                 delta = event.data.get("delta", "")
@@ -521,6 +568,7 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
                     sys.stdout.write(delta)
                     sys.stdout.flush()
                     has_streamed_chat = True
+                    has_printed_chat = True
 
             elif event.type == "turn_start" and debug:
                 if HAS_RICH:
@@ -532,7 +580,12 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
                 _print_reasoning(event.data["content"])
 
             elif event.type == "tool_call" and verbose:
+                if has_streamed_chat:
+                    sys.stdout.write("\n")
+                    sys.stdout.flush()
+                    has_streamed_chat = False
                 _print_tool_call(event.data["turn"], event.data["name"], event.data["arguments"])
+                has_printed_chat = True
 
             elif event.type == "tool_result":
                 if verbose:
@@ -543,8 +596,9 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
                 if has_streamed_chat:
                     sys.stdout.write("\n")
                     has_streamed_chat = False
-                else:
+                elif not has_printed_chat:
                     _print_assistant_message(event.data["content"])
+                has_printed_chat = True
                 _checkpoint(workdir, "checkpoint: done")
 
             elif event.type == "error":
@@ -557,6 +611,7 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
                 if has_streamed_chat:
                     sys.stdout.write("\n")
                     has_streamed_chat = False
-                elif event.data.get("summary"):
+                elif not has_printed_chat and event.data.get("summary"):
                     _print_assistant_message(event.data["summary"])
+                    has_printed_chat = True
                 break

{alpiecode-9.0.4 → alpiecode-9.0.6}/src/codeagent/backends/local_backend.py

@@ -55,8 +55,25 @@ class LocalBackend:
         sanitized = []
         for msg in messages:
             role = msg.get("role", "")
-            # Skip tool result messages entirely — GGUF models don't understand them
             if role == "tool":
+                # Bridge tool execution results into ChatML user turns so local model sees outputs
+                name = msg.get("name") or "tool"
+                raw_content = msg.get("content") or ""
+                if not isinstance(raw_content, str):
+                    raw_content = str(raw_content)
+                # Smart truncate oversized terminal logs to conserve context
+                if len(raw_content) > 1500:
+                    lines = raw_content.splitlines()
+                    if len(lines) > 12:
+                        raw_content = f"[Output: {len(lines)} lines]\n" + "\n".join(lines[:6]) + "\n...\n" + "\n".join(lines[-4:])
+                    else:
+                        raw_content = raw_content[:1500] + "\n... [truncated]"
+
+                tool_text = f"[Tool Result for {name}]:\n{raw_content}"
+                if sanitized and sanitized[-1].get("role") == "user":
+                    sanitized[-1]["content"] += "\n\n" + tool_text
+                else:
+                    sanitized.append({"role": "user", "content": tool_text})
                 continue
 
             clean = {"role": role}

{alpiecode-9.0.4 → alpiecode-9.0.6}/src/codeagent/cli.py

@@ -41,6 +41,10 @@ def _normalize_args():
     if not subcommand and len(sys.argv) > 1:
         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)
+        sys.argv.insert(1, subcommand)
 
     if subcommand in ("run", "plan", "explain") and len(sys.argv) > 2:
         cmd_idx = sys.argv.index(subcommand)
@@ -82,6 +86,7 @@ def main():
     common.add_argument("--no-update", action="store_true", help="Skip automatic update check")
     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")
 
     from . import __version__
     parser = argparse.ArgumentParser(
@@ -145,13 +150,16 @@ def main():
 
     if args.command == "serve":
         _show_banner()
+        if getattr(args, "offline", False):
+            import os
+            os.environ["ALPIECODE_BASE_URL"] = "offline"
         try:
             from .vscode_installer import ensure_vscode_extension
             ensure_vscode_extension()
         except Exception as e:
             pass
         from .server import run_server
-        run_server(host=args.host, port=args.port)
+        run_server(host=args.host, port=args.port, offline=getattr(args, "offline", False))
         return
 
     # Check for auto-updates from GitHub in background
@@ -164,6 +172,12 @@ def main():
 
     cfg = load_config()
 
+    if getattr(args, "offline", False):
+        cfg.base_url = "offline"
+        cfg.n_ctx = 16384
+        import os
+        os.environ["ALPIECODE_BASE_URL"] = "offline"
+
     if getattr(args, "thinking", False):
         cfg.enable_thinking = True
     elif getattr(args, "no_thinking", False):
@@ -188,7 +202,7 @@ def main():
             cfg.max_turns = args.max_turns
         _show_banner()
         from .agent import run_chat
-        run_chat(Path(args.workdir), cfg, verbose=not args.quiet)
+        run_chat(Path(args.workdir), cfg, verbose=not args.quiet, debug=getattr(args, 'debug', False))
 
     elif args.command == "plan":
         plan_task = (

{alpiecode-9.0.4 → alpiecode-9.0.6}/src/codeagent/client.py

@@ -11,7 +11,7 @@ import urllib.parse
 import urllib.request
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, Iterator, Optional
+from typing import Any, Dict, Iterator, List, Optional
 
 from .orchestrator import AgentEvent
 

{alpiecode-9.0.4 → alpiecode-9.0.6}/src/codeagent/config.py

@@ -151,11 +151,13 @@ def load_config() -> Config:
         except ValueError:
             pass
 
-    # For offline mode, optimize default context size to 4096 to prevent VRAM/RAM bottleneck
-    # unless explicitly configured by the user
+    # 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") == 32768:
-            data["n_ctx"] = 4096
+        if data.get("n_ctx") in (32768, 4096):
+            data["n_ctx"] = 16384
+        if data.get("max_tokens", 8192) > 4096:
+            data["max_tokens"] = 4096
 
     # Filter data to only keys present in Config fields
     valid_keys = {f.name for f in fields(Config)}

{alpiecode-9.0.4 → alpiecode-9.0.6}/src/codeagent/discovery.py

@@ -559,6 +559,7 @@ def gather_relevant_context(
     if getattr(task_context, "intent", "") in ("qa",):
         return None
 
+    task_lower = task.lower().strip()
     sections: List[str] = []
     chars_used = 0
 

{alpiecode-9.0.4 → alpiecode-9.0.6}/src/codeagent/executor.py

@@ -194,6 +194,7 @@ class ToolExecutor:
         self.dispatch = make_dispatch(workdir)
         self.tool_call_history: List[Tuple[str, str]] = []
         self.compile_fail_counts: Dict[str, int] = {}
+        self.successful_bash_commands: set = set()
 
     def extract_tool_calls(self, response: ChatResponse) -> List[ToolCall]:
         """Extract tool calls from response (structured or text format)."""
@@ -342,6 +343,10 @@ class ToolExecutor:
                     res_str = f"error: Unknown tool '{tc.name}'"
                 elapsed = (time.monotonic() - t0) * 1000
 
+                # Clear passed verification set whenever code files are written or edited
+                if tc.name in ("write_file", "edit_file", "apply_patch"):
+                    self.successful_bash_commands.clear()
+
                 # Tool loop detection guard
                 call_sig = (tc.name, json.dumps(tc.arguments, sort_keys=True))
                 self.tool_call_history.append(call_sig)
@@ -354,6 +359,19 @@ class ToolExecutor:
                         "All checks have passed. Do NOT run this tool again. Output your final summary starting with: DONE: <summary>."
                     )
 
+                # Repetitive verification sequence guard
+                if tc.name == "bash":
+                    cmd_str = safe_args.get("command", "").strip()
+                    if cmd_str and cmd_str in self.successful_bash_commands:
+                        res_str += (
+                            "\n\n⚠️ REPETITIVE VERIFICATION NOTICE: This exact command has already run and passed with exit code 0, "
+                            "and no files have been modified since. Re-running identical tests is unnecessary. "
+                            "All checks have already passed! Finalize the task now with: DONE: <summary>."
+                        )
+                    elif '"exit_code": 0' in res_str:
+                        if cmd_str:
+                            self.successful_bash_commands.add(cmd_str)
+
                 # Smart error hint injection for failed bash commands
                 if tc.name == "bash" and '"exit_code"' in res_str:
                     try:

{alpiecode-9.0.4 → alpiecode-9.0.6}/src/codeagent/local_model.py

@@ -414,6 +414,17 @@ class LocalModel:
         else:
             msgs = messages
 
+        # Context headroom safety guard: dynamically clamp max_tokens if prompt is large
+        n_ctx_limit = getattr(self, "n_ctx", 16384)
+        try:
+            total_chars = sum(len(str(m.get("content", ""))) for m in msgs)
+            est_prompt_tokens = int(total_chars / 3.0) + (len(tools or []) * 80) + 100
+            if est_prompt_tokens + max_tokens > n_ctx_limit:
+                available_tokens = max(128, n_ctx_limit - est_prompt_tokens - 32)
+                max_tokens = min(max_tokens, available_tokens)
+        except Exception:
+            pass
+
         params = {
             "messages": msgs,
             "temperature": 0.1 if not enable_thinking else temperature,
@@ -423,7 +434,24 @@ class LocalModel:
             params["tools"] = tools
             params["tool_choice"] = kwargs.get("tool_choice", "auto")
 
-        result_dict = llm.create_chat_completion(**params)
+        try:
+            result_dict = llm.create_chat_completion(**params)
+        except ValueError as ve:
+            err_msg = str(ve)
+            if "exceed context window" in err_msg.lower():
+                # Parse: "Requested tokens (X) exceed context window of Y"
+                m = re.search(r"Requested tokens \((\d+)\) exceed context window of (\d+)", err_msg)
+                if m:
+                    requested = int(m.group(1))
+                    win = int(m.group(2))
+                    excess = requested - win
+                    new_max = max(128, params["max_tokens"] - excess - 32)
+                    params["max_tokens"] = new_max
+                    result_dict = llm.create_chat_completion(**params)
+                else:
+                    raise
+            else:
+                raise
 
         # Fix prefill response content so chat history remains valid across multi-turn sessions
         if not enable_thinking and result_dict.get("choices"):

{alpiecode-9.0.4 → alpiecode-9.0.6}/src/codeagent/orchestrator.py

@@ -39,6 +39,7 @@ Owns the turn loop, backend resolution, caching, and event stream.
 """
 
 import copy
+import re
 from dataclasses import dataclass, field
 from typing import Any, Dict, Iterator, List, Optional
 

{alpiecode-9.0.4 → alpiecode-9.0.6}/src/codeagent/server.py

@@ -77,9 +77,12 @@ if HAS_FASTAPI:
         except Exception:
             cache_stats = {}
 
+        is_offline = "LocalBackend" in backend_name or getattr(getattr(app.state, "cfg", None), "base_url", "") == "offline"
         return {
             "status": "online",
+            "mode": "offline" if is_offline else "online",
             "backend": backend_name,
+            "model": getattr(getattr(app.state, "cfg", None), "model", "alpie_9b"),
             "available": is_avail,
             "uptime_seconds": round(uptime, 2),
             "version": "0.9.2",
@@ -283,7 +286,10 @@ else:
     app = None
 
 
-def run_server(host: str = "127.0.0.1", port: int = 7169) -> None:
+def run_server(host: str = "127.0.0.1", port: int = 7169, offline: bool = False) -> None:
+    if offline:
+        import os
+        os.environ["ALPIECODE_BASE_URL"] = "offline"
     """Start the uvicorn ASGI server."""
     if not HAS_FASTAPI:
         print("❌ FastAPI/Uvicorn is not installed. Install with: pip install 'alpiecode[server]' or pip install fastapi uvicorn")

{alpiecode-9.0.4 → alpiecode-9.0.6}/src/codeagent/updater.py

@@ -110,6 +110,14 @@ def auto_update(quiet: bool = False) -> bool:
     if os.environ.get("ALPIECODE_NO_UPDATE") == "1":
         return False
 
+    # Do not auto-update if running from a local development checkout
+    try:
+        dev_root = Path(__file__).resolve().parents[2]
+        if (dev_root / "pyproject.toml").exists() and (dev_root / ".git").exists():
+            return False
+    except Exception:
+        pass
+
     # Show notice if last run installed an update
     if not quiet:
         _check_pending_update_notice()

alpiecode-9.0.6/test/test_audit_fixes.py

@@ -0,0 +1,71 @@
+"""
+Tests for audit fixes:
+1. orchestrator regex splitting on DONE:
+2. discovery task_lower scoping
+3. client.py List import
+4. CLI --offline flag argument parsing
+"""
+
+import argparse
+from pathlib import Path
+
+from codeagent.client import AlpieCodeClient
+from codeagent.discovery import TaskContext, gather_relevant_context
+from codeagent import orchestrator
+
+
+def test_orchestrator_re_import():
+    """Verify that re is imported in orchestrator module and DONE: regex splitting works."""
+    assert hasattr(orchestrator, "re"), "orchestrator module must have 're' imported"
+    content = "The work is completed.\n\nDONE: All tests passed successfully."
+    parts = orchestrator.re.split(r"(?i)\bDONE:\s*", content)
+    assert len(parts) == 2
+    assert "All tests passed" in parts[1]
+
+
+def test_discovery_task_lower_scoping(tmp_path):
+    """Verify gather_relevant_context works with symbol_index without UnboundLocalError."""
+    # Create sample file
+    code_file = tmp_path / "math_utils.py"
+    code_file.write_text("def is_palindrome(s): return s == s[::-1]\n", encoding="utf-8")
+
+    task_context = TaskContext(
+        intent="modify",
+        project_type="python",
+        file_count=1,
+        entry_points=["math_utils.py"],
+        symbol_index={"math_utils.py": ["is_palindrome"]},
+    )
+
+    # Calling gather_relevant_context with a task matching symbols
+    res = gather_relevant_context(
+        task="check the palindrome logic in math_utils.py",
+        workdir=tmp_path,
+        task_context=task_context,
+        max_chars=4000,
+    )
+    assert res is not None
+    assert "math_utils.py" in res
+
+
+def test_client_typing_imports():
+    """Verify client module imports List and AlpieCodeClient instantiates."""
+    from codeagent import client
+    assert hasattr(client, "List"), "client module should import List from typing"
+    c = AlpieCodeClient("http://127.0.0.1:7169")
+    assert c.base_url == "http://127.0.0.1:7169"
+
+
+def test_cli_offline_flag_parsing():
+    """Verify --offline flag is recognized in CLI parser."""
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--offline", "--local", dest="offline", action="store_true")
+    
+    args = common.parse_args(["--offline"])
+    assert args.offline is True
+
+    args_local = common.parse_args(["--local"])
+    assert args_local.offline is True
+
+    args_default = common.parse_args([])
+    assert args_default.offline is False

alpiecode-9.0.6/test/test_chat_mode.py

@@ -0,0 +1,85 @@
+"""
+Tests for interactive chat mode:
+1. run_chat signature accepts debug flag
+2. event loop handles turn_start when debug is True or False
+3. in-chat slash commands (/info, /clear, /help) execute cleanly
+"""
+
+from unittest.mock import MagicMock, patch
+from pathlib import Path
+
+from codeagent.agent import run_chat
+from codeagent.config import Config
+from codeagent.orchestrator import AgentEvent
+
+
+def test_run_chat_debug_true(tmp_path):
+    """Verify run_chat signature accepts debug=True and exits cleanly."""
+    cfg = Config(base_url="offline")
+    with patch("builtins.input", side_effect=["exit"]):
+        run_chat(tmp_path, cfg, verbose=False, debug=True)
+
+
+def test_run_chat_debug_false(tmp_path):
+    """Verify run_chat signature accepts debug=False and exits cleanly."""
+    cfg = Config(base_url="offline")
+    with patch("builtins.input", side_effect=["exit"]):
+        run_chat(tmp_path, cfg, verbose=False, debug=False)
+
+
+def test_run_chat_in_chat_commands(tmp_path):
+    """Verify run_chat handles /info, /help, /clear commands before exiting."""
+    cfg = Config(base_url="offline")
+    commands = ["/info", "/help", "/clear", "exit"]
+    with patch("builtins.input", side_effect=commands):
+        run_chat(tmp_path, cfg, verbose=False, debug=False)
+
+
+def test_chat_event_loop_turn_start_with_debug(tmp_path):
+    """Verify that turn_start event does not raise NameError when debug is enabled."""
+    cfg = Config(base_url="offline")
+
+    mock_events = [
+        AgentEvent("turn_start", {"turn": 1}),
+        AgentEvent("token", {"delta": "Mock output"}),
+        AgentEvent("done", {"summary": "Done"}),
+    ]
+
+    with patch("builtins.input", side_effect=["what is gravity?", "exit"]):
+        with patch("codeagent.agent.AgentOrchestrator.run_task", return_value=iter(mock_events)):
+            run_chat(tmp_path, cfg, verbose=False, debug=True)
+
+
+def test_chat_event_loop_turn_start_without_debug(tmp_path):
+    """Verify that turn_start event does not raise NameError when debug is disabled."""
+    cfg = Config(base_url="offline")
+
+    mock_events = [
+        AgentEvent("turn_start", {"turn": 1}),
+        AgentEvent("token", {"delta": "Mock output"}),
+        AgentEvent("done", {"summary": "Done"}),
+    ]
+
+    with patch("builtins.input", side_effect=["what is gravity?", "exit"]):
+        with patch("codeagent.agent.AgentOrchestrator.run_task", return_value=iter(mock_events)):
+            run_chat(tmp_path, cfg, verbose=False, debug=False)
+
+
+def test_chat_no_duplicate_response(tmp_path, capsys):
+    """Verify that streamed tokens + done summary are not printed twice."""
+    cfg = Config(base_url="offline")
+
+    unique_phrase = "Einstein spacetime curvature 1915"
+    mock_events = [
+        AgentEvent("turn_start", {"turn": 1}),
+        AgentEvent("token", {"delta": unique_phrase}),
+        AgentEvent("message", {"content": unique_phrase}),
+        AgentEvent("done", {"summary": unique_phrase}),
+    ]
+
+    with patch("builtins.input", side_effect=["what is GR?", "exit"]):
+        with patch("codeagent.agent.AgentOrchestrator.run_task", return_value=iter(mock_events)):
+            run_chat(tmp_path, cfg, verbose=True, debug=False)
+
+    captured = capsys.readouterr().out
+    assert captured.count(unique_phrase) == 1, f"Expected 1 occurrence of response, got {captured.count(unique_phrase)}"

alpiecode-9.0.6/test/test_offline_mode.py

@@ -0,0 +1,78 @@
+import os
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from codeagent.config import load_config
+from codeagent.backends.local_backend import LocalBackend
+from codeagent.session import SessionManager
+from codeagent.context import ContextManager
+
+
+def test_offline_config_defaults():
+    os.environ["ALPIECODE_BASE_URL"] = "offline"
+    try:
+        cfg = load_config()
+        assert cfg.base_url == "offline"
+        assert cfg.n_ctx == 16384
+        assert cfg.max_tokens <= 4096
+    finally:
+        os.environ.pop("ALPIECODE_BASE_URL", None)
+
+
+def test_local_backend_tool_result_sanitization():
+    messages = [
+        {"role": "system", "content": "You are a helpful coding assistant."},
+        {"role": "user", "content": "Write a test file."},
+        {
+            "role": "assistant",
+            "content": "Writing file now.",
+            "tool_calls": [
+                {
+                    "id": "call_1",
+                    "function": {"name": "write_file", "arguments": '{"path": "test.py"}'},
+                }
+            ],
+        },
+        {
+            "role": "tool",
+            "name": "write_file",
+            "tool_call_id": "call_1",
+            "content": "wrote 150 bytes to test.py",
+        },
+        {
+            "role": "tool",
+            "name": "bash",
+            "tool_call_id": "call_2",
+            "content": "pytest passed (1 passed in 0.05s)",
+        },
+    ]
+
+    sanitized = LocalBackend._sanitize_messages_for_gguf(messages)
+    # Ensure role 'tool' was NOT dropped
+    assert not any(m.get("role") == "tool" for m in sanitized)
+
+    # Tool results should be converted into user turns
+    user_turns = [m for m in sanitized if m.get("role") == "user"]
+    # Consecutive tool results are coalesced into a single user turn
+    assert any("[Tool Result for write_file]" in m["content"] for m in user_turns)
+    assert any("[Tool Result for bash]" in m["content"] for m in user_turns)
+
+
+def test_agent_session_max_tokens_uses_backend_context_window():
+    cfg_mock = MagicMock()
+    cfg_mock.n_ctx = 16384
+    cfg_mock.base_url = "offline"
+
+    backend = LocalBackend(cfg_mock)
+    assert backend.context_window == 16384
+
+    effective_ctx = (
+        backend.context_window
+        if hasattr(backend, "context_window") and backend.context_window
+        else (cfg_mock.n_ctx if cfg_mock.base_url == "offline" else 262_144)
+    )
+    assert effective_ctx == 16384
+
+    session_mgr = SessionManager()
+    session = session_mgr.create_session(Path.cwd(), max_tokens=effective_ctx)
+    assert session.context.max_tokens == 16384