alpiecode 10.6.6__tar.gz → 10.6.7__tar.gz

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

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

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

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

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

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

{alpiecode-10.6.6 → 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.6 → 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.6"
+__version__ = "10.6.7"
 
 def run(task: str, workdir: str = ".", reasoning_level: str = "thinking", **kwargs):
     """Run an autonomous coding task programmatically."""

{alpiecode-10.6.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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.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"