neuralnode 2.0.9__tar.gz → 2.1.1__tar.gz

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

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

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

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

{neuralnode-2.0.9 → neuralnode-2.1.1}/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.1}/src/neuralnode/providers/horus.py

@@ -102,33 +102,42 @@ 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, 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"
+    "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"
+    "    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"
     "\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 +271,8 @@ class HorusProvider(BaseLLMProvider):
         turboquant_protected_layers: Optional[List[int]] = None,
         suppress_warnings: bool = True,
         suppress_native_output: bool = True,
-        auto_install_deps: bool = True,
+        suppress_library_logs: bool = True,
+        auto_install_deps: bool = False,
         **kwargs,
     ):
         self.auto_install_deps = auto_install_deps
@@ -305,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
@@ -323,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,
@@ -346,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:
@@ -427,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)
@@ -442,13 +469,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 +503,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 +599,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 +637,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,
@@ -609,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:
@@ -634,11 +687,49 @@ 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
+                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()
@@ -866,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*",
         ]
@@ -878,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]],
@@ -934,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 = []
@@ -964,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()