alpiecode 9.0.0__tar.gz → 9.0.1__tar.gz

{alpiecode-9.0.0 → alpiecode-9.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 9.0.0
+Version: 9.0.1
 Summary: AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-9.0.0 → alpiecode-9.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "9.0.0"
+version = "9.0.1"
 description = "AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM"
 requires-python = ">=3.9"
 dependencies = [

{alpiecode-9.0.0 → alpiecode-9.0.1}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 9.0.0
+Version: 9.0.1
 Summary: AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-9.0.0 → alpiecode-9.0.1}/src/codeagent/__init__.py

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

{alpiecode-9.0.0 → alpiecode-9.0.1}/src/codeagent/backends/local_backend.py

@@ -43,6 +43,59 @@ class LocalBackend:
         model = self._ensure_model()
         model.load()
 
+    @staticmethod
+    def _sanitize_messages_for_gguf(messages: List[dict]) -> List[dict]:
+        """
+        Sanitize OpenAI-format messages for GGUF Jinja2 chat templates.
+        Fixes 'Can only get item pairs from a mapping' errors by:
+        - Ensuring content is always a string (never None or list)
+        - Stripping tool_calls and tool messages (GGUF templates don't support them)
+        - Removing tool-related role messages
+        """
+        sanitized = []
+        for msg in messages:
+            role = msg.get("role", "")
+            # Skip tool result messages entirely — GGUF models don't understand them
+            if role == "tool":
+                continue
+
+            clean = {"role": role}
+
+            # Ensure content is always a string
+            content = msg.get("content")
+            if content is None:
+                content = ""
+            elif isinstance(content, list):
+                # Multimodal content (image_url + text blocks) — extract text parts
+                text_parts = []
+                for part in content:
+                    if isinstance(part, dict):
+                        if part.get("type") == "text":
+                            text_parts.append(part.get("text", ""))
+                    elif isinstance(part, str):
+                        text_parts.append(part)
+                content = "\n".join(text_parts) if text_parts else ""
+            elif not isinstance(content, str):
+                content = str(content)
+
+            # For assistant messages with tool_calls, embed tool call info in content text
+            if role == "assistant" and msg.get("tool_calls"):
+                tc_descriptions = []
+                for tc in msg["tool_calls"]:
+                    if isinstance(tc, dict):
+                        fn = tc.get("function", {})
+                        name = fn.get("name", "unknown")
+                        args = fn.get("arguments", "{}")
+                        tc_descriptions.append(f"[Called tool: {name}({args})]")
+                if tc_descriptions:
+                    content = (content + "\n" + "\n".join(tc_descriptions)).strip()
+                # Do NOT include tool_calls key — GGUF template will crash on it
+
+            clean["content"] = content
+            sanitized.append(clean)
+
+        return sanitized
+
     def chat_completion(
         self,
         messages: List[dict],
@@ -52,8 +105,9 @@ class LocalBackend:
         enable_thinking: bool = True,
     ) -> ChatResponse:
         model = self._ensure_model()
+        sanitized_msgs = self._sanitize_messages_for_gguf(messages)
         resp = model.create_chat_completion(
-            messages=messages,
+            messages=sanitized_msgs,
             tools=tools,
             tool_choice="auto",
             temperature=temperature,

{alpiecode-9.0.0 → alpiecode-9.0.1}/src/codeagent/orchestrator.py

@@ -46,7 +46,7 @@ from .backends.base import InferenceBackend, ChatResponse
 from .backends.local_backend import LocalBackend
 from .backends.openai_backend import OpenAIBackend
 from .cache import get_cache
-from .config import Config, is_server_reachable
+from .config import Config, is_server_reachable, is_internet_available
 from .memory import extract_and_save_memories
 from .discovery import build_task_context, gather_relevant_context, COMPLEXITY_CONFIG
 from .progress import ProgressMonitor
@@ -285,23 +285,54 @@ class AgentOrchestrator:
                         enable_thinking=enable_thinking,
                     )
             except Exception as e:
-                # Online error -> fallback to local
+                # Online error -> only fallback to local GGUF if internet is genuinely unavailable.
+                # Server timeouts (read timeout, slow inference) should NOT trigger GGUF fallback
+                # because the server IS reachable — it's just slow.
                 if not is_offline and isinstance(task_backend, OpenAIBackend):
-                    yield AgentEvent("fallback", {"error": str(e), "message": "Falling back to local engine"})
-                    task_backend = LocalBackend(cfg)
-                    session.is_offline = True
-                    is_offline = True
-                    active_tools = self.prompt_builder.get_tools(is_offline=True, complexity=complexity)
-                    try:
-                        resp = task_backend.chat_completion(
-                            messages=session.context.messages,
-                            tools=active_tools if active_tools else None,
-                            temperature=cfg.temperature,
-                            max_tokens=2048,
-                            enable_thinking=enable_thinking,
-                        )
-                    except Exception as fallback_err:
-                        yield AgentEvent("error", {"error": str(fallback_err)})
+                    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_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
+                        yield AgentEvent("warning", {
+                            "message": f"Server inference timed out: {e}. Retrying...",
+                        })
+                        try:
+                            resp = task_backend.chat_completion(
+                                messages=session.context.messages,
+                                tools=active_tools if active_tools else None,
+                                temperature=cfg.temperature,
+                                max_tokens=max_tokens,
+                                enable_thinking=enable_thinking,
+                            )
+                        except Exception as retry_err:
+                            yield AgentEvent("error", {
+                                "error": f"Server inference failed after retry: {retry_err}. "
+                                         "The server may be under heavy load. Please try again."
+                            })
+                            return
+                    elif is_network_down:
+                        # Internet genuinely unavailable — fallback to local GGUF
+                        yield AgentEvent("fallback", {"error": str(e), "message": "Internet unavailable. Falling back to local engine"})
+                        task_backend = LocalBackend(cfg)
+                        session.is_offline = True
+                        is_offline = True
+                        active_tools = self.prompt_builder.get_tools(is_offline=True, complexity=complexity)
+                        try:
+                            resp = task_backend.chat_completion(
+                                messages=session.context.messages,
+                                tools=active_tools if active_tools else None,
+                                temperature=cfg.temperature,
+                                max_tokens=2048,
+                                enable_thinking=enable_thinking,
+                            )
+                        except Exception as fallback_err:
+                            yield AgentEvent("error", {"error": str(fallback_err)})
+                            return
+                    else:
+                        # Other API error (400, 500, etc.) — report directly, don't fallback
+                        yield AgentEvent("error", {"error": f"Server error: {e}"})
                         return
                 else:
                     yield AgentEvent("error", {"error": str(e)})

{alpiecode-9.0.0 → alpiecode-9.0.1}/test/test_phase1.py

@@ -119,7 +119,8 @@ def test_bug06_fallback_preserves_orchestrator_backend(tmp_path):
     )
 
     with patch.object(LocalBackend, "__init__", return_value=None), \
-         patch.object(LocalBackend, "chat_completion", return_value=fallback_resp):
+         patch.object(LocalBackend, "chat_completion", return_value=fallback_resp), \
+         patch("codeagent.orchestrator.is_internet_available", return_value=False):
         events = list(orchestrator.run_task(session=session, task="Fallback test", cfg=cfg))
 
     event_types = [e.type for e in events]