alpiecode 7.0.6__tar.gz → 8.0.0__tar.gz

{alpiecode-7.0.6 → alpiecode-8.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 7.0.6
+Version: 8.0.0
 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-7.0.6 → alpiecode-8.0.0}/pyproject.toml

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

{alpiecode-7.0.6 → alpiecode-8.0.0}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 7.0.6
+Version: 8.0.0
 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-7.0.6 → alpiecode-8.0.0}/src/codeagent/__init__.py

@@ -16,7 +16,7 @@ Supports:
 from pathlib import Path
 from typing import Optional, Any, Dict
 
-__version__ = "7.0.5"
+__version__ = "7.0.7"
 
 
 def run(task: str, workdir: str = ".", reasoning_level: str = "thinking", **kwargs):

{alpiecode-7.0.6 → alpiecode-8.0.0}/src/codeagent/backends/openai_backend.py

@@ -55,6 +55,140 @@ class OpenAIBackend:
             pass
         return self._cfg.model
 
+    def chat_completion_stream(
+        self,
+        messages: List[dict],
+        tools: Optional[List[dict]] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        enable_thinking: bool = True,
+    ):
+        """
+        True real-time SSE streaming completion yielding progressive thinking deltas,
+        duration, content tokens, and final ChatResponse.
+        """
+        import time
+        import json
+        start_time = time.time()
+        temp = temperature if temperature is not None else getattr(self._cfg, "temperature", 0.1)
+        m_tokens = max_tokens if max_tokens is not None else getattr(self._cfg, "max_tokens", 8192)
+
+        client = self._ensure_client()
+        model_name = self._get_available_model(client)
+
+        params = {
+            "model": model_name,
+            "messages": messages,
+            "temperature": temp,
+            "max_tokens": m_tokens,
+            "extra_body": {"chat_template_kwargs": {"enable_thinking": enable_thinking}},
+            "stream": True,
+        }
+        if tools:
+            params["tools"] = tools
+            params["tool_choice"] = "auto"
+
+        try:
+            response = client.chat.completions.create(**params)
+        except NotFoundError:
+            self._resolved_model = None
+            model_name = self._get_available_model(client)
+            params["model"] = model_name
+            response = client.chat.completions.create(**params)
+
+        in_think = enable_thinking
+        think_started = False
+        full_content = []
+        full_reasoning = []
+        tool_calls_dict = {}
+
+        for chunk in response:
+            if not chunk.choices:
+                continue
+            delta = chunk.choices[0].delta
+            if not delta:
+                continue
+
+            # Tool call deltas
+            if delta.tool_calls:
+                for tc in delta.tool_calls:
+                    idx = tc.index
+                    if idx not in tool_calls_dict:
+                        tool_calls_dict[idx] = {
+                            "id": tc.id or f"call_{idx}",
+                            "name": tc.function.name if tc.function and tc.function.name else "",
+                            "arguments": ""
+                        }
+                    else:
+                        if tc.id:
+                            tool_calls_dict[idx]["id"] = tc.id
+                        if tc.function and tc.function.name:
+                            tool_calls_dict[idx]["name"] += tc.function.name
+                    if tc.function and tc.function.arguments:
+                        tool_calls_dict[idx]["arguments"] += tc.function.arguments
+
+            # Explicit reasoning field from some models
+            explicit_reasoning = getattr(delta, "reasoning", None) or getattr(delta, "reasoning_content", None)
+            if explicit_reasoning:
+                if not think_started:
+                    think_started = True
+                    yield ("thinking_start", {"time": start_time})
+                full_reasoning.append(explicit_reasoning)
+                yield ("thinking_delta", {"delta": explicit_reasoning})
+
+            # Content deltas (contains <think>...</think> on vLLM/Qwen models)
+            if delta.content:
+                text = delta.content
+                if in_think:
+                    if not think_started:
+                        think_started = True
+                        yield ("thinking_start", {"time": start_time})
+
+                    if "</think>" in text:
+                        before, after = text.split("</think>", 1)
+                        if before:
+                            full_reasoning.append(before)
+                            yield ("thinking_delta", {"delta": before})
+                        in_think = False
+                        elapsed = time.time() - start_time
+                        yield ("thinking_end", {"duration": round(elapsed, 1), "content": "".join(full_reasoning).strip()})
+                        if after.strip():
+                            full_content.append(after)
+                            yield ("token", {"delta": after})
+                    else:
+                        clean_text = text.replace("<think>", "")
+                        full_reasoning.append(clean_text)
+                        yield ("thinking_delta", {"delta": clean_text})
+                else:
+                    full_content.append(text)
+                    yield ("token", {"delta": text})
+
+        # Close thinking if stream ended while still in think block
+        if in_think and think_started:
+            elapsed = time.time() - start_time
+            yield ("thinking_end", {"duration": round(elapsed, 1), "content": "".join(full_reasoning).strip()})
+
+        tool_calls = None
+        if tool_calls_dict:
+            tool_calls = []
+            for idx in sorted(tool_calls_dict.keys()):
+                item = tool_calls_dict[idx]
+                try:
+                    args = json.loads(item["arguments"])
+                except Exception:
+                    args = {}
+                tool_calls.append(ToolCall(id=item["id"], name=item["name"], arguments=args))
+
+        final_content = "".join(full_content).strip()
+        final_reasoning = "".join(full_reasoning).strip() if full_reasoning else None
+
+        yield ("done", ChatResponse(
+            content=final_content,
+            reasoning=final_reasoning,
+            tool_calls=tool_calls,
+            raw=None
+        ))
+
     def chat_completion(
         self,
         messages: List[dict],

{alpiecode-7.0.6 → alpiecode-8.0.0}/src/codeagent/orchestrator.py

@@ -211,13 +211,27 @@ class AgentOrchestrator:
                 else:
                     max_tokens = 2048 if is_offline else effective_max_tokens
 
-                resp = self.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,
-                )
+                if hasattr(self.backend, "chat_completion_stream") and not is_offline:
+                    resp = None
+                    for event_type, data in self.backend.chat_completion_stream(
+                        messages=session.context.messages,
+                        tools=active_tools if active_tools else None,
+                        temperature=cfg.temperature,
+                        max_tokens=max_tokens,
+                        enable_thinking=enable_thinking,
+                    ):
+                        if event_type == "done":
+                            resp = data
+                        else:
+                            yield AgentEvent(event_type, data)
+                else:
+                    resp = self.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 e:
                 # Online error -> fallback to local
                 if not is_offline and isinstance(self.backend, OpenAIBackend):
@@ -241,7 +255,7 @@ class AgentOrchestrator:
                     yield AgentEvent("error", {"error": str(e)})
                     return
 
-            if resp.reasoning:
+            if resp.reasoning and not (hasattr(self.backend, "chat_completion_stream") and not is_offline):
                 yield AgentEvent("thinking", {"content": resp.reasoning})
 
             session.context.add_assistant_response(resp)