alpiecode 10.6.4__tar.gz → 10.6.7__tar.gz

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

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

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

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

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

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

{alpiecode-10.6.4 → alpiecode-10.6.7}/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.4 → alpiecode-10.6.7}/src/codeagent/__init__.py

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

{alpiecode-10.6.4 → alpiecode-10.6.7}/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()

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

@@ -1,11 +1,14 @@
 import os
 import shutil
+import subprocess
 import sys
-from typing import Any, List, Optional
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
 
 from ..config import Config
 from ..local_model import LocalModel
-from ..paths import is_android, is_ios
+from ..paths import ensure_dir, get_alpiecode_dir, is_android, is_ios
 from .base import ChatResponse, ToolCall
 
 
@@ -425,7 +428,7 @@ class iOSBackend(BasePlatformBackend):
             import llama_cpp
             return True
         except ImportError:
-            return self._is_bridge_online()
+            return self._is_bridge_online() or self._is_wasm_available()
 
     def _get_bridge_url(self) -> str:
         return os.environ.get("IOS_LLAMA_BRIDGE", "http://127.0.0.1:8080").rstrip("/")
@@ -438,6 +441,224 @@ class iOSBackend(BasePlatformBackend):
         except Exception:
             return False
 
+    def _get_wasm_binary_path(self) -> Optional[Path]:
+        """Locate the llama.wasm binary for a-Shell / WASI execution."""
+        custom = os.environ.get("ALPIECODE_WASM_PATH") or os.environ.get("LLAMA_WASM_PATH")
+        if custom and Path(custom).exists():
+            return Path(custom)
+        candidates = [
+            get_alpiecode_dir() / "bin" / "llama.wasm",
+            get_alpiecode_dir() / "bin" / "llama-cli.wasm",
+            Path.home() / "Documents" / ".alpiecode" / "bin" / "llama.wasm",
+            Path.home() / ".alpiecode" / "bin" / "llama.wasm",
+            Path(sys.prefix) / "bin" / "llama.wasm",
+            Path.cwd() / "llama.wasm",
+            Path.cwd() / ".alpiecode" / "bin" / "llama.wasm",
+        ]
+        for c in candidates:
+            if c.is_file():
+                return c
+        w_bin = shutil.which("llama.wasm") or shutil.which("llama-cli.wasm")
+        if w_bin:
+            return Path(w_bin)
+        return None
+
+    def _get_model_path_safe(self) -> Path:
+        """Resolve model path whether _ensure_model returns LocalModel or Path."""
+        model_obj = self._ensure_model()
+        if hasattr(model_obj, "ensure_model"):
+            return model_obj.ensure_model()
+        if hasattr(model_obj, "model_path") and model_obj.model_path:
+            return Path(model_obj.model_path)
+        return Path(model_obj)
+
+    def _is_wasm_available(self) -> bool:
+        """Check if WASM runner (wasm command or executable .wasm) is available in a-Shell."""
+        has_wasm_cmd = shutil.which("wasm") is not None
+        wasm_bin = self._get_wasm_binary_path()
+        return bool(has_wasm_cmd or wasm_bin)
+
+    def _ensure_wasm_runner(self) -> Tuple[str, Path]:
+        """Verify WASM binary and return (wasm_command, wasm_binary_path)."""
+        wasm_bin = self._get_wasm_binary_path()
+        bin_dir = ensure_dir(get_alpiecode_dir() / "bin")
+        default_wasm = bin_dir / "llama.wasm"
+
+        if not wasm_bin:
+            # Attempt automatic download from HuggingFace so user doesn't have to manually transfer files
+            try:
+                from huggingface_hub import hf_hub_download
+                repo = getattr(self._cfg, "model_repo", "169Pi/alpie_learn_gguf")
+                downloaded = hf_hub_download(
+                    repo_id=repo,
+                    filename="llama.wasm",
+                    local_dir=str(bin_dir),
+                )
+                if downloaded and Path(downloaded).exists():
+                    wasm_bin = Path(downloaded)
+            except Exception:
+                pass
+
+        if not wasm_bin:
+            raise RuntimeError(
+                f"\n╭────────────────────────────────────────────────────────────╮\n"
+                f"│  a-Shell WebAssembly Inference:                            │\n"
+                f"│  llama.wasm binary not found.                              │\n"
+                f"│                                                            │\n"
+                f"│  To enable offline inference in a-Shell:                   │\n"
+                f"│  1. Place 'llama.wasm' into:                               │\n"
+                f"│     {str(default_wasm)[:55]:<55}│\n"
+                f"│  2. Or set: export ALPIECODE_WASM_PATH=/path/to/llama.wasm │\n"
+                f"╰────────────────────────────────────────────────────────────╯"
+            )
+
+        runner = shutil.which("wasm") or "wasm"
+        return runner, wasm_bin
+
+    def _format_messages_to_prompt(self, messages: List[dict]) -> str:
+        """Format OpenAI-style message dictionary list into ChatML prompt string."""
+        sanitized = self._sanitize_messages_for_gguf(messages)
+        parts = []
+        for msg in sanitized:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+            parts.append(f"<|im_start|>{role}\n{content}<|im_end|>")
+        parts.append("<|im_start|>assistant\n")
+        return "\n".join(parts)
+
+    def _wasm_chat_completion(
+        self,
+        messages: List[dict],
+        tools: Optional[List[dict]] = None,
+        temperature: float = 0.2,
+        max_tokens: int = 2048,
+        enable_thinking: bool = True,
+    ) -> ChatResponse:
+        runner, wasm_path = self._ensure_wasm_runner()
+        model_path = self._get_model_path_safe()
+        prompt = self._format_messages_to_prompt(messages)
+
+        with tempfile.NamedTemporaryFile("w", encoding="utf-8", delete=False, suffix=".txt") as tf:
+            tf.write(prompt)
+            prompt_file = tf.name
+
+        try:
+            n_ctx = str(getattr(self._cfg, "n_ctx", 4096))
+            base_args = [
+                "-m", str(model_path),
+                "-f", prompt_file,
+                "-n", str(max_tokens),
+                "--temp", str(temperature),
+                "-c", n_ctx,
+                "--no-mmap",
+                "--simple-io",
+                "--no-display-prompt",
+                "-t", "4",
+            ]
+            if shutil.which(runner):
+                cmd = [runner, str(wasm_path)] + base_args
+            else:
+                cmd = [str(wasm_path)] + base_args
+
+            res = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
+            if res.returncode != 0:
+                err = res.stderr.strip() or res.stdout.strip()
+                if "memory" in err.lower() or "bounds" in err.lower() or "alloc" in err.lower():
+                    raise RuntimeError(
+                        f"\n❌ WASM Memory Allocation Failed for '{model_path.name}'.\n"
+                        f"   The model size ({model_path.stat().st_size / (1024**3):.2f} GB) exceeded the 32-bit WASM limit (~2-4 GB).\n"
+                        f"   Details: {err[:200]}"
+                    )
+                raise RuntimeError(f"WASM llama execution failed (code {res.returncode}): {err[:250]}")
+
+            raw_output = res.stdout.strip()
+            content = raw_output
+            reasoning = None
+            if "<think>" in raw_output and "</think>" in raw_output:
+                p1, p2 = raw_output.split("</think>", 1)
+                reasoning = p1.replace("<think>", "").strip()
+                content = p2.strip()
+            elif "<think>" in raw_output:
+                content = raw_output.replace("<think>", "").strip()
+
+            return ChatResponse(content=content, reasoning=reasoning, tool_calls=None, raw={"output": raw_output})
+        finally:
+            try:
+                os.remove(prompt_file)
+            except Exception:
+                pass
+
+    def _wasm_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,
+    ):
+        runner, wasm_path = self._ensure_wasm_runner()
+        model_path = self._get_model_path_safe()
+        prompt = self._format_messages_to_prompt(messages)
+
+        with tempfile.NamedTemporaryFile("w", encoding="utf-8", delete=False, suffix=".txt") as tf:
+            tf.write(prompt)
+            prompt_file = tf.name
+
+        proc = None
+        try:
+            n_ctx = str(getattr(self._cfg, "n_ctx", 4096))
+            t_val = str(temperature if temperature is not None else 0.2)
+            m_val = str(max_tokens if max_tokens is not None else 2048)
+
+            base_args = [
+                "-m", str(model_path),
+                "-f", prompt_file,
+                "-n", m_val,
+                "--temp", t_val,
+                "-c", n_ctx,
+                "--no-mmap",
+                "--simple-io",
+                "--no-display-prompt",
+                "-t", "4",
+            ]
+            if shutil.which(runner):
+                cmd = [runner, str(wasm_path)] + base_args
+            else:
+                cmd = [str(wasm_path)] + base_args
+
+            proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1)
+            full_content = []
+            for line in proc.stdout:
+                if line:
+                    full_content.append(line)
+                    yield ("token", {"delta": line})
+            proc.wait()
+            if proc.returncode != 0:
+                err = proc.stderr.read().strip() if proc.stderr else ""
+                if "memory" in err.lower() or "bounds" in err.lower():
+                    raise RuntimeError(
+                        f"\n❌ WASM Memory Allocation Failed for '{model_path.name}'.\n"
+                        f"   Details: {err[:200]}"
+                    )
+                if not full_content:
+                    raise RuntimeError(f"WASM execution exited with code {proc.returncode}: {err[:200]}")
+
+            yield ("done", ChatResponse(
+                content="".join(full_content).strip(),
+                reasoning=None,
+                tool_calls=None,
+            ))
+        finally:
+            if proc and proc.poll() is None:
+                try:
+                    proc.kill()
+                except Exception:
+                    pass
+            try:
+                os.remove(prompt_file)
+            except Exception:
+                pass
+
     def chat_completion(
         self,
         messages: List[dict],
@@ -455,12 +676,18 @@ class iOSBackend(BasePlatformBackend):
         if self._is_bridge_online():
             return self._bridge_chat_completion(messages, tools, temperature, max_tokens, enable_thinking)
 
+        if self._is_wasm_available():
+            return self._wasm_chat_completion(messages, tools, temperature, max_tokens, enable_thinking)
+
         raise RuntimeError(
             "\n╭────────────────────────────────────────────────────────────╮\n"
-            "│  iOS Native Inference:                                     │\n"
+            "│  iOS Native Inference (a-Shell / Container):               │\n"
             "│  Dynamic compilation via pip is disabled on iOS.           │\n"
-            "│  llama.cpp must be pre-bundled with the iOS app container   │\n"
-            "│  or served via a local bridge (e.g. http://127.0.0.1:8080). │\n"
+            "│                                                            │\n"
+            "│  Choose one of the following to run offline on iOS:        │\n"
+            "│  1. a-Shell WASM: Place llama.wasm into ~/.alpiecode/bin/  │\n"
+            "│  2. Local Bridge: Run local server on 127.0.0.1:8080       │\n"
+            "│  3. Pre-bundled: llama.cpp inside iOS app container        │\n"
             "╰────────────────────────────────────────────────────────────╯"
         )
 
@@ -527,12 +754,19 @@ class iOSBackend(BasePlatformBackend):
             yield from self._bridge_chat_completion_stream(messages, tools, temperature, max_tokens, enable_thinking)
             return
 
+        if self._is_wasm_available():
+            yield from self._wasm_chat_completion_stream(messages, tools, temperature, max_tokens, enable_thinking)
+            return
+
         raise RuntimeError(
             "\n╭────────────────────────────────────────────────────────────╮\n"
-            "│  iOS Native Inference:                                     │\n"
+            "│  iOS Native Inference (a-Shell / Container):               │\n"
             "│  Dynamic compilation via pip is disabled on iOS.           │\n"
-            "│  llama.cpp must be pre-bundled with the iOS app container   │\n"
-            "│  or served via a local bridge (e.g. http://127.0.0.1:8080). │\n"
+            "│                                                            │\n"
+            "│  Choose one of the following to run offline on iOS:        │\n"
+            "│  1. a-Shell WASM: Place llama.wasm into ~/.alpiecode/bin/  │\n"
+            "│  2. Local Bridge: Run local server on 127.0.0.1:8080       │\n"
+            "│  3. Pre-bundled: llama.cpp inside iOS app container        │\n"
             "╰────────────────────────────────────────────────────────────╯"
         )
 

{alpiecode-10.6.4 → alpiecode-10.6.7}/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)
 
@@ -397,6 +406,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 +439,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 +494,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 +535,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 +547,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 +557,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 +708,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.4 → alpiecode-10.6.7}/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.4 → alpiecode-10.6.7}/src/codeagent/config.py

@@ -152,6 +152,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
 

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

@@ -327,7 +327,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 +403,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 +445,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.4 → alpiecode-10.6.7}/test/test_local_model_download.py

@@ -286,3 +286,100 @@ def test_embedded_hf_token_used_when_no_env(monkeypatch):
             from codeagent.local_model import EMBEDDED_HF_TOKEN
             assert EMBEDDED_HF_TOKEN in captured_tokens
 
+
+def test_ios_backend_wasm_dispatch(tmp_path, monkeypatch):
+    """When llama_cpp is absent and bridge is offline, iOSBackend dispatches to WASM runner."""
+    from codeagent.backends.local_backend import iOSBackend
+    cfg = load_config()
+    b = iOSBackend(cfg)
+
+    wasm_bin = tmp_path / "llama.wasm"
+    wasm_bin.touch()
+    fake_model = tmp_path / "alpie-vl-text-q3_k_m.gguf"
+    fake_model.touch()
+
+    monkeypatch.setenv("ALPIECODE_WASM_PATH", str(wasm_bin))
+
+    mock_run = MagicMock()
+    mock_run.returncode = 0
+    mock_run.stdout = "<think>Analyzing code...</think>\nHello from WASM offline!"
+    mock_run.stderr = ""
+
+    with patch.dict("sys.modules", {"llama_cpp": None}), \
+         patch.object(b, "_is_bridge_online", return_value=False), \
+         patch.object(b, "_ensure_model", return_value=fake_model), \
+         patch("shutil.which", return_value="/usr/bin/wasm"), \
+         patch("subprocess.run", return_value=mock_run) as run_spy:
+        res = b.chat_completion([{"role": "user", "content": "hello"}])
+        assert res.content == "Hello from WASM offline!"
+        assert res.reasoning == "Analyzing code..."
+
+        # Verify command arguments
+        assert run_spy.called
+        cmd = run_spy.call_args[0][0]
+        assert cmd[0] == "/usr/bin/wasm"
+        assert cmd[1] == str(wasm_bin)
+        assert "-m" in cmd
+        assert str(fake_model) in cmd
+        assert "-f" in cmd
+
+
+def test_ios_backend_wasm_streaming(tmp_path, monkeypatch):
+    """iOSBackend streams tokens line-by-line via WASM runner."""
+    from codeagent.backends.local_backend import iOSBackend
+    cfg = load_config()
+    b = iOSBackend(cfg)
+
+    wasm_bin = tmp_path / "llama.wasm"
+    wasm_bin.touch()
+    fake_model = tmp_path / "alpie-vl-text-q3_k_m.gguf"
+    fake_model.touch()
+
+    monkeypatch.setenv("ALPIECODE_WASM_PATH", str(wasm_bin))
+
+    mock_proc = MagicMock()
+    mock_proc.stdout = ["Hello ", "from ", "stream!"]
+    mock_proc.returncode = 0
+    mock_proc.poll.return_value = 0
+
+    with patch.dict("sys.modules", {"llama_cpp": None}), \
+         patch.object(b, "_is_bridge_online", return_value=False), \
+         patch.object(b, "_ensure_model", return_value=fake_model), \
+         patch("shutil.which", return_value="/usr/bin/wasm"), \
+         patch("subprocess.Popen", return_value=mock_proc):
+        stream = list(b.chat_completion_stream([{"role": "user", "content": "hi"}]))
+        tokens = [payload["delta"] for tag, payload in stream if tag == "token"]
+        assert "".join(tokens) == "Hello from stream!"
+        assert stream[-1][0] == "done"
+        assert stream[-1][1].content == "Hello from stream!"
+
+
+def test_ios_backend_wasm_memory_error(tmp_path, monkeypatch):
+    """WASM runtime memory allocation failure throws actionable diagnostic."""
+    from codeagent.backends.local_backend import iOSBackend
+    cfg = load_config()
+    b = iOSBackend(cfg)
+
+    wasm_bin = tmp_path / "llama.wasm"
+    wasm_bin.touch()
+    fake_model = tmp_path / "alpie-vl-text-q3_k_m.gguf"
+    fake_model.touch()
+
+    monkeypatch.setenv("ALPIECODE_WASM_PATH", str(wasm_bin))
+
+    mock_run = MagicMock()
+    mock_run.returncode = 1
+    mock_run.stdout = ""
+    mock_run.stderr = "RuntimeError: out of bounds memory access / memory allocation failed"
+
+    with patch.dict("sys.modules", {"llama_cpp": None}), \
+         patch.object(b, "_is_bridge_online", return_value=False), \
+         patch.object(b, "_ensure_model", return_value=fake_model), \
+         patch("shutil.which", return_value="/usr/bin/wasm"), \
+         patch("subprocess.run", return_value=mock_run):
+        with pytest.raises(RuntimeError) as exc_info:
+            b.chat_completion([{"role": "user", "content": "hello"}])
+        assert "WASM Memory Allocation Failed" in str(exc_info.value)
+        assert "32-bit WASM limit" in str(exc_info.value)
+
+

alpiecode-10.6.7/test/test_non_thinking_and_local_stream.py

@@ -0,0 +1,70 @@
+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"