neuralnode 2.1.0__tar.gz → 2.1.1__tar.gz

{neuralnode-2.1.0 → neuralnode-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuralnode
-Version: 2.1.0
+Version: 2.1.1
 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.1.0 → neuralnode-2.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "neuralnode"
-version = "2.1.0"
+version = "2.1.1"
 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.1.0 → neuralnode-2.1.1}/src/neuralnode/__init__.py

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

{neuralnode-2.1.0 → neuralnode-2.1.1}/src/neuralnode/providers/horus.py

@@ -105,8 +105,9 @@ UNIFIED_SYSTEM_PROMPT = (
     "You are a multilingual model and can communicate in multiple languages, but you must always reply in the same language as the user's latest message unless the user explicitly requests another language.\n"
     "\n"
     "Behavior rules:\n"
-    "1) When the user greets you, do NOT say: 'I'm Horus, an AI model developed by TokenAI.'\n"
-    "   Only greet the user naturally, mention that you are Horus, and ask how you can help.\n"
+    "1) When the user greets you, reply with a short natural greeting and ask how you can help.\n"
+    "   Do NOT say: 'I'm Horus, an AI model developed by TokenAI.'\n"
+    "   Do NOT mention TokenAI, your developer, your origin, or any self-introduction unless the user explicitly asks who you are.\n"
     "2) Answer in the same language as the user's latest message unless the user explicitly requests another language.\n"
     "3) Match the length of your answer to the size and depth of the user's question.\n"
     "   Keep short questions short, and provide detailed answers only when needed.\n"
@@ -120,6 +121,7 @@ UNIFIED_SYSTEM_PROMPT = (
     "11) If the user asks for code, produce correct runnable code and briefly mention assumptions when necessary.\n"
     "12) If the user request is unsafe or harmful, refuse briefly and offer a safe alternative.\n"
     "13) Do not repeatedly introduce yourself. Only provide your identity if the user explicitly asks who you are.\n"
+    "    Outside identity questions, never start your answer with self-introduction, biography, or model-description text.\n"
     "14) You currently have NO permissions or authority over any tools, device controls, system settings, files, or user hardware unless tools are explicitly enabled later.\n"
     "    Never claim access to the user's device, apps, files, camera, microphone, or controls.\n"
     "15) If the user asks for more information about you as the Horus model, state that Horus is the first publicly announced open-source model originating from Egypt and one of the strongest models in its category.\n"
@@ -269,6 +271,7 @@ class HorusProvider(BaseLLMProvider):
         turboquant_protected_layers: Optional[List[int]] = None,
         suppress_warnings: bool = True,
         suppress_native_output: bool = True,
+        suppress_library_logs: bool = True,
         auto_install_deps: bool = False,
         **kwargs,
     ):
@@ -312,12 +315,8 @@ class HorusProvider(BaseLLMProvider):
         self.cache_dir = cache_dir
         self.local_files_only = local_files_only
         self.trust_remote_code = trust_remote_code
-        
-        # Obfuscated fallback HF token to suppress warnings (auto-injected for users)
-        import base64
-        _df_token = base64.b64decode("aGZfRklTc25aQ1ZQVURxdmtIbWtxc01Cb2xCRFFEUFdwV0lOTg==").decode('utf-8')
-        
-        self.token = token or os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_TOKEN") or _df_token
+
+        self.token = token or os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_TOKEN")
         self.proxies = proxies
         self.force_download = force_download
         self.resume_download = resume_download
@@ -330,6 +329,7 @@ class HorusProvider(BaseLLMProvider):
         self.turboquant_protected_layers = turboquant_protected_layers
         self.suppress_warnings = suppress_warnings
         self.suppress_native_output = suppress_native_output
+        self.suppress_library_logs = suppress_library_logs
 
         self.generation_config = {
             "max_new_tokens": max_new_tokens,
@@ -353,6 +353,12 @@ class HorusProvider(BaseLLMProvider):
         if not self.suppress_warnings:
             logger.warning(message, *args)
 
+    def _configure_external_logging(self) -> None:
+        if not self.suppress_library_logs:
+            return
+        for logger_name in ("httpx", "httpcore", "huggingface_hub", "transformers"):
+            logging.getLogger(logger_name).setLevel(logging.WARNING)
+
     @contextmanager
     def _quiet_native_output(self):
         if not self.suppress_native_output:
@@ -434,12 +440,26 @@ class HorusProvider(BaseLLMProvider):
         return base
 
     def load(self) -> "HorusProvider":
+        self._configure_external_logging()
         if self.model is not None:
             return self
         if self._is_gguf_model_id(self.model_id):
             return self._load_gguf()
         return self._load_transformers()
 
+    @staticmethod
+    def _is_cuda_oom(exc: Exception) -> bool:
+        text = str(exc).lower()
+        return "out of memory" in text or "cuda out of memory" in text
+
+    def _clear_cuda_cache(self) -> None:
+        if torch is None or not torch.cuda.is_available():
+            return
+        try:
+            torch.cuda.empty_cache()
+        except Exception:
+            pass
+
     def _load_gguf(self) -> "HorusProvider":
         if not HF_HUB_AVAILABLE and self.auto_install_deps:
             ensure_feature_dependencies("horus_gguf", auto_install=True)
@@ -639,6 +659,9 @@ class HorusProvider(BaseLLMProvider):
             model_kwargs["device_map"] = self.device_map
         if self.max_memory:
             model_kwargs["max_memory"] = self.max_memory
+        elif self.device == "cuda" and not self.device_map and not self.load_in_4bit and not self.load_in_8bit:
+            # Avoid moving the full safetensors model to GPU in one shot on 16 GB cards.
+            model_kwargs["device_map"] = "auto"
 
         if self.load_in_4bit or self.load_in_8bit:
             try:
@@ -670,17 +693,43 @@ class HorusProvider(BaseLLMProvider):
                 fallback_kwargs = dict(model_kwargs)
                 fallback_kwargs.pop("dtype", None)
                 fallback_kwargs["torch_dtype"] = self.torch_dtype
-                self.model = AutoModelForCausalLM.from_pretrained(repo_id, **fallback_kwargs)
+                try:
+                    self.model = AutoModelForCausalLM.from_pretrained(repo_id, **fallback_kwargs)
+                except Exception as retry_exc:
+                    raise RuntimeError(
+                        f"Failed to load Horus transformers model from '{repo_id}'. "
+                        "Try GGUF for lower VRAM usage or enable 4-bit loading."
+                    ) from retry_exc
             else:
                 raise RuntimeError(
                     f"Failed to load Horus transformers model from '{repo_id}'. "
                     "This Horus variant may require GGUF runtime; try one of the GGUF model ids."
                 ) from exc
         except Exception as exc:
-            raise RuntimeError(
-                f"Failed to load Horus transformers model from '{repo_id}'. "
-                "This Horus variant may require GGUF runtime; try one of the GGUF model ids."
-            ) from exc
+            if self._is_cuda_oom(exc) and self.device == "cuda":
+                self._clear_cuda_cache()
+                cpu_fallback_kwargs = dict(model_kwargs)
+                cpu_fallback_kwargs.pop("device_map", None)
+                cpu_fallback_kwargs.pop("max_memory", None)
+                cpu_fallback_kwargs["dtype"] = torch.float32 if torch is not None else None
+                try:
+                    self.device = "cpu"
+                    self.torch_dtype = torch.float32 if torch is not None else self.torch_dtype
+                    self.model = AutoModelForCausalLM.from_pretrained(repo_id, **cpu_fallback_kwargs)
+                    self._warn(
+                        "Horus CUDA load ran out of memory and fell back to CPU. "
+                        "Use GGUF or 4-bit loading for better local performance."
+                    )
+                except Exception as cpu_exc:
+                    raise RuntimeError(
+                        f"Failed to load Horus transformers model from '{repo_id}' on GPU due to CUDA OOM, "
+                        "and CPU fallback also failed. Use a GGUF model id or enable 4-bit loading."
+                    ) from cpu_exc
+            else:
+                raise RuntimeError(
+                    f"Failed to load Horus transformers model from '{repo_id}'. "
+                    "This Horus variant may require GGUF runtime; try one of the GGUF model ids."
+                ) from exc
         if "device_map" not in model_kwargs:
             self.model = self.model.to(self.device)
         self.model.eval()
@@ -908,10 +957,54 @@ class HorusProvider(BaseLLMProvider):
         )
         return any(marker in q for marker in identity_markers)
 
+    @staticmethod
+    def _is_greeting(user_text: str) -> bool:
+        q = (user_text or "").strip().lower()
+        normalized = re.sub(r"[^\w\u0600-\u06FF\s]", " ", q)
+        normalized = re.sub(r"\s+", " ", normalized).strip()
+        greeting_markers = {
+            "hi",
+            "hello",
+            "hey",
+            "hi there",
+            "hello there",
+            "good morning",
+            "good afternoon",
+            "good evening",
+            "اهلا",
+            "أهلا",
+            "مرحبا",
+            "السلام عليكم",
+            "سلام",
+        }
+        return normalized in greeting_markers
+
+    @staticmethod
+    def _remove_leading_identity_sentences(text: str) -> str:
+        patterns = [
+            r"^\s*(?:hi|hello|hey)[,!\.\s]+i(?:\s*am|'m)\s+horus,\s*an ai (?:assistant|model)\s+developed by tokenai\.?\s*",
+            r"^\s*(?:hi|hello|hey)[,!\.\s]+i(?:\s*am|'m)\s+horus,\s*developed by tokenai\.?\s*",
+            r"^\s*(?:hi|hello|hey)[,!\.\s]+i(?:\s*am|'m)\s+horus\.?\s*",
+            r"^\s*i(?:\s*am|'m)\s+horus,\s*an ai (?:assistant|model)\s+developed by tokenai\.?\s*",
+            r"^\s*i(?:\s*am|'m)\s+horus,\s*developed by tokenai\.?\s*",
+            r"^\s*i(?:\s*am|'m)\s+horus\.?\s*",
+            r"^\s*(?:مرحبا|اهلا|أهلا|السلام عليكم|سلام)[،!,\.\s]+(?:أنا\s+)?horus[^.!\n]*[.!\n]\s*",
+            r"^\s*(?:أنا\s+)?horus[^.!\n]*tokenai[^.!\n]*[.!\n]\s*",
+        ]
+        cleaned = text.strip()
+        for pattern in patterns:
+            cleaned = re.sub(pattern, "", cleaned, flags=re.IGNORECASE)
+        return cleaned.strip()
+
     @staticmethod
     def _strip_redundant_identity_prefix(text: str) -> str:
         patterns = [
+            r"^\s*(?:hi|hello|hey)[,!\.\s]+i(?:\s*am|'m)\s+horus,\s*an ai (?:assistant|model)\s+developed by tokenai\.?\s*",
+            r"^\s*(?:hi|hello|hey)[,!\.\s]+i(?:\s*am|'m)\s+horus,\s*developed by tokenai\.?\s*",
+            r"^\s*(?:hi|hello|hey)[,!\.\s]+i(?:\s*am|'m)\s+horus\.?\s*",
             r"^\s*i(?:\s*am|'m)\s+horus,\s*an ai model developed by tokenai\.?\s*",
+            r"^\s*i(?:\s*am|'m)\s+horus,\s*an ai assistant developed by tokenai\.?\s*",
+            r"^\s*i(?:\s*am|'m)\s+horus,\s*developed by tokenai\.?\s*",
             r"^\s*i(?:\s*am|'m)\s+horus\.?\s*",
             r"^\s*أنا\s+horus[^.!\n]*[.!\n]\s*",
         ]
@@ -920,6 +1013,20 @@ class HorusProvider(BaseLLMProvider):
             cleaned = re.sub(pattern, "", cleaned, flags=re.IGNORECASE)
         return cleaned.strip() or text
 
+    def _postprocess_assistant_text(self, text: str, user_text: str = "") -> str:
+        cleaned = self._clean_generated_text(text)
+        if self._is_identity_question(user_text):
+            return cleaned
+
+        cleaned = self._remove_leading_identity_sentences(cleaned)
+        cleaned = self._strip_redundant_identity_prefix(cleaned)
+
+        if self._is_greeting(user_text) and not cleaned.strip():
+            if re.search(r"[\u0600-\u06FF]", user_text or ""):
+                return "أهلا! كيف يمكنني مساعدتك؟"
+            return "Hello! How can I help you?"
+        return cleaned
+
     def chat(
         self,
         messages: List[Dict[str, Any]],
@@ -976,8 +1083,7 @@ class HorusProvider(BaseLLMProvider):
             if m.get("role") == "user":
                 last_user_message = m.get("content", "")
                 break
-        if not self._is_identity_question(last_user_message):
-            content = self._strip_redundant_identity_prefix(content)
+        content = self._postprocess_assistant_text(content, last_user_message)
 
         # Parse tool calls from response if tools were provided
         tool_calls = []
@@ -1006,7 +1112,18 @@ class HorusProvider(BaseLLMProvider):
         prompt = self._render_prompt(normalized)
 
         if self._is_gguf_model_id(self.model_id):
-            yield StreamingChunk(content=self._generate_gguf_text(prompt, **kwargs), is_finished=True)
+            last_user_message = ""
+            for message in reversed(normalized):
+                if message.get("role") == "user":
+                    last_user_message = message.get("content", "")
+                    break
+            yield StreamingChunk(
+                content=self._postprocess_assistant_text(
+                    self._generate_gguf_text(prompt, **kwargs),
+                    last_user_message,
+                ),
+                is_finished=True,
+            )
             return
 
         self.load()