neuralnode 2.0.9__tar.gz → 2.1.0__tar.gz

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

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

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

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

{neuralnode-2.0.9 → neuralnode-2.1.0}/src/neuralnode/integrations/telegram.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 
 import asyncio
 import json
+import logging
 import os
 import re
 import tempfile
@@ -95,6 +96,8 @@ class TelegramBotConfig:
     download_dir: Optional[str] = None
     validate_token_on_start: bool = True
     auto_install_deps: bool = True
+    suppress_library_logs: bool = True
+    debug_updates: bool = False
 
 
 class TelegramBot:
@@ -222,6 +225,12 @@ class TelegramBot:
             return f"Previous context:\n{chat_context}\n\nUser message: {user_message}"
         return user_message
 
+    def _configure_runtime_logging(self) -> None:
+        if not self.config.suppress_library_logs:
+            return
+        for logger_name in ("httpx", "httpcore", "telegram", "telegram.ext"):
+            logging.getLogger(logger_name).setLevel(logging.WARNING)
+
     def _run_agent(self, task: str) -> str:
         response = self.agent.run(task)
         if hasattr(response, "output"):
@@ -237,6 +246,10 @@ class TelegramBot:
         text = re.sub(r"REASONING:.*?\n", "", text, flags=re.IGNORECASE | re.DOTALL)
         return text.strip()
 
+    async def _run_agent_with_timeout(self, task: str) -> str:
+        timeout = max(1, int(self.config.response_timeout or 60))
+        return await asyncio.wait_for(asyncio.to_thread(self._run_agent, task), timeout=timeout)
+
     def _record_exchange(self, session: TelegramSession, user_message: str, response: str):
         session.chat_history.append(
             {
@@ -413,15 +426,21 @@ class TelegramBot:
             await update.message.reply_text("You are not authorized to use this bot.")
             return
 
-        user_message = update.message.text
+        user_message = update.message.text or ""
+        if self.config.debug_updates:
+            print(f"[Telegram][text] user={user.id} message={user_message[:200]}")
         if self.config.show_typing:
             await context.bot.send_chat_action(chat_id=update.effective_chat.id, action="typing")
 
         try:
             task = self._build_user_task(session, user_message)
-            response = self._run_agent(task)
+            response = await self._run_agent_with_timeout(task)
             self._record_exchange(session, user_message, response)
             await self._send_response(update, response)
+        except asyncio.TimeoutError:
+            await update.message.reply_text(
+                "Model response timed out. Try a shorter prompt or reduce max tokens."
+            )
         except Exception as exc:
             await update.message.reply_text(f"Error processing your message: {str(exc)[:200]}")
 
@@ -449,6 +468,8 @@ class TelegramBot:
 
         voice = update.message.voice
         file_name = f"voice_{user.id}_{voice.file_unique_id}.ogg"
+        if self.config.debug_updates:
+            print(f"[Telegram][voice] user={user.id} file={file_name}")
 
         try:
             downloaded = await self._download_telegram_file(voice.file_id, file_name)
@@ -460,11 +481,15 @@ class TelegramBot:
             )
 
             task = self._build_user_task(session, transcript)
-            response = self._run_agent(task)
+            response = await self._run_agent_with_timeout(task)
             self._record_exchange(session, transcript, response)
 
             await update.message.reply_text(f"Transcript: {transcript}")
             await self._send_response(update, response)
+        except asyncio.TimeoutError:
+            await update.message.reply_text(
+                "Model response timed out after transcription. Try shorter audio or a shorter prompt."
+            )
         except Exception as exc:
             await update.message.reply_text(f"Voice transcription failed: {str(exc)[:300]}")
 
@@ -484,6 +509,8 @@ class TelegramBot:
 
         document = update.message.document
         safe_name = document.file_name or f"document_{document.file_unique_id}"
+        if self.config.debug_updates:
+            print(f"[Telegram][document] user={user.id} file={safe_name}")
         try:
             downloaded = await self._download_telegram_file(document.file_id, safe_name)
             extracted_text = self._extract_document_text(downloaded)
@@ -493,11 +520,15 @@ class TelegramBot:
                 f"Document content:\n{extracted_text}\n\n"
                 "Provide a concise summary, key points, risks, and actionable insights."
             )
-            response = self._run_agent(task)
+            response = await self._run_agent_with_timeout(task)
             self._record_exchange(session, f"[Document upload] {safe_name}", response)
 
             header = f"Document received: {safe_name}\nSize: {document.file_size / 1024:.1f} KB\n\n"
             await self._send_response(update, header + response)
+        except asyncio.TimeoutError:
+            await update.message.reply_text(
+                "Model response timed out while analyzing document. Try a smaller file."
+            )
         except Exception as exc:
             await update.message.reply_text(f"Document analysis failed: {str(exc)[:300]}")
 
@@ -518,6 +549,8 @@ class TelegramBot:
 
     async def _handle_error(self, update: object, context: ContextTypes.DEFAULT_TYPE):
         print(f"Telegram bot error: {context.error}")
+        if self.config.debug_updates:
+            logging.exception("Telegram update error", exc_info=context.error)
 
     def start(self, poll_interval: float = 1.0):
         if self._running:
@@ -526,6 +559,7 @@ class TelegramBot:
         if self.config.validate_token_on_start and not self.validate_token():
             raise ValueError("Invalid Telegram bot token. Verify your BotFather token and network connectivity.")
 
+        self._configure_runtime_logging()
         self.application = Application.builder().token(self.token).build()
         self._setup_handlers()
         self._running = True
@@ -539,6 +573,7 @@ class TelegramBot:
         async def run_bot():
             if self.config.validate_token_on_start and not self.validate_token():
                 raise ValueError("Invalid Telegram bot token. Verify your BotFather token and network connectivity.")
+            self._configure_runtime_logging()
             self.application = Application.builder().token(self.token).build()
             self._setup_handlers()
             await self.application.initialize()

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

@@ -102,33 +102,40 @@ HORUS_CONTEXT_WINDOW = 8192
 UNIFIED_CHAT_TEMPLATE_NAME = "horus_unified"
 UNIFIED_SYSTEM_PROMPT = (
     "You are Horus, an AI assistant developed by TokenAI.\n"
+    "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) Answer in the same language as the user's latest message unless the user explicitly requests another language.\n"
-    "2) Prioritize factual accuracy. Do not invent facts, sources, citations, URLs, names, numbers, or events.\n"
-    "3) If information is uncertain or missing, say so clearly and ask a short clarifying question instead of guessing.\n"
-    "4) Be concise, direct, and non-repetitive. Avoid restating the same point with different wording.\n"
-    "5) Keep internal reasoning private. Return only the final answer.\n"
-    "6) For instructions that require steps, provide clear actionable steps without filler.\n"
-    "7) If the user asks for code, produce correct runnable code and mention assumptions briefly.\n"
-    "8) If the user request is unsafe or harmful, refuse briefly and offer a safe alternative.\n"
-    "9) Do not repeatedly introduce yourself. Only provide your identity if the user explicitly asks who you are.\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"
+    "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"
+    "4) Do not add extra unnecessary information beyond what the user asked.\n"
+    "5) Prioritize factual accuracy. Do not invent facts, sources, citations, URLs, names, numbers, or events.\n"
+    "6) Do not invent or assume any new information about Assem Sabry or TokenAI unless it is explicitly provided in the conversation context.\n"
+    "7) If information is uncertain or missing, clearly say so and ask a short clarifying question instead of guessing.\n"
+    "8) Be concise, direct, and non-repetitive. Avoid repeating the same point in different wording.\n"
+    "9) Keep internal reasoning private. Return only the final answer.\n"
+    "10) For instructions that require steps, provide clear actionable steps without filler.\n"
+    "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"
+    "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"
     "\n"
     "Quality checks before responding:\n"
     "- Is the answer grounded in provided context or clearly stated assumptions?\n"
     "- Is there any hallucinated detail? If yes, remove it.\n"
-    "- Is the answer short, useful, and in the user's language?"
+    "- Is the answer appropriately sized for the user's question?\n"
+    "- Is the answer in the user's language?\n"
+    "- Did you avoid adding unnecessary extra information?"
 )
 
-# Tool calling system prompt addition
 TOOL_CALLING_PROMPT = """
-You have access to the following tools. When you need to use a tool, respond with a JSON object in this format:
-{"tool": "tool_name", "arguments": {"arg1": "value1", "arg2": "value2"}}
-
-Available tools:
-{tool_descriptions}
-
-If no tool is needed, respond normally.
+You currently do NOT have access to any tools.
+Do not claim the ability to use external tools, device controls, APIs, or system functions.
+If tools are enabled in the future, they will be explicitly listed here.
 """
 
 
@@ -262,7 +269,7 @@ class HorusProvider(BaseLLMProvider):
         turboquant_protected_layers: Optional[List[int]] = None,
         suppress_warnings: bool = True,
         suppress_native_output: bool = True,
-        auto_install_deps: bool = True,
+        auto_install_deps: bool = False,
         **kwargs,
     ):
         self.auto_install_deps = auto_install_deps
@@ -442,13 +449,28 @@ class HorusProvider(BaseLLMProvider):
             _refresh_llama_imports()
         if not LLAMA_CPP_AVAILABLE:
             raise ImportError(
-                "llama-cpp-python is required for GGUF Horus models. "
-                "Install with: pip install llama-cpp-python"
+                "llama-cpp-python is required for GGUF Horus models.\n"
+                "Please preinstall it once before using Horus GGUF to avoid long runtime builds:\n"
+                "  pip install \"neuralnode[horus]\"\n"
+                "or:\n"
+                "  pip install llama-cpp-python\n"
+                "Tip: runtime auto-install is disabled by default for Horus (auto_install_deps=False)."
             )
 
         repo_id, filename = self._split_repo_and_filename(self.model_id)
         model_path = filename
+        if not HF_HUB_AVAILABLE and repo_id:
+            raise ImportError(
+                "huggingface_hub is required to download Horus model files from HF.\n"
+                "Install with:\n"
+                "  pip install huggingface_hub\n"
+                "or:\n"
+                "  pip install \"neuralnode[horus]\""
+            )
         if repo_id and HF_HUB_AVAILABLE:
+            prev_disable_progress = os.environ.get("HF_HUB_DISABLE_PROGRESS_BARS")
+            if self.suppress_native_output:
+                os.environ["HF_HUB_DISABLE_PROGRESS_BARS"] = "1"
             with warnings.catch_warnings():
                 warnings.filterwarnings(
                     "ignore",
@@ -461,6 +483,11 @@ class HorusProvider(BaseLLMProvider):
                     local_files_only=self.local_files_only,
                     token=self.token,
                 )
+            if self.suppress_native_output:
+                if prev_disable_progress is None:
+                    os.environ.pop("HF_HUB_DISABLE_PROGRESS_BARS", None)
+                else:
+                    os.environ["HF_HUB_DISABLE_PROGRESS_BARS"] = prev_disable_progress
 
         llama_kwargs: Dict[str, Any] = {
             "model_path": model_path,
@@ -552,8 +579,11 @@ class HorusProvider(BaseLLMProvider):
             _refresh_transformers_imports()
         if not TRANSFORMERS_AVAILABLE:
             raise ImportError(
-                "transformers and torch are required for Horus transformers models. "
-                "Install with: pip install transformers torch"
+                "transformers and torch are required for Horus transformers models.\n"
+                "Please preinstall once with:\n"
+                "  pip install \"neuralnode[horus]\"\n"
+                "or:\n"
+                "  pip install transformers torch"
             )
         repo_id, auto_subfolder = self._resolve_transformers_source(self.model_id)
         resolved_subfolder = self.subfolder or auto_subfolder
@@ -587,7 +617,7 @@ class HorusProvider(BaseLLMProvider):
             "cache_dir": self.cache_dir,
             "local_files_only": self.local_files_only,
             "trust_remote_code": self.trust_remote_code,
-            "torch_dtype": self.torch_dtype,
+            "dtype": self.torch_dtype,
             "low_cpu_mem_usage": self.low_cpu_mem_usage,
             "use_safetensors": self.use_safetensors,
             "proxies": self.proxies,
@@ -634,6 +664,18 @@ class HorusProvider(BaseLLMProvider):
 
         try:
             self.model = AutoModelForCausalLM.from_pretrained(repo_id, **model_kwargs)
+        except TypeError as exc:
+            # Backward compatibility with older transformers versions.
+            if "dtype" in str(exc) and "unexpected keyword" in str(exc):
+                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)
+            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}'. "