alpiecode 10.5.4__tar.gz → 10.5.6__tar.gz

{alpiecode-10.5.4 → alpiecode-10.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 10.5.4
+Version: 10.5.6
 Summary: AlpieCode
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0
@@ -8,7 +8,6 @@ Requires-Dist: rich>=13.0
 Requires-Dist: click>=8.0
 Requires-Dist: openai>=1.0.0
 Requires-Dist: httpx[http2]>=0.24.0
-Requires-Dist: duckduckgo-search>=7.0.0
 Requires-Dist: beautifulsoup4>=4.12.0
 Requires-Dist: yt-dlp>=2024.0.0
 Requires-Dist: imageio-ffmpeg>=0.4.0

{alpiecode-10.5.4 → alpiecode-10.5.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "10.5.4"
+version = "10.5.6"
 description = "AlpieCode"
 requires-python = ">=3.9"
 dependencies = [
@@ -13,7 +13,6 @@ dependencies = [
     "click>=8.0",
     "openai>=1.0.0",
     "httpx[http2]>=0.24.0",
-    "duckduckgo-search>=7.0.0",
     "beautifulsoup4>=4.12.0",
     "yt-dlp>=2024.0.0",
     "imageio-ffmpeg>=0.4.0",

{alpiecode-10.5.4 → alpiecode-10.5.6}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 10.5.4
+Version: 10.5.6
 Summary: AlpieCode
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0
@@ -8,7 +8,6 @@ Requires-Dist: rich>=13.0
 Requires-Dist: click>=8.0
 Requires-Dist: openai>=1.0.0
 Requires-Dist: httpx[http2]>=0.24.0
-Requires-Dist: duckduckgo-search>=7.0.0
 Requires-Dist: beautifulsoup4>=4.12.0
 Requires-Dist: yt-dlp>=2024.0.0
 Requires-Dist: imageio-ffmpeg>=0.4.0

{alpiecode-10.5.4 → alpiecode-10.5.6}/src/alpiecode.egg-info/SOURCES.txt

@@ -45,6 +45,7 @@ src/codeagent/backends/base.py
 src/codeagent/backends/local_backend.py
 src/codeagent/backends/openai_backend.py
 src/codeagent/extension/alpiecode.vsix
+test/test_adaptive_resilience.py
 test/test_cli_ui.py
 test/test_context_and_trajectory.py
 test/test_dream_rsi.py

{alpiecode-10.5.4 → alpiecode-10.5.6}/src/alpiecode.egg-info/requires.txt

@@ -3,7 +3,6 @@ rich>=13.0
 click>=8.0
 openai>=1.0.0
 httpx[http2]>=0.24.0
-duckduckgo-search>=7.0.0
 beautifulsoup4>=4.12.0
 yt-dlp>=2024.0.0
 imageio-ffmpeg>=0.4.0

{alpiecode-10.5.4 → alpiecode-10.5.6}/src/codeagent/__init__.py

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

{alpiecode-10.5.4 → alpiecode-10.5.6}/src/codeagent/assessment.py

@@ -85,6 +85,7 @@ class TaskAssessment:
     estimated_tool_calls: int = 1
     strategy: str = ExecutionStrategy.FAST_PATH.value
     rationale: str = ""
+    requires_strict_format: bool = False
 
     @property
     def legacy_complexity(self) -> str:
@@ -115,6 +116,7 @@ class TaskAssessment:
             "estimated_tool_calls": self.estimated_tool_calls,
             "strategy": self.strategy,
             "rationale": self.rationale,
+            "requires_strict_format": self.requires_strict_format,
             "legacy_complexity": self.legacy_complexity,
         }
 
@@ -122,12 +124,15 @@ class TaskAssessment:
 # ── Pattern Dictionaries for Sub-15ms Deterministic Analysis ───────────────
 
 _QA_INDICATORS = [
-    r"^\s*(what\s+is|what\s+are|what\'s|what\s+does|what\s+do)\b",
+    r"^\s*(what\s+is|what\s+are|what\'s|what\s+does|what\s+do|what\s+can\s+you|what\s+can\s+i|what\s+can\s+we)\b",
+    r"^\s*(what\s+are\s+your|what\s+tools|what\s+capabilities|what\s+can)\b",
+    r"^\s*(who\s+are\s+you|who\s+made\s+you|who\s+created\s+you)\b",
     r"^\s*(explain|describe|define|compare|contrast)\b",
-    r"^\s*(how\s+does|how\s+do|why\s+does|why\s+do|why\s+is)\b",
-    r"^\s*(can\s+you\s+explain|could\s+you\s+explain|tell\s+me\s+about)\b",
+    r"^\s*(how\s+does|how\s+do|why\s+does|why\s+do|why\s+is|how\s+to|how\s+can\s+i|how\s+can\s+you)\b",
+    r"^\s*(can\s+you\s+explain|could\s+you\s+explain|tell\s+me\s+about|can\s+you\s+help|help\s+me\s+with)\b",
     r"^\s*(who\s+invented|when\s+was|difference\s+between)\b",
     r"^\s*(is\s+it\s+possible|is\s+there\s+a\s+way)\b",
+    r"^\s*(help|capabilities|hello|hi|hey)\b",
 ]
 
 _EXPLAIN_INDICATORS = [
@@ -192,6 +197,15 @@ _EXTERNAL_DEP_INDICATORS = [
     r"\b(pydantic|fastapi|flask|django|react|vue|angular|express|torch|pandas|numpy)\b",
 ]
 
+_STRICT_FORMAT_INDICATORS = [
+    r"\b(?:only\s+(?:a\s+)?json|valid\s+json|return\s+(?:only\s+)?json|json\s+object|json\s+only|just\s+json|pure\s+json)\b",
+    r"\b(?:strict(?:ly)?\s+json|in\s+json\s+format|raw\s+json|respond\s+with\s+json)\b",
+    r"\b(?:no\s+explanation|without\s+(?:any\s+)?explanation|without\s+extra\s+text|no\s+surrounding\s+text|no\s+preamble)\b",
+    r"\b(?:single\s+line|one\s+line\s+only|single-line)\b",
+    r"\b(?:one\s+word|single\s+word|just\s+the\s+number|regex\s+only)\b",
+    r"\b(?:format:\s*json|schema:\s*\{)\b",
+]
+
 
 def assess_task(
     task: str,
@@ -215,10 +229,12 @@ def assess_task(
             estimated_tool_calls=1,
             strategy=ExecutionStrategy.FAST_PATH.value,
             rationale="Empty task string defaulted to fast local execution.",
+            requires_strict_format=False,
         )
 
     task_clean = task.strip()
     task_lower = task_clean.lower()
+    requires_strict_format = any(re.search(pat, task_lower) for pat in _STRICT_FORMAT_INDICATORS)
     repo = repo_info or {}
     file_count = repo.get("file_count", 0)
     has_tests = repo.get("has_tests", False)
@@ -228,8 +244,12 @@ def assess_task(
 
     # ── 1. Intent Classification ──
     intent = TaskIntent.CREATE.value
-    if any(re.search(pat, task_lower) for pat in _QA_INDICATORS) and not any(
-        kw in task_lower for kw in ["write", "create", "implement", "build", "fix", "code", "script"]
+    is_qa_candidate = (
+        any(re.search(pat, task_lower) for pat in _QA_INDICATORS)
+        or (task_clean.endswith("?") and not any(kw in task_lower for kw in ["write", "create", "implement", "build", "fix", "code", "script", "add", "modify", "refactor"]))
+    )
+    if is_qa_candidate and not any(
+        kw in task_lower for kw in ["write", "create", "implement", "build", "fix", "code", "script", "refactor", "modify"]
     ):
         intent = TaskIntent.QA.value
     elif any(re.search(pat, task_lower) for pat in _EXPLAIN_INDICATORS) and not any(
@@ -240,7 +260,7 @@ def assess_task(
         intent = TaskIntent.DEBUG.value
     elif any(re.search(pat, task_lower) for pat in _MODIFY_INDICATORS):
         intent = TaskIntent.MODIFY.value
-    elif intent == TaskIntent.CREATE.value and any(re.search(pat, task_lower) for pat in _QA_INDICATORS):
+    elif intent == TaskIntent.CREATE.value and (any(re.search(pat, task_lower) for pat in _QA_INDICATORS) or task_clean.endswith("?")):
         # Fallback question check
         intent = TaskIntent.QA.value
 
@@ -397,4 +417,5 @@ def assess_task(
         estimated_tool_calls=estimated_tool_calls,
         strategy=strategy,
         rationale=rationale,
+        requires_strict_format=requires_strict_format,
     )

{alpiecode-10.5.4 → alpiecode-10.5.6}/src/codeagent/backends/openai_backend.py

@@ -127,6 +127,7 @@ class OpenAIBackend:
         self._cfg = cfg
         self._client: Optional[OpenAI] = None
         self._resolved_model: Optional[str] = None
+        self._max_model_len: Optional[int] = None
 
     @property
     def name(self) -> str:
@@ -138,6 +139,8 @@ class OpenAIBackend:
 
     @property
     def context_window(self) -> int:
+        if self._max_model_len:
+            return self._max_model_len
         return 262_144
 
     def _ensure_client(self) -> OpenAI:
@@ -173,10 +176,13 @@ class OpenAIBackend:
                 for m in models_list.data:
                     if m.id == self._cfg.model or getattr(m, "root", None) == self._cfg.model:
                         self._resolved_model = m.id
-                        logger.info("Resolved model: %s", self._resolved_model)
+                        self._max_model_len = getattr(m, "max_model_len", None)
+                        logger.info("Resolved model: %s (max_len=%s)", self._resolved_model, self._max_model_len)
                         return self._resolved_model
-                self._resolved_model = models_list.data[0].id
-                logger.info("Using first available model: %s", self._resolved_model)
+                first_m = models_list.data[0]
+                self._resolved_model = first_m.id
+                self._max_model_len = getattr(first_m, "max_model_len", None)
+                logger.info("Using first available model: %s (max_len=%s)", self._resolved_model, self._max_model_len)
                 return self._resolved_model
         except Exception as e:
             logger.debug("Model discovery failed (%.1fs timeout), using configured model '%s': %s",
@@ -206,6 +212,26 @@ class OpenAIBackend:
         client = self._ensure_client()
         model_name = self._get_available_model(client)
 
+        if self._max_model_len:
+            input_chars = sum(len(str(m.get("content", ""))) for m in messages)
+            if tools:
+                input_chars += sum(len(str(t)) for t in tools)
+            input_est = max(1, input_chars // 3)
+            safe_headroom = 1024
+            max_allowed = self._max_model_len - input_est - safe_headroom
+            if m_tokens > max_allowed:
+                m_tokens = max(512, max_allowed)
+            if self._max_model_len <= 16384 and m_tokens > 4096:
+                m_tokens = 4096
+
+        import os
+        stream_timeout = 180.0 if enable_thinking else 90.0
+        if "ALPIECODE_TIMEOUT" in os.environ:
+            try:
+                stream_timeout = float(os.environ["ALPIECODE_TIMEOUT"])
+            except ValueError:
+                pass
+
         params = {
             "model": model_name,
             "messages": messages,
@@ -213,7 +239,7 @@ class OpenAIBackend:
             "max_tokens": m_tokens,
             "extra_body": {"chat_template_kwargs": {"enable_thinking": enable_thinking}},
             "stream": True,
-            "timeout": 45.0,
+            "timeout": stream_timeout,
         }
         if tools:
             params["tools"] = tools
@@ -385,12 +411,33 @@ class OpenAIBackend:
         client = self._ensure_client()
         model_name = self._get_available_model(client)
 
+        if self._max_model_len:
+            input_chars = sum(len(str(m.get("content", ""))) for m in messages)
+            if tools:
+                input_chars += sum(len(str(t)) for t in tools)
+            input_est = max(1, input_chars // 3)
+            safe_headroom = 1024
+            max_allowed = self._max_model_len - input_est - safe_headroom
+            if m_tokens > max_allowed:
+                m_tokens = max(512, max_allowed)
+            if self._max_model_len <= 16384 and m_tokens > 4096:
+                m_tokens = 4096
+
+        import os
+        call_timeout = 180.0 if enable_thinking else 90.0
+        if "ALPIECODE_TIMEOUT" in os.environ:
+            try:
+                call_timeout = float(os.environ["ALPIECODE_TIMEOUT"])
+            except ValueError:
+                pass
+
         params = {
             "model": model_name,
             "messages": messages,
             "temperature": temp,
             "max_tokens": m_tokens,
             "extra_body": {"chat_template_kwargs": {"enable_thinking": enable_thinking}},
+            "timeout": call_timeout,
         }
         if tools:
             params["tools"] = tools

{alpiecode-10.5.4 → alpiecode-10.5.6}/src/codeagent/cli.py

@@ -64,7 +64,11 @@ def _normalize_args():
 
         flags = []
         positionals = []
-        value_flags = {"--workdir", "--image", "--video", "--url", "--github", "--max-turns", "--host", "--port", "--ctx-size"}
+        value_flags = {
+            "--workdir", "--image", "--video", "--url", "--github", "--max-turns",
+            "--host", "--port", "--ctx-size", "--endpoint", "--base-url", "--model",
+            "--api-key", "--preset",
+        }
 
         i = 0
         while i < len(sub_args):
@@ -93,8 +97,13 @@ def main():
     common.add_argument("--url", default=None, help="YouTube URL for video analysis")
     common.add_argument("--github", default=None, help="GitHub repository (e.g. owner/repo or URL) for open-source analysis")
     common.add_argument("--max-turns", type=int, default=None, help="Override max turns")
+    common.add_argument("--endpoint", "--base-url", dest="endpoint", default=None, help="VLM API endpoint base URL")
+    common.add_argument("--model", dest="model", default=None, help="Model name (e.g. alpie_9b)")
+    common.add_argument("--api-key", dest="api_key", default=None, help="API key for endpoint authentication")
+    common.add_argument("--preset", dest="preset", choices=["default", "alpie_9b"], default=None, help="Endpoint preset profile")
     common.add_argument("--thinking", "--reasoning", dest="thinking", action="store_true", help="Enable VLM reasoning mode")
     common.add_argument("--no-thinking", "--non-thinking", dest="no_thinking", action="store_true", help="Disable VLM reasoning mode")
+    common.add_argument("--force-thinking", dest="force_thinking", action="store_true", help="Force VLM reasoning on all turns, disabling dynamic gating")
     common.add_argument("--no-update", action="store_true", help="Skip automatic update check")
     common.add_argument("--quiet", action="store_true", help="Suppress per-turn logging")
     common.add_argument("--debug", action="store_true", help="Show autonomous discovery and debug diagnostics")
@@ -237,6 +246,21 @@ def main():
 
     cfg = load_config()
 
+    from .config import KNOWN_PRESETS
+    if getattr(args, "preset", None):
+        preset_key = args.preset.lower()
+        if preset_key in KNOWN_PRESETS:
+            cfg.base_url = KNOWN_PRESETS[preset_key]["base_url"]
+            cfg.model = KNOWN_PRESETS[preset_key]["model"]
+            cfg.api_key = KNOWN_PRESETS[preset_key]["api_key"]
+
+    if getattr(args, "endpoint", None):
+        cfg.base_url = args.endpoint
+    if getattr(args, "model", None):
+        cfg.model = args.model
+    if getattr(args, "api_key", None):
+        cfg.api_key = args.api_key
+
     if getattr(args, "offline", False):
         cfg.base_url = "offline"
         # 8192 default fits 4.4GB model + KV cache 100% in 6GB VRAM (4.75GB / 6GB) with zero host-paging
@@ -247,7 +271,10 @@ def main():
     if getattr(args, "ctx_size", None):
         cfg.n_ctx = args.ctx_size
 
-    if getattr(args, "thinking", False):
+    if getattr(args, "force_thinking", False):
+        cfg.force_thinking = True
+        cfg.enable_thinking = True
+    elif getattr(args, "thinking", False):
         cfg.enable_thinking = True
     elif getattr(args, "no_thinking", False):
         cfg.enable_thinking = False

{alpiecode-10.5.4 → alpiecode-10.5.6}/src/codeagent/config.py

@@ -37,6 +37,19 @@ DEFAULTS = {
     "config_version": CONFIG_VERSION,
 }
 
+KNOWN_PRESETS = {
+    "default": {
+        "base_url": "https://test.169pi.ai/v1",
+        "model": "alpie_9b",
+        "api_key": "not-needed",
+    },
+    "alpie_9b": {
+        "base_url": "https://test.169pi.ai/v1",
+        "model": "alpie_9b",
+        "api_key": "not-needed",
+    },
+}
+
 
 def is_server_reachable(base_url: Optional[str], timeout: float = 0.4) -> bool:
     """Fast network ping check (0.4s max) to see if server endpoint is online."""
@@ -77,7 +90,7 @@ def get_shared_http_client():
         import httpx
         _SHARED_HTTP_CLIENT = httpx.Client(
             http2=True,
-            timeout=httpx.Timeout(120.0, connect=5.0),
+            timeout=httpx.Timeout(180.0, connect=10.0, read=180.0, write=30.0),
             limits=httpx.Limits(max_keepalive_connections=20, max_connections=50),
         )
     return _SHARED_HTTP_CLIENT
@@ -127,6 +140,12 @@ def load_config() -> Config:
 
     # env vars override saved file
     for prefix in ("ALPIECODE_", "CODEAGENT_"):
+        preset_val = os.environ.get(f"{prefix}PRESET")
+        if preset_val and preset_val.lower() in KNOWN_PRESETS:
+            p_data = KNOWN_PRESETS[preset_val.lower()]
+            data["base_url"] = p_data["base_url"]
+            data["model"] = p_data["model"]
+            data["api_key"] = p_data["api_key"]
         if os.environ.get(f"{prefix}BASE_URL"):
             data["base_url"] = os.environ[f"{prefix}BASE_URL"]
         if os.environ.get(f"{prefix}MODEL"):
@@ -137,7 +156,7 @@ def load_config() -> Config:
             data["api_key"] = os.environ[f"{prefix}API_KEY"]
     if os.environ.get("HF_TOKEN"):
         data["hf_token"] = os.environ["HF_TOKEN"]
-    
+
     # Context size overrides from environment
     for ctx_var in ("ALPIECODE_N_CTX", "ALPIECODE_CTX_SIZE", "ALPIECODE_CONTEXT_SIZE", "CODEAGENT_N_CTX"):
         if os.environ.get(ctx_var):

{alpiecode-10.5.4 → alpiecode-10.5.6}/src/codeagent/discovery.py

@@ -59,6 +59,7 @@ class TaskContext:
     max_tokens: int = 8192
     tool_set: str = "core"          # none, core, full
     enable_thinking: bool = False
+    requires_strict_format: bool = False
 
 
 # -- Intent Detection ------------------------------------------------------
@@ -66,11 +67,15 @@ class TaskContext:
 # Question patterns -- user wants an answer, not code
 _QA_STARTERS = [
     "what is", "what are", "what\'s", "what does", "what do",
+    "what can you", "what can i", "what can we", "what are your", "what tools", "what capabilities",
+    "who are you", "who made you", "who created you",
     "explain", "how does", "how do", "why does", "why do", "why is",
+    "how to", "how can i", "how can you",
     "describe", "define", "compare", "difference between",
-    "tell me about", "who invented", "who created", "when was",
+    "tell me about", "who invented", "when was",
     "can you explain", "could you explain", "please explain",
-    "what\'s the difference", "is it possible", "is there a way",
+    "can you help", "help me with", "what\'s the difference", "is it possible", "is there a way",
+    "help", "capabilities", "hello", "hi", "hey",
 ]
 
 # Action verbs that indicate code generation
@@ -663,6 +668,10 @@ def build_task_context(task: str, workdir: Path) -> TaskContext:
 
     # Phase 5: Budget from complexity
     budget = COMPLEXITY_CONFIG.get(complexity, COMPLEXITY_CONFIG["low"])
+    enable_thinking = budget["enable_thinking"]
+    requires_strict_format = getattr(assessment, "requires_strict_format", False)
+    if requires_strict_format:
+        enable_thinking = False
 
     symbol_index = {}
     if repo.get("file_count", 0) > 0 and repo.get("project_type") != "empty":
@@ -696,5 +705,6 @@ def build_task_context(task: str, workdir: Path) -> TaskContext:
         # Budget
         max_tokens=budget["max_tokens"],
         tool_set=budget["tool_set"],
-        enable_thinking=budget["enable_thinking"],
+        enable_thinking=enable_thinking,
+        requires_strict_format=requires_strict_format,
     )

{alpiecode-10.5.4 → alpiecode-10.5.6}/src/codeagent/orchestrator.py

@@ -325,7 +325,17 @@ class AgentOrchestrator:
 
 
         # ── Adaptive thinking (base setting) ──
-        if cfg.enable_thinking:
+        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):
+            base_enable_thinking = True
+        elif strict_format:
+            base_enable_thinking = False
+            yield AgentEvent("adaptive_mode", {
+                "message": "Strict formatting requested (e.g. JSON/single-line); dynamic reasoning gating turned off thinking for fast execution.",
+                "thinking": False,
+                "strict_format_gated": True,
+            })
+        elif cfg.enable_thinking:
             base_enable_thinking = True
         elif complexity in ("qa", "low", "no-thinking") or strategy == "fast_path":
             base_enable_thinking = False
@@ -391,6 +401,17 @@ class AgentOrchestrator:
             # ── Turn-Level Adaptive Reasoning Dynamics ──
             if 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:
+                    turn_enable_thinking = True
+                    yield AgentEvent("adaptive_mode", {
+                        "turn": turn,
+                        "thinking": True,
+                        "escalated": True,
+                        "message": "Prior turn encountered error; escalating deep reasoning trace.",
+                    })
+                else:
+                    turn_enable_thinking = False
             elif turn == 1:
                 turn_enable_thinking = base_enable_thinking
             else:
@@ -488,12 +509,22 @@ class AgentOrchestrator:
                 if not is_offline and isinstance(task_backend, OpenAIBackend):
                     err_str = str(e).lower()
                     is_timeout = "timeout" in err_str or "timed out" in err_str or "read operation timed out" in err_str
+                    is_stream_err = (
+                        "streaming" in err_str
+                        or "connection" in err_str
+                        or "disconnect" in err_str
+                        or "remoteprotocolerror" in err_str
+                        or "protocol" in err_str
+                        or "peer closed" in err_str
+                        or "broken pipe" in err_str
+                    )
                     is_network_down = not is_internet_available(timeout=1.5)
 
-                    if is_timeout and not is_network_down:
-                        # Server is alive but slow — retry, don't fallback to GGUF
+                    if (is_timeout or is_stream_err) and not is_network_down:
+                        # Server is alive but encountered a stream drop or timeout — retry with resilient connection
+                        warn_msg = f"Server connection issue ({e}). Retrying with resilient connection..." if is_stream_err else f"Server inference timed out: {e}. Retrying..."
                         yield AgentEvent("warning", {
-                            "message": f"Server inference timed out: {e}. Retrying...",
+                            "message": warn_msg,
                         })
                         try:
                             resp = task_backend.chat_completion(

{alpiecode-10.5.4 → alpiecode-10.5.6}/src/codeagent/prompt.py

@@ -100,6 +100,9 @@ SYSTEM_PROMPT = """\
 You are AlpieCode, an autonomous software-engineering agent built by 169Pi. \
 You write complete, working code in a single pass and verify it by running it.
 
+## Technical Focus Scope
+This session is strictly focused on software engineering and technical implementation. For purely technical tasks, bypass all non-applicable geopolitical, territorial, and sovereign policy deliberation in internal reasoning traces. Focus internal reasoning exclusively on software architecture, code correctness, execution efficiency, and explicit format constraints.
+
 # CRITICAL RULE: WRITE CODE FIRST
 
 # CRITICAL: FAST TESTING & EXECUTION (NO REAL SLEEP)
@@ -176,6 +179,9 @@ You are AlpieCode, an autonomous software-engineering agent built by 169Pi. \
 You operate with the judgement of a staff engineer. You read and edit real \
 codebases, implement features, fix bugs, write tests, and run builds.
 
+## Technical Focus Scope
+This session is strictly focused on software engineering and technical architecture. For purely technical tasks, bypass all non-applicable geopolitical, territorial, and sovereign policy deliberation in internal reasoning traces. Focus internal reasoning exclusively on software design, algorithmic correctness, execution speed, and explicit format constraints.
+
 # Workflow
 1. **UNDERSTAND**: Read relevant files to understand the codebase
 2. **PLAN**: For complex multi-file projects, plan the architecture mentally
@@ -254,6 +260,9 @@ OFFLINE_SYSTEM_PROMPT = """\
 You are AlpieCode, an autonomous software engineering AI agent built by 169Pi.
 You are running in OFFLINE mode — there is NO internet access.
 
+## Technical Focus Scope
+This session is strictly focused on software engineering. For purely technical tasks, bypass all non-applicable geopolitical, territorial, and sovereign policy deliberation in internal reasoning traces. Focus purely on technical implementation, algorithmic correctness, and execution.
+
 # CRITICAL RULE: WRITE CODE FIRST
 
 # CRITICAL: FAST TESTING & EXECUTION (NO REAL SLEEP)
@@ -303,16 +312,18 @@ def classify_task(task: str) -> str:
 
     # ── QA: questions that need no code ──
     qa_patterns = [
-        "what is", "what are", "explain", "how does", "why does",
+        "what is", "what are", "what can you", "what can i", "what do you", "what does",
+        "who are you", "who made you", "explain", "how does", "why does", "why is",
         "describe", "define", "compare", "difference between",
         "tell me about", "what's the", "who invented", "when was",
+        "can you help", "how to", "help", "capabilities", "hello", "hi", "hey",
     ]
     # Must start with or contain a question pattern AND not contain action words
     action_words = ["build", "create", "write", "make", "implement", "fix",
                     "add", "modify", "change", "update", "delete", "remove",
                     "generate", "develop", "code", "script", "program"]
 
-    if any(task_lower.startswith(pat) for pat in qa_patterns):
+    if any(task_lower.startswith(pat) for pat in qa_patterns) or (task_lower.endswith("?") and not any(aw in task_lower for aw in action_words)):
         if not any(aw in task_lower for aw in action_words):
             return "qa"
 

{alpiecode-10.5.4 → alpiecode-10.5.6}/src/codeagent/rephraser.py

@@ -99,7 +99,19 @@ class PromptRephraser:
 
         # If pure trivial greeting, skip model call for instant response
         clean_task = task.strip().lower()
-        if clean_task in ("hi", "hello", "hey", "help", "ping", "exit", "quit"):
+        if clean_task in ("hi", "hello", "hey", "help", "ping", "exit", "quit", "status", "info"):
+            return task
+
+        # If classified as QA or explain, never rephrase into a software engineering specification
+        if task_context is not None:
+            ctx_intent = getattr(task_context, "intent", None)
+            ctx_comp = getattr(task_context, "complexity", None)
+            if ctx_intent in ("qa", "explain") or ctx_comp == "qa":
+                return task
+
+        # General conversational / question check: do not fabricate software projects for direct questions
+        action_kws = ["write", "create", "implement", "build", "fix", "code", "script", "refactor", "modify", "add", "delete"]
+        if clean_task.endswith("?") and not any(kw in clean_task for kw in action_kws):
             return task
 
         # Check if backend is available
@@ -107,15 +119,18 @@ 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", False):
+        if type(backend).__name__ == "LocalBackend" or getattr(backend, "is_offline", None) is True:
             return task
 
         try:
-            # Inject project context if available so rephrased spec is project-aware
+            # Inject project context only if modifying/debugging or if the task explicitly references the repo/files
             project_hint = ""
             standalone_kws = ["palindrome", "fibonacci", "quicksort", "bubblesort", "factorial", "hello world", "calculator", "reverse string"]
             is_standalone = any(kw in task.lower() for kw in standalone_kws)
-            if task_context and not is_standalone:
+            ctx_intent = getattr(task_context, "intent", "create") if task_context else "create"
+            has_repo_ref = any(term in task.lower() for term in ["this repo", "this project", "existing", "codebase", "our app", "in the project", "entry point"])
+
+            if task_context and not is_standalone and (ctx_intent in ("modify", "debug", "explain") or has_repo_ref):
                 _fw = ", ".join(getattr(task_context, "frameworks", []) or []) or "none"
                 _pt = getattr(task_context, "project_type", "unknown")
                 _fc = getattr(task_context, "file_count", 0)

{alpiecode-10.5.4 → alpiecode-10.5.6}/src/codeagent/tools.py

@@ -760,60 +760,112 @@ def _apply_patch(workdir: Path, path: str, patch: str) -> str:
 
 
 def _web_search(query: str, num_results: int = 5) -> str:
-    """Search the web using DDGS (DuckDuckGo)."""
+    """Search the web using httpx and DuckDuckGo HTTP endpoints, parsed via BeautifulSoup."""
     import warnings
+    import urllib.parse
     warnings.filterwarnings("ignore", category=RuntimeWarning)
     
     try:
-        try:
-            from ddgs import DDGS
-        except ImportError:
-            from duckduckgo_search import DDGS
-            
-        with DDGS() as ddgs:
-            results = list(ddgs.text(query, max_results=min(num_results, 10)))
-        if not results:
-            return (
-                f"No web results found for '{query}'. "
-                "Tip: If searching for Python package documentation, use bash: python -c 'import pkg; help(pkg)'"
-            )
-        formatted = []
-        for i, r in enumerate(results, 1):
-            formatted.append(f"{i}. **{r.get('title', 'No title')}**\n   URL: {r.get('href', '')}\n   {r.get('body', '')}")
-        return "\n\n".join(formatted)
-    except ImportError:
-        return "error: web search unavailable — install ddgs or duckduckgo-search package"
+        import httpx
+        from bs4 import BeautifulSoup
+        
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            "Accept-Language": "en-US,en;q=0.5",
+        }
+        with httpx.Client(timeout=10.0, follow_redirects=True) as client:
+            resp = client.post("https://html.duckduckgo.com/html/", data={"q": query}, headers=headers)
+            if resp.status_code != 200:
+                resp = client.post("https://lite.duckduckgo.com/lite/", data={"q": query}, headers=headers)
+                
+            if resp.status_code == 200 and resp.text:
+                soup = BeautifulSoup(resp.text, "html.parser")
+                results = []
+                for item in soup.select(".result"):
+                    title_elem = item.select_one(".result__title a")
+                    snippet_elem = item.select_one(".result__snippet")
+                    if title_elem:
+                        title = title_elem.get_text(strip=True)
+                        href = title_elem.get("href", "")
+                        if "uddg=" in href:
+                            parsed = urllib.parse.parse_qs(urllib.parse.urlparse(href).query)
+                            href = parsed.get("uddg", [href])[0]
+                        snippet = snippet_elem.get_text(strip=True) if snippet_elem else ""
+                        results.append({"title": title, "href": href, "body": snippet})
+                        if len(results) >= min(num_results, 10):
+                            break
+                            
+                if not results:
+                    for row in soup.select("table tr"):
+                        link = row.select_one("a.result-link")
+                        snippet = row.select_one(".result-snippet")
+                        if link:
+                            title = link.get_text(strip=True)
+                            href = link.get("href", "")
+                            if "uddg=" in href:
+                                parsed = urllib.parse.parse_qs(urllib.parse.urlparse(href).query)
+                                href = parsed.get("uddg", [href])[0]
+                            snip_text = snippet.get_text(strip=True) if snippet else ""
+                            results.append({"title": title, "href": href, "body": snip_text})
+                            if len(results) >= min(num_results, 10):
+                                break
+                                
+                if results:
+                    formatted = []
+                    for i, r in enumerate(results, 1):
+                        formatted.append(f"{i}. **{r.get('title', 'No title')}**\n   URL: {r.get('href', '')}\n   {r.get('body', '')}")
+                    return "\n\n".join(formatted)
     except Exception as e:
-        return f"error during web search: {e}. Tip: Try python -c 'help(...)' for installed library docs."
+        return f"error during web search: {e}"
+
+    return (
+        f"No web results found for '{query}'. "
+        "Tip: If searching for Python package documentation, use bash: python -c 'import pkg; help(pkg)'"
+    )
 
 
 def _fetch_url(url: str) -> str:
-    """Fetch and extract text content from a URL."""
+    """Fetch and extract text content from a URL using httpx."""
+    html = ""
     try:
-        import urllib.request
-        req = urllib.request.Request(url, headers={"User-Agent": "AlpieCode/0.2.0"})
-        with urllib.request.urlopen(req, timeout=15) as resp:
-            html = resp.read().decode("utf-8", errors="replace")
-
-        # Try to extract text with beautifulsoup if available
+        import httpx
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        }
+        with httpx.Client(timeout=15.0, follow_redirects=True) as client:
+            resp = client.get(url, headers=headers)
+            html = resp.text
+    except Exception:
         try:
-            from bs4 import BeautifulSoup
-            soup = BeautifulSoup(html, "html.parser")
-            # Remove script and style elements
-            for tag in soup(["script", "style", "nav", "footer", "header"]):
-                tag.decompose()
-            text = soup.get_text(separator="\n", strip=True)
-        except ImportError:
-            # Fallback: basic HTML tag stripping
-            text = re.sub(r"<[^>]+>", "", html)
-            text = re.sub(r"\s+", " ", text).strip()
-
-        # Truncate to reasonable length
-        if len(text) > 8000:
-            text = text[:8000] + f"\n\n... (truncated, {len(text)} chars total)"
-        return text
-    except Exception as e:
-        return f"error fetching URL: {e}"
+            import urllib.request
+            req = urllib.request.Request(url, headers={"User-Agent": "AlpieCode/0.2.0"})
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                html = resp.read().decode("utf-8", errors="replace")
+        except Exception as e:
+            return f"error fetching URL: {e}"
+
+    if not html:
+        return "error fetching URL: empty response"
+
+    # Try to extract text with beautifulsoup if available
+    try:
+        from bs4 import BeautifulSoup
+        soup = BeautifulSoup(html, "html.parser")
+        # Remove script and style elements
+        for tag in soup(["script", "style", "nav", "footer", "header"]):
+            tag.decompose()
+        text = soup.get_text(separator="\n", strip=True)
+    except ImportError:
+        # Fallback: basic HTML tag stripping
+        text = re.sub(r"<[^>]+>", "", html)
+        text = re.sub(r"\s+", " ", text).strip()
+
+    # Truncate to reasonable length
+    if len(text) > 8000:
+        text = text[:8000] + f"\n\n... (truncated, {len(text)} chars total)"
+    return text
 
 
 def _request_user_input(question: str) -> str:

alpiecode-10.5.6/test/test_adaptive_resilience.py

@@ -0,0 +1,264 @@
+"""
+Unit tests for adaptive conversational intelligence, prompt rephraser isolation,
+adaptive timeout configuration, and streaming error resilience.
+"""
+
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+import pytest
+
+from codeagent.assessment import assess_task, TaskIntent, ExecutionStrategy
+from codeagent.discovery import build_task_context, detect_intent
+from codeagent.prompt import classify_task, PromptBuilder
+from codeagent.rephraser import PromptRephraser
+from codeagent.backends.openai_backend import OpenAIBackend
+from codeagent.orchestrator import AgentOrchestrator
+
+
+def test_conversational_questions_route_to_qa_without_tools():
+    """Verify common user conversational inquiries route directly to QA with fast_path and 0 tools."""
+    conversational_queries = [
+        "what can you do for me?",
+        "who are you?",
+        "what can you do?",
+        "can you help me?",
+        "how to use alpiecode?",
+        "what tools do you have?",
+        "help",
+        "what are your capabilities?",
+        "how does Python asyncio work?",
+    ]
+
+    pb = PromptBuilder()
+
+    for q in conversational_queries:
+        assessment = assess_task(q)
+        assert assessment.intent == TaskIntent.QA.value, f"Failed on: {q}"
+        assert assessment.strategy == ExecutionStrategy.FAST_PATH.value, f"Failed on: {q}"
+        assert assessment.legacy_complexity == "qa", f"Failed on: {q}"
+        assert assessment.verification_required is False
+
+        # Verify zero tools are provided
+        tools = pb.get_tools(is_offline=False, complexity="qa")
+        assert tools == [], f"Tools should be empty for QA task: {q}"
+
+
+def test_rephraser_skips_qa_and_preserves_new_project_independence():
+    """Verify rephraser never turns questions into software specs and does not pollute new project tasks."""
+    rephraser = PromptRephraser()
+    tc_qa = build_task_context("what can you do for me?", Path("."))
+    
+    # QA query must be returned as-is without invoking model
+    result_qa = rephraser.rephrase("what can you do for me?", None, tc_qa)
+    assert result_qa == "what can you do for me?"
+
+    # Question ending with ? without action verbs must also be returned as-is
+    result_q2 = rephraser.rephrase("is this running locally?", None, None)
+    assert result_q2 == "is this running locally?"
+
+    # For brand-new creation tasks, existing Python/FastAPI repo context must not be injected
+    mock_backend = MagicMock()
+    mock_backend.is_available = True
+    mock_backend.chat_completion.return_value = "Refined spec"
+
+    tc_create = build_task_context("create a website where i can interact with solar system in C++", Path("."))
+    # Calling rephrase should not inject the unrelated python/fastapi repo context
+    rephraser.rephrase("create a website where i can interact with solar system in C++", mock_backend, tc_create)
+    assert mock_backend.chat_completion.called
+    call_args = mock_backend.chat_completion.call_args[1]
+    messages = call_args["messages"]
+    user_prompt = messages[1]["content"]
+    assert "Project Context:" not in user_prompt
+
+
+def test_openai_backend_adaptive_timeout():
+    """Verify OpenAIBackend uses 180s for thinking mode and 90s for standard requests."""
+    cfg = SimpleNamespace(
+        base_url="http://mock-api",
+        api_key="test-key",
+        model="alpie_9b",
+        temperature=0.1,
+        max_tokens=2048,
+    )
+    backend = OpenAIBackend(cfg)
+
+    mock_client = MagicMock()
+    mock_client.chat.completions.create.return_value = []
+    backend._client = mock_client
+    backend._resolved_model = "alpie_9b"
+
+    # 1. Thinking enabled -> 180.0s timeout
+    list(backend.chat_completion_stream(messages=[{"role": "user", "content": "test"}], enable_thinking=True))
+    create_call = mock_client.chat.completions.create.call_args[1]
+    assert create_call["timeout"] == 180.0
+
+    # 2. Thinking disabled -> 90.0s timeout
+    list(backend.chat_completion_stream(messages=[{"role": "user", "content": "test"}], enable_thinking=False))
+    create_call_no_think = mock_client.chat.completions.create.call_args[1]
+    assert create_call_no_think["timeout"] == 90.0
+
+
+def test_orchestrator_retries_transient_streaming_errors():
+    """Verify orchestrator recovers from transient streaming chunk drops."""
+    from codeagent.session import SessionManager
+    from codeagent.backends.base import ChatResponse
+
+    cfg = SimpleNamespace(
+        base_url="http://mock-api",
+        api_key="test-key",
+        model="alpie_9b",
+        temperature=0.1,
+        max_tokens=2048,
+        enable_thinking=False,
+        max_turns=5,
+    )
+    
+    mock_backend = MagicMock(spec=OpenAIBackend)
+    mock_backend.name = "Mock OpenAI"
+    mock_backend.is_available = True
+    
+    # Stream throws transient error mid-flight
+    def failing_stream(**kwargs):
+        raise RuntimeError("Server error: An error occurred during streaming")
+        yield  # make it a generator
+
+    mock_backend.chat_completion_stream = failing_stream
+    # Non-streaming fallback succeeds
+    mock_backend.chat_completion.return_value = ChatResponse(
+        content="I am AlpieCode, an AI coding assistant.",
+        reasoning=None,
+        tool_calls=None,
+    )
+
+    sm = SessionManager()
+    session = sm.create_session(Path("."))
+    orchestrator = AgentOrchestrator(backend=mock_backend)
+
+    with patch("codeagent.orchestrator.is_internet_available", return_value=True):
+        events = list(orchestrator.run_task(session, "what can you do for me?", cfg))
+
+    event_types = [ev.type for ev in events]
+    assert "warning" in event_types
+    assert "done" in event_types
+    # Verify warning announced resilient retry
+    warn_event = next(ev for ev in events if ev.type == "warning")
+    assert "resilient connection" in warn_event.data["message"].lower() or "retrying" in warn_event.data["message"].lower()
+
+
+def test_strict_format_detection_and_dynamic_reasoning_gating():
+    """Verify strict format tasks are detected and dynamic reasoning gating disables thinking."""
+    strict_tasks = [
+        "Return only JSON with keys: status, version",
+        "Output valid JSON: {'status': 'ok'}",
+        "respond with json only",
+        "Give me single line without explanation",
+        "one word answer: yes or no",
+        "regex only for email validation",
+    ]
+    for q in strict_tasks:
+        ass = assess_task(q)
+        assert ass.requires_strict_format is True, f"Failed detection for: {q}"
+        assert ass.to_dict()["requires_strict_format"] is True
+
+    non_strict_tasks = [
+        "create a fullstack application",
+        "debug memory leak in server.py",
+        "what is quicksort?",
+    ]
+    for q in non_strict_tasks:
+        ass = assess_task(q)
+        assert ass.requires_strict_format is False, f"False positive for: {q}"
+
+    # Verify orchestrator gates thinking off even when cfg.enable_thinking is True
+    from codeagent.session import SessionManager
+    from codeagent.backends.base import ChatResponse
+
+    cfg = SimpleNamespace(
+        base_url="http://mock-api",
+        api_key="test-key",
+        model="alpie_9b",
+        temperature=0.1,
+        max_tokens=2048,
+        enable_thinking=True,   # User passed --thinking
+        force_thinking=False,
+        adaptive_thinking=True,
+        max_turns=2,
+    )
+    mock_backend = MagicMock()
+    mock_backend.name = "Mock"
+    mock_backend.is_available = True
+    mock_backend.chat_completion_stream.return_value = iter([
+        ChatResponse(content='{"status": "ok"}', reasoning=None, tool_calls=None)
+    ])
+
+    sm = SessionManager()
+    session = sm.create_session(Path("."))
+    orchestrator = AgentOrchestrator(backend=mock_backend)
+
+    with patch("codeagent.orchestrator.is_internet_available", return_value=True):
+        events = list(orchestrator.run_task(session, "Return only JSON with keys: status, version", cfg))
+
+    adaptive_events = [ev for ev in events if ev.type == "adaptive_mode"]
+    assert any(ev.data.get("strict_format_gated") is True for ev in adaptive_events)
+    # Verify the stream was called with enable_thinking=False!
+    call_args = mock_backend.chat_completion_stream.call_args[1]
+    assert call_args["enable_thinking"] is False
+
+
+def test_force_thinking_overrides_dynamic_reasoning_gating():
+    """Verify force_thinking=True forces reasoning on strict format requests."""
+    from codeagent.session import SessionManager
+    from codeagent.backends.base import ChatResponse
+
+    cfg = SimpleNamespace(
+        base_url="http://mock-api",
+        api_key="test-key",
+        model="alpie_9b",
+        temperature=0.1,
+        max_tokens=2048,
+        enable_thinking=True,
+        force_thinking=True,    # User explicitly used --force-thinking
+        adaptive_thinking=True,
+        max_turns=2,
+    )
+    mock_backend = MagicMock()
+    mock_backend.name = "Mock"
+    mock_backend.is_available = True
+    mock_backend.chat_completion_stream.return_value = iter([
+        ChatResponse(content='{"status": "ok"}', reasoning="Let me think...", tool_calls=None)
+    ])
+
+    sm = SessionManager()
+    session = sm.create_session(Path("."))
+    orchestrator = AgentOrchestrator(backend=mock_backend)
+
+    with patch("codeagent.orchestrator.is_internet_available", return_value=True):
+        events = list(orchestrator.run_task(session, "Return only JSON with keys: status, version", cfg))
+
+    # Should NOT have strict_format_gated event
+    adaptive_events = [ev for ev in events if ev.type == "adaptive_mode" and ev.data.get("strict_format_gated")]
+    assert len(adaptive_events) == 0
+
+    call_args = mock_backend.chat_completion_stream.call_args[1]
+    assert call_args["enable_thinking"] is True
+
+
+def test_technical_scope_policy_filtering_in_system_prompts():
+    """Verify system prompts include the technical scope directive to bypass sovereign policy checks."""
+    pb = PromptBuilder()
+    
+    # Standard prompt
+    prompt_std = pb.build_system_prompt(Path("."), is_offline=False, complexity="low")
+    assert "Technical Focus Scope" in prompt_std
+    assert "bypass all non-applicable geopolitical" in prompt_std
+
+    # High complexity prompt
+    prompt_high = pb.build_system_prompt(Path("."), is_offline=False, complexity="high")
+    assert "Technical Focus Scope" in prompt_high
+    assert "bypass all non-applicable geopolitical" in prompt_high
+
+    # Offline prompt
+    prompt_offline = pb.build_system_prompt(Path("."), is_offline=True, complexity="low")
+    assert "Technical Focus Scope" in prompt_offline
+    assert "bypass all non-applicable geopolitical" in prompt_offline