neuralnode 2.2.3__tar.gz → 2.2.5__tar.gz

{neuralnode-2.2.3 → neuralnode-2.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuralnode
-Version: 2.2.3
+Version: 2.2.5
 Summary: Comprehensive AI Framework with 50+ LLM Providers, Advanced Agents, Chains, Memory, RAG, and 100+ Tools
 Project-URL: Homepage, https://assem.cloud/
 Project-URL: Documentation, https://neuralnode.readthedocs.io

{neuralnode-2.2.3 → neuralnode-2.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "neuralnode"
-version = "2.2.3"
+version = "2.2.5"
 description = "Comprehensive AI Framework with 50+ LLM Providers, Advanced Agents, Chains, Memory, RAG, and 100+ Tools"
 readme = "README.md"
 requires-python = ">=3.9"

{neuralnode-2.2.3 → neuralnode-2.2.5}/src/neuralnode/__init__.py

@@ -42,7 +42,7 @@ Quick Start::
     text = sr.listen()
 """
 
-__version__ = "2.2.3"
+__version__ = "2.2.5"
 __author__ = "NeuralNode Contributors"
 
 # ── Core types ────────────────────────────────────────────────────────────────

{neuralnode-2.2.3 → neuralnode-2.2.5}/src/neuralnode/integrations/openclaw.py

@@ -14,6 +14,7 @@ import logging
 import threading
 import subprocess
 import shutil
+import json
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union, Generator
 
@@ -372,14 +373,39 @@ class OpenClawManager:
                 pm_cmd = ["npm", "install"]
             else:
                 raise RuntimeError("npm or pnpm is required to install OpenClaw dependencies. Install Node.js and retry.")
-            subprocess.run(
+            install_result = subprocess.run(
                 pm_cmd,
                 cwd=str(repo_dir),
                 check=True,
                 capture_output=True
             )
         except subprocess.CalledProcessError as e:
-            raise RuntimeError(f"Failed to install node dependencies: {e.stderr.decode()}")
+            output = (e.stdout or b"").decode(errors="replace") + (e.stderr or b"").decode(errors="replace")
+            raise RuntimeError(f"Failed to install node dependencies: {output.strip()}")
+
+        package_json_path = repo_dir / "package.json"
+        dist_entry_exists = (repo_dir / "dist" / "entry.mjs").exists() or (repo_dir / "dist" / "entry.js").exists()
+        if package_json_path.exists() and not dist_entry_exists:
+            try:
+                with open(package_json_path, "r", encoding="utf-8") as f:
+                    package_json = json.load(f)
+                scripts = package_json.get("scripts", {})
+            except Exception:
+                scripts = {}
+
+            if "build" in scripts:
+                build_cmd = [pm_cmd[0], "run", "build"]
+                logger.info(f"Building OpenClaw via: {' '.join(build_cmd)}")
+                try:
+                    subprocess.run(
+                        build_cmd,
+                        cwd=str(repo_dir),
+                        check=True,
+                        capture_output=True,
+                    )
+                except subprocess.CalledProcessError as e:
+                    output = (e.stdout or b"").decode(errors="replace") + (e.stderr or b"").decode(errors="replace")
+                    raise RuntimeError(f"Failed to build OpenClaw source tree: {output.strip()}")
 
         # Step 3: Write configuration pointing to NeuralNode API server
         self.configure()
@@ -434,7 +460,7 @@ class OpenClawManager:
 
         # Find starting command
         # Use node openclaw.mjs gateway or npm run dev/start
-        startup_cmd = ["node", "openclaw.mjs", "gateway"]
+        startup_cmd = ["node", "openclaw.mjs", "gateway", "--allow-unconfigured"]
         
         # Fallback to dev command if js build not present
         if not (repo_dir / "openclaw.mjs").exists():
@@ -447,9 +473,21 @@ class OpenClawManager:
                 raise RuntimeError("npm or pnpm is required to start OpenClaw. Install Node.js and retry.")
 
         logger.info(f"Starting OpenClaw Gateway via: {' '.join(startup_cmd)}")
+        process_env = os.environ.copy()
+        process_env.update(
+            {
+                "PORT": str(self.gateway_port),
+                "GATEWAY_HOST": self.gateway_host,
+                "GATEWAY_TOKEN": self.api_key or "neuralnode-secret-key",
+                "OPENAI_BASE_URL": f"http://127.0.0.1:{self.api_server_port}/v1",
+                "OPENAI_API_KEY": "neuralnode-secret-key",
+                "OPENAI_MODEL": getattr(self.node, "model", "neuralnode-model") or "neuralnode-model",
+            }
+        )
         self.process = subprocess.Popen(
             startup_cmd,
             cwd=str(repo_dir),
+            env=process_env,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
             text=True
@@ -468,7 +506,10 @@ class OpenClawManager:
         # Check process state
         if self.process.poll() is not None:
             stdout, stderr = self.process.communicate()
-            raise RuntimeError(f"OpenClaw process exited immediately with code {self.process.returncode}. Error: {stderr}")
+            raise RuntimeError(
+                f"OpenClaw process exited immediately with code {self.process.returncode}. "
+                f"Output: {(stdout or '') + (stderr or '')}"
+            )
             
         logger.warning("OpenClaw Gateway start timed out, but process is still running.")
 

{neuralnode-2.2.3 → neuralnode-2.2.5}/src/neuralnode/providers/horus.py

@@ -11,9 +11,12 @@ This module standardizes all Horus-family models around:
 from __future__ import annotations
 
 import asyncio
+import hashlib
 import logging
 import os
 import re
+import shutil
+import struct
 import time
 import warnings
 from contextlib import contextmanager, redirect_stderr, redirect_stdout
@@ -457,6 +460,8 @@ class HorusProvider(BaseLLMProvider):
         subfolder: str = "",
         revision: Optional[str] = None,
         cache_dir: Optional[str] = None,
+        patched_gguf_dir: Optional[str] = None,
+        patch_hiero_gguf_metadata: bool = True,
         local_files_only: bool = False,
         trust_remote_code: bool = True,
         token: Optional[str] = None,
@@ -471,6 +476,8 @@ class HorusProvider(BaseLLMProvider):
         do_sample: bool = True,
         num_beams: int = 1,
         early_stopping: bool = False,
+        thinking: Optional[bool] = None,
+        show_thinking: bool = False,
         tts_voice_id: str = "replic-aria-language{en-us}",
         enable_tts: bool = False,
         turboquant: Optional[Union[bool, TurboQuant, TurboQuantConfig, Dict[str, Any]]] = None,
@@ -539,6 +546,9 @@ class HorusProvider(BaseLLMProvider):
         self.subfolder = subfolder
         self.revision = revision
         self.cache_dir = cache_dir
+        self.patched_gguf_dir = patched_gguf_dir
+        self.patch_hiero_gguf_metadata = patch_hiero_gguf_metadata
+        self.model_path: Optional[str] = None
         self.local_files_only = local_files_only
         self.trust_remote_code = trust_remote_code
 
@@ -568,6 +578,8 @@ class HorusProvider(BaseLLMProvider):
             "do_sample": do_sample,
             "num_beams": num_beams,
             "early_stopping": early_stopping,
+            "thinking": thinking,
+            "show_thinking": show_thinking,
         }
 
         self.tokenizer = None
@@ -743,6 +755,142 @@ class HorusProvider(BaseLLMProvider):
             return min(self._context_window(), HORUS_CONTEXT_WINDOW)
         return self._context_window()
 
+    @staticmethod
+    def _read_gguf_u32(buffer: Union[bytes, bytearray], offset: int) -> tuple[int, int]:
+        return struct.unpack_from("<I", buffer, offset)[0], offset + 4
+
+    @staticmethod
+    def _read_gguf_u64(buffer: Union[bytes, bytearray], offset: int) -> tuple[int, int]:
+        return struct.unpack_from("<Q", buffer, offset)[0], offset + 8
+
+    @classmethod
+    def _skip_gguf_value(cls, buffer: Union[bytes, bytearray], offset: int, value_type: int) -> int:
+        # GGUF value type enum:
+        # UINT8, INT8, UINT16, INT16, UINT32, INT32, FLOAT32, BOOL, STRING,
+        # ARRAY, UINT64, INT64, FLOAT64 = 0..12
+        if value_type in (0, 1, 7):
+            return offset + 1
+        if value_type in (2, 3):
+            return offset + 2
+        if value_type in (4, 5, 6):
+            return offset + 4
+        if value_type in (10, 11, 12):
+            return offset + 8
+        if value_type == 8:
+            length, offset = cls._read_gguf_u64(buffer, offset)
+            return offset + length
+        if value_type == 9:
+            element_type, offset = cls._read_gguf_u32(buffer, offset)
+            count, offset = cls._read_gguf_u64(buffer, offset)
+            for _ in range(count):
+                offset = cls._skip_gguf_value(buffer, offset, element_type)
+            return offset
+        raise ValueError(f"Unsupported GGUF metadata value type: {value_type}")
+
+    @classmethod
+    def _read_gguf_metadata(cls, model_path: str) -> Dict[str, Any]:
+        with open(model_path, "rb") as f:
+            header = f.read(32 * 1024 * 1024)
+        if header[:4] != b"GGUF":
+            return {}
+
+        offset = 4
+        version, offset = cls._read_gguf_u32(header, offset)
+        tensor_count, offset = cls._read_gguf_u64(header, offset)
+        kv_count, offset = cls._read_gguf_u64(header, offset)
+        metadata: Dict[str, Any] = {
+            "__version__": version,
+            "__tensor_count__": tensor_count,
+            "__kv_count__": kv_count,
+        }
+
+        for _ in range(kv_count):
+            key_len, offset = cls._read_gguf_u64(header, offset)
+            key = bytes(header[offset:offset + key_len]).decode("utf-8")
+            offset += key_len
+            value_type, offset = cls._read_gguf_u32(header, offset)
+            value_offset = offset
+            if value_type == 4:
+                metadata[key] = struct.unpack_from("<I", header, value_offset)[0]
+            elif value_type == 8:
+                length, string_offset = cls._read_gguf_u64(header, value_offset)
+                metadata[key] = bytes(header[string_offset:string_offset + length]).decode("utf-8", errors="replace")
+            offset = cls._skip_gguf_value(header, offset, value_type)
+        return metadata
+
+    @classmethod
+    def _patch_gguf_u32_metadata(cls, source_path: str, target_path: str, patches: Dict[str, int]) -> bool:
+        shutil.copyfile(source_path, target_path)
+        with open(target_path, "r+b") as f:
+            data = bytearray(f.read(32 * 1024 * 1024))
+            if data[:4] != b"GGUF":
+                return False
+
+            offset = 4
+            _, offset = cls._read_gguf_u32(data, offset)
+            _, offset = cls._read_gguf_u64(data, offset)
+            kv_count, offset = cls._read_gguf_u64(data, offset)
+            patched = False
+
+            for _ in range(kv_count):
+                key_len, offset = cls._read_gguf_u64(data, offset)
+                key = bytes(data[offset:offset + key_len]).decode("utf-8")
+                offset += key_len
+                value_type, offset = cls._read_gguf_u32(data, offset)
+                value_offset = offset
+                if key in patches and value_type == 4:
+                    struct.pack_into("<I", data, value_offset, int(patches[key]))
+                    patched = True
+                offset = cls._skip_gguf_value(data, offset, value_type)
+
+            if patched:
+                f.seek(0)
+                f.write(data)
+            return patched
+
+    def _prepare_gguf_for_llama_cpp(self, model_path: str) -> str:
+        if not self.patch_hiero_gguf_metadata:
+            return model_path
+        if "horus-hiero" not in self.model_id.lower():
+            return model_path
+
+        try:
+            metadata = self._read_gguf_metadata(model_path)
+        except Exception:
+            return model_path
+
+        if (
+            metadata.get("general.architecture") != "qwen35"
+            or metadata.get("qwen35.block_count") != 33
+            or metadata.get("qwen35.nextn_predict_layers") != 1
+        ):
+            return model_path
+
+        source = Path(model_path)
+        fingerprint = hashlib.sha256(
+            f"{source.resolve()}:{source.stat().st_size}:{source.stat().st_mtime_ns}".encode("utf-8")
+        ).hexdigest()[:16]
+        patch_dir = Path(
+            self.patched_gguf_dir
+            or os.environ.get("NEURALNODE_PATCHED_GGUF_DIR", "")
+            or source.parent / ".neuralnode_patched"
+        )
+        patch_dir.mkdir(parents=True, exist_ok=True)
+        patched_path = patch_dir / f"{source.stem}.neuralnode-qwen35-block32-{fingerprint}{source.suffix}"
+
+        if patched_path.exists() and patched_path.stat().st_size == source.stat().st_size:
+            return str(patched_path)
+
+        self._patch_gguf_u32_metadata(
+            str(source),
+            str(patched_path),
+            {
+                "qwen35.block_count": 32,
+                "qwen35.nextn_predict_layers": 0,
+            },
+        )
+        return str(patched_path)
+
     def load(self) -> "HorusProvider":
         self._configure_external_logging()
         if self.model is not None:
@@ -1168,6 +1316,9 @@ class HorusProvider(BaseLLMProvider):
                     else:
                         os.environ["HF_HUB_DISABLE_PROGRESS_BARS"] = prev_disable_progress
 
+        model_path = self._prepare_gguf_for_llama_cpp(model_path)
+        self.model_path = model_path
+
         llama_kwargs: Dict[str, Any] = {
             "model_path": model_path,
             "n_ctx": self._runtime_context_window(),
@@ -1438,7 +1589,13 @@ class HorusProvider(BaseLLMProvider):
                 raise TypeError(f"Unsupported message type: {type(message)!r}")
         return normalized
 
-    def _render_prompt(self, messages: Sequence[Dict[str, str]]) -> str:
+    def _render_prompt(
+        self,
+        messages: Sequence[Dict[str, str]],
+        *,
+        thinking: Optional[bool] = None,
+        show_thinking: bool = False,
+    ) -> str:
         """Render messages using the tokenizer's chat template if available."""
         # Filter out empty system messages and normalize
         normalized_messages = []
@@ -1451,16 +1608,29 @@ class HorusProvider(BaseLLMProvider):
         has_system = any(m["role"] == "system" and m["content"].strip() for m in normalized_messages)
         if not has_system:
             normalized_messages.insert(0, {"role": "system", "content": UNIFIED_SYSTEM_PROMPT})
+
+        if thinking is not None:
+            thinking_instruction = self._thinking_instruction(thinking, show_thinking)
+            for m in normalized_messages:
+                if m["role"] == "system":
+                    m["content"] = f"{m['content'].rstrip()}\n\n{thinking_instruction}"
+                    break
         
         # If tokenizer is loaded and has apply_chat_template, use it
         if self.tokenizer is not None and hasattr(self.tokenizer, "apply_chat_template"):
             try:
                 # Use the model's built-in chat template
-                prompt = self.tokenizer.apply_chat_template(
-                    normalized_messages,
-                    tokenize=False,
-                    add_generation_prompt=True,
-                )
+                template_kwargs = {
+                    "tokenize": False,
+                    "add_generation_prompt": True,
+                }
+                if thinking is not None:
+                    template_kwargs["enable_thinking"] = bool(thinking)
+                try:
+                    prompt = self.tokenizer.apply_chat_template(normalized_messages, **template_kwargs)
+                except TypeError:
+                    template_kwargs.pop("enable_thinking", None)
+                    prompt = self.tokenizer.apply_chat_template(normalized_messages, **template_kwargs)
                 return prompt
             except Exception as exc:
                 self._warn("Chat template failed, falling back to unified format: %s", exc)
@@ -1488,6 +1658,33 @@ class HorusProvider(BaseLLMProvider):
         parts.append("<|assistant|>")
         return "\n".join(parts)
 
+    @staticmethod
+    def _thinking_instruction(thinking: bool, show_thinking: bool) -> str:
+        if thinking:
+            if show_thinking:
+                return (
+                    "Thinking mode is enabled. Put concise reasoning inside <think>...</think>, "
+                    "then provide the final answer."
+                )
+            return (
+                "Thinking mode is enabled. Reason internally before answering, but do not reveal "
+                "the reasoning or any <think> block. Return only the final answer."
+            )
+        return (
+            "Thinking mode is disabled. Answer directly and do not include hidden reasoning, "
+            "chain-of-thought, or <think> blocks."
+        )
+
+    @staticmethod
+    def _strip_thinking_blocks(text: str) -> str:
+        cleaned = text or ""
+        cleaned = re.sub(r"<think>.*?</think>", "", cleaned, flags=re.DOTALL | re.IGNORECASE)
+        cleaned = re.sub(r"(?is)^.*?</think>", "", cleaned)
+        cleaned = re.sub(r"(?is)<think>.*$", "", cleaned)
+        cleaned = re.sub(r"(?is)^\s*thinking\s*:\s*.*?(final answer\s*:)", "", cleaned)
+        cleaned = re.sub(r"(?im)^\s*final answer\s*:\s*", "", cleaned)
+        return cleaned.strip()
+
     def _resolve_generation_settings(self, **kwargs) -> Dict[str, Any]:
         settings = dict(self.generation_config)
         settings.update({k: v for k, v in kwargs.items() if v is not None})
@@ -1592,7 +1789,19 @@ class HorusProvider(BaseLLMProvider):
                 top_p=settings.get("top_p", 0.85),
                 top_k=settings.get("top_k", 50),
                 repeat_penalty=settings.get("repetition_penalty", 1.2),
-                stop=["<|end|>", "<|user|>", "\n<|user|>", "<|assistant|>", "\n<|assistant|>"],
+                stop=[
+                    "<|end|>",
+                    "<|endoftext|>",
+                    "<|im_end|>",
+                    "<|user|>",
+                    "\n<|user|>",
+                    "<|assistant|>",
+                    "\n<|assistant|>",
+                    "<|im_start|>user",
+                    "\n<|im_start|>user",
+                    "<|im_start|>assistant",
+                    "\n<|im_start|>assistant",
+                ],
                 echo=False,
             )
         return self._clean_generated_text(output["choices"][0]["text"])
@@ -1600,7 +1809,24 @@ class HorusProvider(BaseLLMProvider):
     def _clean_generated_text(self, text: str) -> str:
         """Clean generation artifacts from Horus outputs."""
         cleaned = text or ""
-        cleaned = cleaned.replace("<|assistant|>", "").replace("<|user|>", "").replace("<|end|>", "")
+        special_markers = (
+            "<|assistant|>",
+            "<|user|>",
+            "<|system|>",
+            "<|end|>",
+            "<|endoftext|>",
+            "<|im_end|>",
+            "<|im_start|>",
+            "<|vision_start|>",
+            "<|vision_end|>",
+            "<|image_pad|>",
+            "<|video_pad|>",
+        )
+        for marker in special_markers:
+            cleaned = cleaned.replace(marker, "")
+        partial_special = cleaned.find("<|")
+        if partial_special >= 0:
+            cleaned = cleaned[:partial_special]
         cleaned = re.sub(r"(?im)^\s*assistant\s*[:：]?\s*", "", cleaned)
         cleaned = re.sub(r"\n{3,}", "\n\n", cleaned)
         cleaned = cleaned.strip()
@@ -1822,8 +2048,10 @@ class HorusProvider(BaseLLMProvider):
                     "role": "system",
                     "content": UNIFIED_SYSTEM_PROMPT + tool_section
                 })
-        
-        prompt = self._render_prompt(normalized)
+
+        thinking = kwargs.pop("thinking", self.generation_config.get("thinking"))
+        show_thinking = bool(kwargs.pop("show_thinking", self.generation_config.get("show_thinking", False)))
+        prompt = self._render_prompt(normalized, thinking=thinking, show_thinking=show_thinking)
         generation_kwargs = {
             "temperature": temperature if temperature is not None else self.generation_config["temperature"],
             "max_new_tokens": max_tokens or self.generation_config["max_new_tokens"],
@@ -1832,7 +2060,7 @@ class HorusProvider(BaseLLMProvider):
         }
 
         if stream:
-            return self.stream_chat(normalized, **generation_kwargs)
+            return self.stream_chat(normalized, **generation_kwargs, thinking=thinking, show_thinking=show_thinking)
 
         if self._is_gguf_model_id(self.model_id):
             content = self._generate_gguf_text(prompt, **generation_kwargs)
@@ -1846,6 +2074,8 @@ class HorusProvider(BaseLLMProvider):
                 last_user_message = m.get("content", "")
                 break
         content = self._postprocess_assistant_text(content, last_user_message)
+        if not show_thinking:
+            content = self._strip_thinking_blocks(content)
 
         # Parse tool calls from response if tools were provided
         tool_calls = []
@@ -1874,7 +2104,9 @@ class HorusProvider(BaseLLMProvider):
             raise RuntimeError("Horus Lens is a text-to-image model. Use generate_image(prompt) instead of stream_chat().")
 
         normalized = self._normalize_messages(messages)
-        prompt = self._render_prompt(normalized)
+        thinking = kwargs.pop("thinking", self.generation_config.get("thinking"))
+        show_thinking = bool(kwargs.pop("show_thinking", self.generation_config.get("show_thinking", False)))
+        prompt = self._render_prompt(normalized, thinking=thinking, show_thinking=show_thinking)
 
         if self._is_gguf_model_id(self.model_id):
             last_user_message = ""
@@ -1883,7 +2115,10 @@ class HorusProvider(BaseLLMProvider):
                     last_user_message = message.get("content", "")
                     break
             yield StreamingChunk(
-                content=self._postprocess_assistant_text(
+                content=self._strip_thinking_blocks(self._postprocess_assistant_text(
+                    self._generate_gguf_text(prompt, **kwargs),
+                    last_user_message,
+                )) if not show_thinking else self._postprocess_assistant_text(
                     self._generate_gguf_text(prompt, **kwargs),
                     last_user_message,
                 ),