alpiecode 10.6.6__tar.gz → 10.6.9__tar.gz

{alpiecode-10.6.6 → alpiecode-10.6.9}/PKG-INFO

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

{alpiecode-10.6.6 → alpiecode-10.6.9}/pyproject.toml

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

{alpiecode-10.6.6 → alpiecode-10.6.9}/src/alpiecode.egg-info/PKG-INFO

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

{alpiecode-10.6.6 → alpiecode-10.6.9}/src/alpiecode.egg-info/SOURCES.txt

@@ -51,5 +51,6 @@ test/test_cli_ui.py
 test/test_context_and_trajectory.py
 test/test_dream_rsi.py
 test/test_local_model_download.py
+test/test_non_thinking_and_local_stream.py
 test/test_task_assessment.py
 test/test_verifier.py

{alpiecode-10.6.6 → alpiecode-10.6.9}/src/codeagent/__init__.py

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

{alpiecode-10.6.6 → alpiecode-10.6.9}/src/codeagent/agent.py

@@ -376,12 +376,16 @@ def run_agent(
                 else:
                     status_spinner.update("Reasoning through implementation...", style="bold magenta")
 
-            elif event.type == "thinking_delta" and verbose and debug:
-                status_spinner.pause()
+            elif event.type == "thinking_delta" and verbose:
                 delta = event.data.get("delta", "")
-                if delta:
-                    sys.stdout.write(delta)
-                    sys.stdout.flush()
+                count = event.data.get("count", 0)
+                if debug:
+                    if delta:
+                        status_spinner.pause()
+                        sys.stdout.write(delta)
+                        sys.stdout.flush()
+                elif count > 0 and count % 15 == 0:
+                    status_spinner.update(f"Reasoning through implementation ({count} tokens)...", style="bold magenta")
 
             elif event.type == "thinking_end" and verbose:
                 duration = event.data.get("duration", 0)
@@ -504,7 +508,9 @@ def run_agent(
                     else:
                         print(f"── Step {current_turn} ──")
                 if current_turn > 0:
-                    status_spinner.resume(f"Step {current_turn}: Thinking...", style="bold cyan")
+                    is_turn_thinking = event.data.get("thinking", True)
+                    turn_label = "Thinking..." if is_turn_thinking else "Working..."
+                    status_spinner.resume(f"Step {current_turn}: {turn_label}", style="bold cyan")
 
             elif event.type == "compaction" and verbose:
                 status_spinner.pause()
@@ -728,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.6 → alpiecode-10.6.9}/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,119 @@ 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 _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 = shutil.which("llama-server")
+        if not server_bin:
+            return False
+        from ..local_model import get_model_cache_dir
+        cache_dir = get_model_cache_dir()
+        if not cache_dir.exists():
+            return False
+        ggufs = list(cache_dir.glob("*.gguf"))
+        main_models = [g for g in ggufs if "mmproj" not in g.name.lower()]
+        if not main_models:
+            return False
+        model_path = main_models[0]
+        mmprojs = [g for g in ggufs if "mmproj" in g.name.lower()]
+        cmd = [
+            server_bin,
+            "-m", str(model_path),
+            "-c", "4096",
+            "-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:
+            subprocess.Popen(
+                cmd,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+            )
+            import time
+            for _ in range(25):
+                if self._is_bridge_online():
+                    return True
+                time.sleep(0.4)
+        except Exception:
+            pass
+        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(shutil.which("llama-server") or shutil.which("llama-cli"))
+
+    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)
+
+        raise RuntimeError(
+            "\n╭────────────────────────────────────────────────────────────╮\n"
+            "│  Android / Termux Native Inference:                        │\n"
+            "│  No local engine is available.                             │\n"
+            "│  To enable local inference on Termux, run:                 │\n"
+            "│    pkg install llama-cpp                                   │\n"
+            "│    alpiecode init                                          │\n"
+            "╰────────────────────────────────────────────────────────────╯"
+        )
+
+    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
+
+        raise RuntimeError(
+            "\n╭────────────────────────────────────────────────────────────╮\n"
+            "│  Android / Termux Native Inference:                        │\n"
+            "│  No local engine is available.                             │\n"
+            "│  To enable local inference on Termux, run:                 │\n"
+            "│    pkg install llama-cpp                                   │\n"
+            "│    alpiecode init                                          │\n"
+            "╰────────────────────────────────────────────────────────────╯"
+        )
 
 
 class MacOSBackend(BasePlatformBackend):

{alpiecode-10.6.6 → alpiecode-10.6.9}/src/codeagent/backends/openai_backend.py

@@ -175,7 +175,16 @@ class _HTTPXClient:
     def __init__(self, base_url: str, api_key: str, http_client: Any = None):
         self.base_url = base_url
         self.api_key = api_key or "not-needed"
-        self.http_client = http_client if http_client is not None else get_shared_http_client()
+        if http_client is not None:
+            self.http_client = http_client
+        elif "127.0.0.1" in base_url or "localhost" in base_url:
+            self.http_client = httpx.Client(
+                http2=False,
+                timeout=httpx.Timeout(180.0, connect=5.0, read=180.0, write=30.0),
+                limits=httpx.Limits(max_keepalive_connections=5, max_connections=10),
+            )
+        else:
+            self.http_client = get_shared_http_client()
         self.chat = _Namespace(completions=_HTTPXChatCompletions(self))
         self.models = _HTTPXModels(self)
 
@@ -284,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
 
 
@@ -297,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})"
@@ -397,6 +418,17 @@ class OpenAIBackend:
             except ValueError:
                 pass
 
+        # For local endpoints (e.g. llama-server on Android), instruct model to skip <think> in fast mode
+        if not enable_thinking and ("127.0.0.1" in getattr(self._cfg, "base_url", "") or "localhost" in getattr(self._cfg, "base_url", "")):
+            clean_messages = []
+            for m in messages:
+                clean_messages.append(dict(m))
+            if clean_messages and clean_messages[-1].get("role") == "user":
+                u_text = str(clean_messages[-1].get("content", ""))
+                if "[Direct Mode:" not in u_text:
+                    clean_messages[-1]["content"] = u_text + "\n\n[Direct Mode: Output code and tool calls directly without <think> tags. Do not deliberate.]"
+            messages = clean_messages
+
         params = {
             "model": model_name,
             "messages": messages,
@@ -419,6 +451,8 @@ class OpenAIBackend:
             response = client.chat.completions.create(**params)
 
         in_think = enable_thinking
+        suppress_think = not enable_thinking
+        inside_suppressed_think = False
         think_started = False
         full_content = []
         full_reasoning = []
@@ -472,16 +506,38 @@ class OpenAIBackend:
 
             # Explicit reasoning field from some models
             explicit_reasoning = getattr(delta, "reasoning", None) or getattr(delta, "reasoning_content", None)
-            if explicit_reasoning:
+            if explicit_reasoning and enable_thinking:
                 if not think_started:
                     think_started = True
                     yield ("thinking_start", {"time": start_time})
                 full_reasoning.append(explicit_reasoning)
-                yield ("thinking_delta", {"delta": explicit_reasoning})
+                yield ("thinking_delta", {"delta": explicit_reasoning, "count": len(full_reasoning)})
 
             # Content deltas (contains <think>...</think> on vLLM/Qwen models)
             if delta.content:
                 text = delta.content
+                if suppress_think:
+                    # In non-thinking mode, swallow any think tags/blocks emitted by local models
+                    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
+
                 if in_think:
                     if not think_started:
                         think_started = True
@@ -491,7 +547,7 @@ class OpenAIBackend:
                         before, after = text.split("</think>", 1)
                         if before:
                             full_reasoning.append(before)
-                            yield ("thinking_delta", {"delta": before})
+                            yield ("thinking_delta", {"delta": before, "count": len(full_reasoning)})
                         in_think = False
                         elapsed = time.time() - start_time
                         yield ("thinking_end", {"duration": round(elapsed, 1), "content": "".join(full_reasoning).strip()})
@@ -503,7 +559,7 @@ class OpenAIBackend:
                         before, after = text.split("DONE:", 1)
                         if before:
                             full_reasoning.append(before)
-                            yield ("thinking_delta", {"delta": before})
+                            yield ("thinking_delta", {"delta": before, "count": len(full_reasoning)})
                         in_think = False
                         elapsed = time.time() - start_time
                         yield ("thinking_end", {"duration": round(elapsed, 1), "content": "".join(full_reasoning).strip()})
@@ -513,7 +569,7 @@ class OpenAIBackend:
                     else:
                         clean_text = text.replace("<think>", "")
                         full_reasoning.append(clean_text)
-                        yield ("thinking_delta", {"delta": clean_text})
+                        yield ("thinking_delta", {"delta": clean_text, "count": len(full_reasoning)})
                 else:
                     full_content.append(text)
                     yield ("token", {"delta": text})
@@ -664,6 +720,9 @@ class OpenAIBackend:
                         reasoning = re.sub(r"(?i)^thinking process:\s*", "", content).strip()
                         content = ""
 
+        if not enable_thinking:
+            reasoning = None
+
         return ChatResponse(
             content=content,
             reasoning=reasoning,

{alpiecode-10.6.6 → alpiecode-10.6.9}/src/codeagent/cli.py

@@ -274,10 +274,13 @@ def main():
     if getattr(args, "force_thinking", False):
         cfg.force_thinking = True
         cfg.enable_thinking = True
+        cfg.force_no_thinking = False
     elif getattr(args, "thinking", False):
         cfg.enable_thinking = True
+        cfg.force_no_thinking = False
     elif getattr(args, "no_thinking", False):
         cfg.enable_thinking = False
+        cfg.force_no_thinking = True
 
     if args.command == "run":
         if args.max_turns:

{alpiecode-10.6.6 → alpiecode-10.6.9}/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
 
@@ -152,6 +160,7 @@ class Config:
     enable_thinking: bool = False
     adaptive_thinking: bool = True
     force_thinking: bool = False
+    force_no_thinking: bool = False
     n_ctx: int = 32768
     n_gpu_layers: Optional[int] = None
 
@@ -298,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.6 → alpiecode-10.6.9}/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.6 → alpiecode-10.6.9}/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()
@@ -327,7 +332,10 @@ class AgentOrchestrator:
 
         # ── Adaptive thinking (base setting) ──
         strict_format = getattr(getattr(task_context, "assessment", None), "requires_strict_format", False) or getattr(task_context, "requires_strict_format", False)
-        if getattr(cfg, "force_thinking", False):
+        if getattr(cfg, "force_no_thinking", False):
+            base_enable_thinking = False
+            yield AgentEvent("adaptive_mode", {"message": "Non-thinking mode explicitly requested via --no-thinking; fast execution enabled.", "thinking": False})
+        elif getattr(cfg, "force_thinking", False):
             base_enable_thinking = True
         elif strict_format:
             base_enable_thinking = False
@@ -400,7 +408,9 @@ class AgentOrchestrator:
                     )
 
             # ── Turn-Level Adaptive Reasoning Dynamics ──
-            if getattr(cfg, "force_thinking", False) or not getattr(cfg, "adaptive_thinking", True):
+            if getattr(cfg, "force_no_thinking", False):
+                turn_enable_thinking = False
+            elif getattr(cfg, "force_thinking", False) or not getattr(cfg, "adaptive_thinking", True):
                 turn_enable_thinking = base_enable_thinking
             elif strict_format:
                 if prior_turn_had_error:
@@ -440,7 +450,7 @@ class AgentOrchestrator:
                 yield AgentEvent("safety_ceiling", {"turn": turn, "ceiling": safety_ceiling})
                 break
 
-            yield AgentEvent("turn_start", {"turn": turn})
+            yield AgentEvent("turn_start", {"turn": turn, "thinking": turn_enable_thinking})
 
             # In offline mode, guide the model with current workspace progress
             if is_offline and turn >= 1:

{alpiecode-10.6.6 → alpiecode-10.6.9}/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.6 → alpiecode-10.6.9}/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.6.9/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)