alpiecode 10.6.7__tar.gz → 10.7.0__tar.gz

{alpiecode-10.6.7 → alpiecode-10.7.0}/PKG-INFO

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

{alpiecode-10.6.7 → alpiecode-10.7.0}/pyproject.toml

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

{alpiecode-10.6.7 → alpiecode-10.7.0}/src/alpiecode.egg-info/PKG-INFO

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

{alpiecode-10.6.7 → alpiecode-10.7.0}/src/codeagent/__init__.py

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

{alpiecode-10.6.7 → alpiecode-10.7.0}/src/codeagent/agent.py

@@ -734,7 +734,12 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True, debug: bool = Fal
     session_mgr = SessionManager()
     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
+    is_offline = (
+        getattr(backend, "is_offline", False) is True
+        or isinstance(backend, LocalBackend)
+        or not backend.is_available
+        or any(h in str(getattr(cfg, "base_url", "")).lower() for h in ("127.0.0.1", "localhost", "0.0.0.0", "offline"))
+    )
     active_tools = PromptBuilder().get_tools(is_offline=is_offline)
 
     if HAS_RICH:

{alpiecode-10.6.7 → alpiecode-10.7.0}/src/codeagent/backends/local_backend.py

@@ -39,6 +39,10 @@ class LocalBackend:
     def is_available(self) -> bool:
         return True
 
+    @property
+    def is_offline(self) -> bool:
+        return True
+
 
     @property
     def context_window(self) -> int:
@@ -401,6 +405,166 @@ class LocalBackend:
         )
         yield ("done", chat_resp)
 
+    def _get_bridge_url(self) -> str:
+        return os.environ.get("LOCAL_LLAMA_BRIDGE", "http://127.0.0.1:8080").rstrip("/")
+
+    def _is_bridge_online(self) -> bool:
+        try:
+            import httpx
+            r = httpx.get(f"{self._get_bridge_url()}/v1/models", timeout=0.3)
+            return r.status_code == 200
+        except Exception:
+            return False
+
+    def _bridge_chat_completion(
+        self,
+        messages: List[dict],
+        tools: Optional[List[dict]] = None,
+        temperature: float = 0.2,
+        max_tokens: int = 2048,
+        enable_thinking: bool = True,
+    ) -> ChatResponse:
+        import httpx
+        import json
+        bridge_url = self._get_bridge_url()
+        sanitized = self._sanitize_messages_for_gguf(messages)
+        if not enable_thinking and sanitized and sanitized[-1].get("role") == "user":
+            u_text = str(sanitized[-1].get("content", ""))
+            if "[Direct Mode:" not in u_text:
+                sanitized[-1]["content"] = u_text + "\n\n[Direct Mode: Output code and tool calls directly without <think> tags. Do not deliberate.]"
+        payload = {
+            "model": "local",
+            "messages": sanitized,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "stream": False,
+        }
+        if tools:
+            payload["tools"] = tools
+            payload["tool_choice"] = "auto"
+        client = httpx.Client(http2=False, timeout=120.0)
+        try:
+            resp = client.post(f"{bridge_url}/v1/chat/completions", json=payload)
+        finally:
+            client.close()
+        if resp.status_code != 200:
+            raise RuntimeError(f"Local bridge HTTP {resp.status_code}: {resp.text}")
+        data = json.loads(resp.text)
+        choice = data["choices"][0]["message"]
+        content = choice.get("content") or ""
+        reasoning = choice.get("reasoning") or choice.get("reasoning_content")
+        if not enable_thinking:
+            reasoning = None
+            if "<think>" in content:
+                import re
+                content = re.sub(r"<think>.*?</think>", "", content, flags=re.DOTALL).strip()
+        raw_tc = choice.get("tool_calls")
+        tool_calls = None
+        if raw_tc:
+            tool_calls = []
+            for tc in raw_tc:
+                fn = tc.get("function", {})
+                args = fn.get("arguments", "{}")
+                if isinstance(args, str):
+                    try:
+                        args = json.loads(args)
+                    except Exception:
+                        args = {}
+                tool_calls.append(ToolCall(id=tc.get("id", "call_1"), name=fn.get("name", ""), arguments=args))
+        return ChatResponse(content=content, reasoning=reasoning, tool_calls=tool_calls, raw=data)
+
+    def _bridge_chat_completion_stream(
+        self,
+        messages: List[dict],
+        tools: Optional[List[dict]] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        enable_thinking: bool = True,
+    ):
+        import httpx
+        import json
+        bridge_url = self._get_bridge_url()
+        sanitized = self._sanitize_messages_for_gguf(messages)
+        if not enable_thinking and sanitized and sanitized[-1].get("role") == "user":
+            u_text = str(sanitized[-1].get("content", ""))
+            if "[Direct Mode:" not in u_text:
+                sanitized[-1]["content"] = u_text + "\n\n[Direct Mode: Output code and tool calls directly without <think> tags. Do not deliberate.]"
+        payload = {
+            "model": "local",
+            "messages": sanitized,
+            "temperature": temperature or 0.2,
+            "max_tokens": max_tokens or 2048,
+            "stream": True,
+        }
+        if tools:
+            payload["tools"] = tools
+            payload["tool_choice"] = "auto"
+        client = httpx.Client(http2=False, timeout=120.0)
+        req = client.build_request("POST", f"{bridge_url}/v1/chat/completions", json=payload)
+        resp = client.send(req, stream=True)
+        if resp.status_code != 200:
+            err = resp.read().decode("utf-8", errors="replace")
+            resp.close()
+            client.close()
+            raise RuntimeError(f"Local bridge HTTP {resp.status_code}: {err}")
+        full_content = []
+        full_reasoning = []
+        tool_calls = []
+        suppress_think = not enable_thinking
+        inside_suppressed_think = False
+        try:
+            for line in resp.iter_lines():
+                line = line.strip()
+                if not line or not line.startswith("data: "):
+                    continue
+                data_str = line[6:].strip()
+                if data_str == "[DONE]":
+                    break
+                try:
+                    chunk = json.loads(data_str)
+                except Exception:
+                    continue
+                choice = chunk["choices"][0]
+                delta = choice.get("delta") or {}
+                text = delta.get("content")
+                if text:
+                    if suppress_think:
+                        if "<think>" in text:
+                            inside_suppressed_think = True
+                            text = text.replace("<think>", "")
+                        if inside_suppressed_think:
+                            if "<tool_call>" in text or "DONE:" in text or "<function=" in text:
+                                inside_suppressed_think = False
+                            elif "</think>" in text:
+                                _, after = text.split("</think>", 1)
+                                inside_suppressed_think = False
+                                text = after
+                            else:
+                                text = ""
+                        else:
+                            text = text.replace("</think>", "")
+                        if not text:
+                            continue
+                        full_content.append(text)
+                        yield ("token", {"delta": text})
+                        continue
+
+                    full_content.append(text)
+                    yield ("token", {"delta": text})
+
+                if (delta.get("reasoning") or delta.get("reasoning_content")) and enable_thinking:
+                    r = delta.get("reasoning") or delta.get("reasoning_content")
+                    full_reasoning.append(r)
+                    yield ("thinking_delta", {"delta": r, "count": len(full_reasoning)})
+        finally:
+            resp.close()
+            client.close()
+        yield ("done", ChatResponse(
+            content="".join(full_content).strip(),
+            reasoning="".join(full_reasoning).strip() or None,
+            tool_calls=tool_calls or None,
+        ))
+
     def shutdown(self) -> None:
         if self._model:
             self._model._llm = None
@@ -840,13 +1004,152 @@ class AndroidBackend(BasePlatformBackend):
     def platform_name(self) -> str:
         return "Android"
 
+    def _get_bridge_url(self) -> str:
+        return os.environ.get("ANDROID_LLAMA_BRIDGE", "http://127.0.0.1:8080").rstrip("/")
+
+    def _find_llama_server_bin(self) -> Optional[Path]:
+        custom = os.environ.get("LLAMA_SERVER_PATH") or os.environ.get("LLAMA_BIN")
+        if custom and Path(custom).is_file():
+            return Path(custom)
+        which_bin = shutil.which("llama-server")
+        if which_bin:
+            return Path(which_bin)
+        candidates = [
+            Path("/data/data/com.termux/files/usr/bin/llama-server"),
+            Path.home() / "llama.cpp" / "build" / "bin" / "llama-server",
+            Path.home() / "llama.cpp" / "build" / "bin" / "Release" / "llama-server",
+            Path.home() / ".alpiecode" / "bin" / "llama-server",
+            Path.cwd() / "llama.cpp" / "build" / "bin" / "llama-server",
+        ]
+        for c in candidates:
+            if c.is_file() and os.access(c, os.X_OK):
+                return c
+        return None
+
+    def _find_gguf_model(self) -> Optional[Path]:
+        from ..local_model import get_model_cache_dir
+        candidate_dirs = [
+            get_model_cache_dir(),
+            Path.home() / ".alpiecode" / "models",
+            Path.home() / "models",
+            Path.cwd() / "models",
+            Path.cwd() / ".alpiecode" / "models",
+        ]
+        for d in candidate_dirs:
+            if d.exists():
+                ggufs = list(d.glob("*.gguf"))
+                mains = [g for g in ggufs if "mmproj" not in g.name.lower()]
+                if mains:
+                    mains.sort(key=lambda p: p.stat().st_size)
+                    return mains[0]
+        return None
+
+    def _ensure_local_server(self) -> bool:
+        """Auto-detect or auto-start local llama-server in background if needed."""
+        if self._is_bridge_online():
+            return True
+        server_bin = self._find_llama_server_bin()
+        if not server_bin:
+            self._last_server_error = "llama-server binary was not found in PATH or ~/llama.cpp/build/bin/llama-server."
+            return False
+        model_path = self._find_gguf_model()
+        if not model_path:
+            self._last_server_error = "No GGUF model found in ~/.alpiecode/models or ~/models."
+            return False
+        mmprojs = list(model_path.parent.glob("*mmproj*.gguf"))
+        cmd = [
+            str(server_bin),
+            "-m", str(model_path),
+            "-c", "2048",
+            "-t", "4",
+            "-np", "1",
+            "-b", "512",
+            "-ub", "256",
+            "--cache-type-k", "q8_0",
+            "--cache-type-v", "q8_0",
+            "--port", "8080",
+        ]
+        if mmprojs:
+            cmd += ["--mmproj", str(mmprojs[0])]
+        try:
+            print(f"⏳ Starting local llama-server in background ({model_path.name})...")
+            subprocess.Popen(
+                cmd,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+            )
+            import time
+            for _ in range(35):
+                if self._is_bridge_online():
+                    return True
+                time.sleep(0.5)
+        except Exception as e:
+            self._last_server_error = f"Failed to launch llama-server: {e}"
+            return False
+        return self._is_bridge_online()
+
     @property
     def is_available(self) -> bool:
         try:
             import llama_cpp
             return True
         except ImportError:
-            return bool(shutil.which("llama-server") or shutil.which("llama-cli"))
+            return self._is_bridge_online() or bool(self._find_llama_server_bin() or shutil.which("llama-cli"))
+
+    def _raise_missing_engine_error(self) -> None:
+        err_detail = getattr(self, "_last_server_error", None)
+        detail_msg = f"\n│  Reason: {err_detail}" if err_detail else ""
+        raise RuntimeError(
+            "\n╭────────────────────────────────────────────────────────────╮\n"
+            "│  Android / Termux Local Inference:                         │\n"
+            "│  Local inference server (http://127.0.0.1:8080) is offline.│"
+            f"{detail_msg}\n"
+            "│                                                            │\n"
+            "│  To start it manually in Termux:                           │\n"
+            "│    llama-server -m ~/.alpiecode/models/*.gguf -c 2048 -t 4 │\n"
+            "╰────────────────────────────────────────────────────────────╯"
+        )
+
+    def chat_completion(
+        self,
+        messages: List[dict],
+        tools: Optional[List[dict]] = None,
+        temperature: float = 0.2,
+        max_tokens: int = 2048,
+        enable_thinking: bool = True,
+    ) -> ChatResponse:
+        try:
+            import llama_cpp
+            return super().chat_completion(messages, tools, temperature, max_tokens, enable_thinking)
+        except ImportError:
+            pass
+
+        if self._ensure_local_server():
+            return self._bridge_chat_completion(messages, tools, temperature, max_tokens, enable_thinking)
+
+        self._raise_missing_engine_error()
+
+    def chat_completion_stream(
+        self,
+        messages: List[dict],
+        tools: Optional[List[dict]] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        enable_thinking: bool = True,
+    ):
+        try:
+            import llama_cpp
+            yield from super().chat_completion_stream(messages, tools, temperature, max_tokens, enable_thinking)
+            return
+        except ImportError:
+            pass
+
+        if self._ensure_local_server():
+            yield from self._bridge_chat_completion_stream(messages, tools, temperature, max_tokens, enable_thinking)
+            return
+
+        self._raise_missing_engine_error()
 
 
 class MacOSBackend(BasePlatformBackend):

{alpiecode-10.6.7 → alpiecode-10.7.0}/src/codeagent/backends/openai_backend.py

@@ -293,7 +293,7 @@ def _repair_and_parse_json_arguments(raw_args: str) -> dict:
         "_parse_error": "Failed to parse streaming JSON arguments",
     }
 
-from ..config import Config, get_shared_http_client, is_server_reachable
+from ..config import Config, get_shared_http_client, is_server_reachable, is_local_endpoint
 from .base import ChatResponse, ToolCall
 
 
@@ -306,6 +306,18 @@ class OpenAIBackend:
         self._resolved_model: Optional[str] = None
         self._max_model_len: Optional[int] = None
 
+    @property
+    def base_url(self) -> str:
+        return getattr(self._cfg, "base_url", "")
+
+    @property
+    def is_local(self) -> bool:
+        return is_local_endpoint(self.base_url)
+
+    @property
+    def is_offline(self) -> bool:
+        return self.is_local
+
     @property
     def name(self) -> str:
         return f"Online API ({self._cfg.base_url})"

{alpiecode-10.6.7 → alpiecode-10.7.0}/src/codeagent/config.py

@@ -14,7 +14,7 @@ from dataclasses import dataclass, asdict, fields
 from pathlib import Path
 from typing import Optional
 
-from .paths import ensure_dir, get_alpiecode_dir, is_ios, load_dotenv_if_present
+from .paths import ensure_dir, get_alpiecode_dir, is_android, is_ios, load_dotenv_if_present
 
 # Auto-load .env if present (zero-dependency)
 load_dotenv_if_present()
@@ -120,6 +120,14 @@ def is_internet_available(timeout: float = 1.0) -> bool:
     return False
 
 
+def is_local_endpoint(base_url: Optional[str]) -> bool:
+    """Check if base_url points to a local machine / loopback interface or offline mode."""
+    if not base_url:
+        return False
+    u = str(base_url).lower().strip()
+    return any(h in u for h in ("127.0.0.1", "localhost", "0.0.0.0", "::1", "offline"))
+
+
 # ── Shared HTTP/2 connection pool ─────────────────────────────────────
 _SHARED_HTTP_CLIENT = None
 
@@ -299,6 +307,17 @@ def interactive_init() -> Config:
         else:
             print("ℹ️  iOS Inference: Online model endpoint (https://test.169pi.ai) is configured.")
             print("   For offline inference on iOS, launch an in-app bridge (http://127.0.0.1:8080).")
+    elif is_android():
+        print("\n⚙️  Configuring inference engine for Android...")
+        from .backends.local_backend import AndroidBackend
+        b = AndroidBackend(cfg)
+        if b.is_available:
+            print("✅ Android local engine ready (native llama-cpp or local server active).")
+            print("✅ Offline mode ready — works without internet from now on!")
+        else:
+            print("ℹ️  To enable local offline inference on Termux, please install:")
+            print("     pkg install llama-cpp")
+            print("   Then run: alpiecode init")
     else:
         try:
             from .local_model import _ensure_llama_cpp

{alpiecode-10.6.7 → alpiecode-10.7.0}/src/codeagent/local_model.py

@@ -258,12 +258,15 @@ def _ensure_llama_cpp():
         )
 
     if is_android():
+        import shutil
+        if shutil.which("llama-server") or shutil.which("llama-cli"):
+            return None
         raise RuntimeError(
             "\n╭────────────────────────────────────────────────────────────╮\n"
             "│  Android / Termux Native Inference:                        │\n"
             "│  Dynamic pip compilation is disabled on Android.            │\n"
             "│  To enable local inference on Termux, please install:       │\n"
-            "│    pkg install llama.cpp                                   │\n"
+            "│    pkg install llama-cpp                                   │\n"
             "╰────────────────────────────────────────────────────────────╯"
         )
 

{alpiecode-10.6.7 → alpiecode-10.7.0}/src/codeagent/orchestrator.py

@@ -47,7 +47,7 @@ from .backends.base import InferenceBackend, ChatResponse
 from .backends.local_backend import LocalBackend
 from .backends.openai_backend import OpenAIBackend
 from .cache import get_cache
-from .config import Config, is_server_reachable, is_internet_available
+from .config import Config, is_server_reachable, is_internet_available, is_local_endpoint
 from .memory import extract_and_save_memories
 from .discovery import build_task_context, gather_relevant_context, COMPLEXITY_CONFIG
 from .progress import ProgressMonitor
@@ -251,7 +251,12 @@ class AgentOrchestrator:
         if isinstance(task_backend, LocalBackend) and is_server_reachable(cfg.base_url, timeout=1.5):
             task_backend = OpenAIBackend(cfg)
 
-        is_offline = not task_backend.is_available or isinstance(task_backend, LocalBackend)
+        is_offline = (
+            not task_backend.is_available
+            or getattr(task_backend, "is_offline", False) is True
+            or isinstance(task_backend, LocalBackend)
+            or is_local_endpoint(getattr(cfg, "base_url", ""))
+        )
         session.is_offline = is_offline
         # ?? Dream-RSI Trajectory Recorder ??
         trajectory_store = TrajectoryStore()

{alpiecode-10.6.7 → alpiecode-10.7.0}/src/codeagent/prompt.py

@@ -530,7 +530,20 @@ class PromptBuilder:
         """Build system prompt, optionally enhanced with TaskContext discovery."""
         if is_offline:
             prompt = OFFLINE_SYSTEM_PROMPT
-        elif complexity == "high":
+            if task_context is not None:
+                shell = getattr(task_context, "shell", "bash")
+                if shell == "powershell":
+                    prompt += "\n\n" + POWERSHELL_RULES
+                elif shell == "wsl":
+                    prompt += "\n\n" + WSL_RULES
+                elif shell == "bash":
+                    prompt += "\n\n" + BASH_RULES
+            memories = format_memories_for_prompt(workdir, max_entries=2, max_chars=250)
+            if memories:
+                prompt += f"\n\n{memories}"
+            return prompt
+
+        if complexity == "high":
             prompt = SYSTEM_PROMPT_HIGH
         else:
             prompt = SYSTEM_PROMPT

{alpiecode-10.6.7 → alpiecode-10.7.0}/src/codeagent/rephraser.py

@@ -119,7 +119,13 @@ class PromptRephraser:
             return task
 
         # In offline/local GGUF mode, skip redundant rephraser LLM pass to ensure instant turn-0 start
-        if type(backend).__name__ == "LocalBackend" or getattr(backend, "is_offline", None) is True:
+        is_local = (
+            type(backend).__name__ == "LocalBackend"
+            or getattr(backend, "is_offline", None) is True
+            or getattr(backend, "is_local", None) is True
+            or any(h in str(getattr(backend, "base_url", "")).lower() for h in ("127.0.0.1", "localhost", "0.0.0.0", "offline"))
+        )
+        if is_local:
             return task
 
         try:

alpiecode-10.7.0/test/test_non_thinking_and_local_stream.py

@@ -0,0 +1,136 @@
+import pytest
+from unittest.mock import MagicMock, patch
+from codeagent.config import Config
+from codeagent.backends.openai_backend import _HTTPXClient, OpenAIBackend
+
+
+def test_httpx_client_uses_http1_for_local_bridge():
+    """Verify that localhost/127.0.0.1 uses an unbuffered HTTP/1.1 client for llama-server."""
+    client_local = _HTTPXClient("http://127.0.0.1:8080/v1", "not-needed")
+    # http2 is disabled for local server
+    assert client_local.http_client._transport._pool._http2 is False or not getattr(client_local.http_client, "_http2", True)
+
+    client_remote = _HTTPXClient("https://test.169pi.ai/v1", "not-needed")
+    assert client_remote.http_client is not None
+
+
+def test_force_no_thinking_flag_on_config():
+    """Verify that force_no_thinking flag defaults to False and can be set to True."""
+    cfg = Config()
+    assert cfg.force_no_thinking is False
+
+    cfg_no_think = Config(force_no_thinking=True)
+    assert cfg_no_think.force_no_thinking is True
+
+
+def test_openai_backend_suppresses_think_in_non_thinking_mode():
+    """Verify that OpenAIBackend suppresses think tokens when enable_thinking=False."""
+    cfg = Config(base_url="http://127.0.0.1:8080/v1")
+    backend = OpenAIBackend(cfg)
+
+    # Mock response chunks containing a <think> block
+    class MockDelta:
+        def __init__(self, content=None, tool_calls=None):
+            self.content = content
+            self.tool_calls = tool_calls
+
+    class MockChoice:
+        def __init__(self, delta):
+            self.delta = delta
+
+    class MockChunk:
+        def __init__(self, content):
+            self.choices = [MockChoice(MockDelta(content=content))]
+
+    mock_stream = [
+        MockChunk("<think>"),
+        MockChunk("Reasoning about prime numbers..."),
+        MockChunk("</think>"),
+        MockChunk("def is_prime(n):"),
+        MockChunk(" return n > 1"),
+    ]
+
+    mock_client = MagicMock()
+    mock_client.chat.completions.create.return_value = mock_stream
+    backend._client = mock_client
+    backend._resolved_model = "alpie_9b"
+
+    events = list(backend.chat_completion_stream(
+        messages=[{"role": "user", "content": "Write a prime checker"}],
+        enable_thinking=False,
+    ))
+
+    # In non-thinking mode, thinking_start and thinking_delta must NOT be emitted
+    event_types = [e[0] for e in events]
+    assert "thinking_start" not in event_types
+    assert "thinking_delta" not in event_types
+
+    # Only real content tokens must be emitted
+    token_events = [e[1]["delta"] for e in events if e[0] == "token"]
+    assert "".join(token_events).strip() == "def is_prime(n): return n > 1"
+
+
+def test_android_backend_offline_bridge_routing():
+    """Verify that AndroidBackend routes to bridge when available."""
+    from codeagent.backends.local_backend import AndroidBackend
+    cfg = Config(base_url="offline")
+    backend = AndroidBackend(cfg)
+
+    # When bridge is online and llama_cpp is absent (Android), is_available is True
+    with patch.dict("sys.modules", {"llama_cpp": None}):
+        with patch.object(backend, "_is_bridge_online", return_value=True):
+            assert backend.is_available is True
+            with patch.object(backend, "_bridge_chat_completion_stream", return_value=iter([("token", {"delta": "hello"})])):
+                res = list(backend.chat_completion_stream([{"role": "user", "content": "hi"}]))
+                assert len(res) == 1
+                assert res[0] == ("token", {"delta": "hello"})
+
+
+def test_is_local_endpoint():
+    from codeagent.config import is_local_endpoint
+    assert is_local_endpoint("http://127.0.0.1:8080/v1") is True
+    assert is_local_endpoint("http://localhost:8080/v1") is True
+    assert is_local_endpoint("http://0.0.0.0:8000") is True
+    assert is_local_endpoint("offline") is True
+    assert is_local_endpoint("https://test.169pi.ai/v1") is False
+    assert is_local_endpoint("https://api.openai.com/v1") is False
+
+
+def test_openai_backend_is_offline_property():
+    cfg_local = Config(base_url="http://127.0.0.1:8080/v1")
+    b_local = OpenAIBackend(cfg_local)
+    assert b_local.is_local is True
+    assert b_local.is_offline is True
+
+    cfg_remote = Config(base_url="https://test.169pi.ai/v1")
+    b_remote = OpenAIBackend(cfg_remote)
+    assert b_remote.is_local is False
+    assert b_remote.is_offline is False
+
+
+def test_rephraser_bypasses_for_local_backend():
+    from codeagent.rephraser import PromptRephraser
+    rephraser = PromptRephraser()
+    cfg = Config(base_url="http://127.0.0.1:8080/v1")
+    backend = OpenAIBackend(cfg)
+
+    # Calling rephrase should return original task immediately without calling backend.chat_completion
+    backend.chat_completion = MagicMock(side_effect=Exception("Should not be called!"))
+    raw_task = "Write a bash script to monitor memory usage"
+    res = rephraser.rephrase(raw_task, backend)
+    assert res == raw_task
+    backend.chat_completion.assert_not_called()
+
+
+def test_prompt_builder_lean_offline_prompt():
+    from pathlib import Path
+    from codeagent.prompt import PromptBuilder, OFFLINE_SYSTEM_PROMPT
+    from codeagent.discovery import build_task_context
+
+    pb = PromptBuilder()
+    ctx = build_task_context("Build a full stack web app with auth", Path("."))
+    # When offline, prompt must be OFFLINE_SYSTEM_PROMPT (lean) and NOT include GOAL_DRIVEN_RULES
+    prompt = pb.build_system_prompt(Path("."), is_offline=True, complexity="high", task_context=ctx)
+    assert "You are running in OFFLINE mode" in prompt
+    assert "Execution & Goal Convergence Rules" not in prompt
+    assert len(prompt) < 3500  # Lean offline prompt under 3500 chars (~600 tokens vs 4500 cloud tokens)

alpiecode-10.6.7/test/test_non_thinking_and_local_stream.py

@@ -1,70 +0,0 @@
-import pytest
-from unittest.mock import MagicMock, patch
-from codeagent.config import Config
-from codeagent.backends.openai_backend import _HTTPXClient, OpenAIBackend
-
-
-def test_httpx_client_uses_http1_for_local_bridge():
-    """Verify that localhost/127.0.0.1 uses an unbuffered HTTP/1.1 client for llama-server."""
-    client_local = _HTTPXClient("http://127.0.0.1:8080/v1", "not-needed")
-    # http2 is disabled for local server
-    assert client_local.http_client._transport._pool._http2 is False or not getattr(client_local.http_client, "_http2", True)
-
-    client_remote = _HTTPXClient("https://test.169pi.ai/v1", "not-needed")
-    assert client_remote.http_client is not None
-
-
-def test_force_no_thinking_flag_on_config():
-    """Verify that force_no_thinking flag defaults to False and can be set to True."""
-    cfg = Config()
-    assert cfg.force_no_thinking is False
-
-    cfg_no_think = Config(force_no_thinking=True)
-    assert cfg_no_think.force_no_thinking is True
-
-
-def test_openai_backend_suppresses_think_in_non_thinking_mode():
-    """Verify that OpenAIBackend suppresses think tokens when enable_thinking=False."""
-    cfg = Config(base_url="http://127.0.0.1:8080/v1")
-    backend = OpenAIBackend(cfg)
-
-    # Mock response chunks containing a <think> block
-    class MockDelta:
-        def __init__(self, content=None, tool_calls=None):
-            self.content = content
-            self.tool_calls = tool_calls
-
-    class MockChoice:
-        def __init__(self, delta):
-            self.delta = delta
-
-    class MockChunk:
-        def __init__(self, content):
-            self.choices = [MockChoice(MockDelta(content=content))]
-
-    mock_stream = [
-        MockChunk("<think>"),
-        MockChunk("Reasoning about prime numbers..."),
-        MockChunk("</think>"),
-        MockChunk("def is_prime(n):"),
-        MockChunk(" return n > 1"),
-    ]
-
-    mock_client = MagicMock()
-    mock_client.chat.completions.create.return_value = mock_stream
-    backend._client = mock_client
-    backend._resolved_model = "alpie_9b"
-
-    events = list(backend.chat_completion_stream(
-        messages=[{"role": "user", "content": "Write a prime checker"}],
-        enable_thinking=False,
-    ))
-
-    # In non-thinking mode, thinking_start and thinking_delta must NOT be emitted
-    event_types = [e[0] for e in events]
-    assert "thinking_start" not in event_types
-    assert "thinking_delta" not in event_types
-
-    # Only real content tokens must be emitted
-    token_events = [e[1]["delta"] for e in events if e[0] == "token"]
-    assert "".join(token_events).strip() == "def is_prime(n): return n > 1"