neuralnode 2.0.2__tar.gz → 2.0.4__tar.gz

{neuralnode-2.0.2 → neuralnode-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuralnode
-Version: 2.0.2
+Version: 2.0.4
 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
@@ -243,7 +243,6 @@ Supported IDs currently include:
 - `tokenaii/Hours-1.0-4B-GGUF/Horus-1.0-4B-Q6_K.gguf`
 - `tokenaii/Hours-1.0-4B-GGUF/Horus-1.0-4B-Q8_0.gguf`
 - `tokenaii/Hours-1.0-4B-GGUF/Horus-1.0-4B-F16.gguf`
-- `tokenaii/horus-instruct`
 
 ## Replica TTS
 

{neuralnode-2.0.2 → neuralnode-2.0.4}/README.md

@@ -77,7 +77,6 @@ Supported IDs currently include:
 - `tokenaii/Hours-1.0-4B-GGUF/Horus-1.0-4B-Q6_K.gguf`
 - `tokenaii/Hours-1.0-4B-GGUF/Horus-1.0-4B-Q8_0.gguf`
 - `tokenaii/Hours-1.0-4B-GGUF/Horus-1.0-4B-F16.gguf`
-- `tokenaii/horus-instruct`
 
 ## Replica TTS
 

{neuralnode-2.0.2 → neuralnode-2.0.4}/docs/documentation.md

@@ -133,7 +133,6 @@ Available Horus model IDs:
 - `tokenaii/Hours-1.0-4B-GGUF/Horus-1.0-4B-Q6_K.gguf`
 - `tokenaii/Hours-1.0-4B-GGUF/Horus-1.0-4B-Q8_0.gguf`
 - `tokenaii/Hours-1.0-4B-GGUF/Horus-1.0-4B-F16.gguf`
-- `tokenaii/horus-instruct`
 
 ## Replica
 

neuralnode-2.0.4/examples/horus_tq_ready_gguf.py

@@ -0,0 +1,59 @@
+"""Horus ready-GGUF usage (including TQ* variants).
+
+Run:
+    python examples/horus_tq_ready_gguf.py
+"""
+
+from __future__ import annotations
+
+import json
+
+import neuralnode as nn
+
+
+def main() -> None:
+    # Example TQ model id (replace with the real published TQ GGUF file when available)
+    tq_model_id = "tokenaii/Hours-1.0-4B-GGUF/Horus-1.0-4B-TQ3_1S.gguf"
+    q4_model_id = "tokenaii/Hours-1.0-4B-GGUF/Horus-1.0-4B-Q4_K_M.gguf"
+
+    # Optional: register TQ in Horus listed models for nicer discovery.
+    nn.HorusModel.register_gguf_variant(
+        model_id=tq_model_id,
+        name="Horus 1.0 4B (TurboQuant TQ3_1S)",
+        size="4B",
+    )
+
+    print("Registered models:")
+    for model_id in [tq_model_id, q4_model_id]:
+        print("-", model_id)
+
+    # Use any ready GGUF model directly by model_id.
+    model = nn.HorusModel(
+        model_id=q4_model_id,
+        cache_dir=r"D:\Work Space\NeuralNode\hf_cache",
+        local_files_only=True,
+        suppress_warnings=True,
+        suppress_native_output=True,
+    ).load()
+
+    response = model.chat([{"role": "user", "content": "Say: Horus ready GGUF works."}])
+    print("\nChat preview:")
+    print(response.content[:200])
+    model.unload()
+
+    # Quick benchmark helper (latency-oriented).
+    benchmark = nn.HorusModel.benchmark_variants(
+        model_ids=[q4_model_id],
+        prompt="Explain TurboQuant in one line.",
+        runs=2,
+        cache_dir=r"D:\Work Space\NeuralNode\hf_cache",
+        local_files_only=True,
+        max_new_tokens=48,
+    )
+    print("\nBenchmark:")
+    print(json.dumps(benchmark, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()
+

neuralnode-2.0.4/neuralnode_horus_replica_telegram.ipynb

@@ -0,0 +1,404 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# NeuralNode v2.0.2 - Horus Q8 + Replica + Thinking Mode + Telegram\n",
+    "\n",
+    "This notebook demonstrates:\n",
+    "- Loading Horus Q8 model\n",
+    "- Replica TTS integration (Female EN-US)\n",
+    "- Interactive chat with voice output\n",
+    "- Thinking mode toggle\n",
+    "- Optional Telegram bot integration"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Install NeuralNode v2.0.2 and all dependencies\n",
+    "!pip install neuralnode==2.0.2\n",
+    "\n",
+    "# Install Horus + Replica dependencies\n",
+    "!pip install llama-cpp-python huggingface-hub torch transformers\n",
+    "\n",
+    "# Install Replica TTS dependency\n",
+    "!pip install edge-tts>=6.1.0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Install NeuralNode v2.0.2\n",
+    "!pip install neuralnode==2.0.2\n",
+    "\n",
+    "# Install Horus extras for GGUF support\n",
+    "!pip install llama-cpp-python huggingface-hub torch transformers"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 2: Import Libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import neuralnode as nn\n",
+    "import os\n",
+    "import time\n",
+    "from IPython.display import Audio, display, clear_output"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 3: Configuration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Configuration\n",
+    "MODEL_ID = \"tokenaii/Hours-1.0-4B-GGUF/Horus-1.0-4B-Q8_0.gguf\"  # Q8 version\n",
+    "CACHE_DIR = \"/content/neuralnode_models\"  # Colab path\n",
+    "REPLICA_VOICE = \"replic-aria-language{en-us}\"  # Female EN-US\n",
+    "TELEGRAM_TOKEN = \"8517902003:AAHgTvh353QekvWFKX3744yH4-72kfwfe9A\"\n",
+    "\n",
+    "# Options\n",
+    "ENABLE_THINKING = True  # Toggle thinking mode\n",
+    "ENABLE_TELEGRAM = False  # Toggle Telegram bot\n",
+    "\n",
+    "print(\"✅ Configuration loaded\")\n",
+    "print(f\"Model: {MODEL_ID}\")\n",
+    "print(f\"Voice: {REPLICA_VOICE}\")\n",
+    "print(f\"Thinking Mode: {ENABLE_THINKING}\")\n",
+    "print(f\"Telegram Bot: {ENABLE_TELEGRAM}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 4: Load Horus Q8 Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create cache directory\n",
+    "os.makedirs(CACHE_DIR, exist_ok=True)\n",
+    "\n",
+    "# Load Horus model with all features\n",
+    "print(\"⏳ Loading Horus Q8 model...\")\n",
+    "print(\"This may take 5-10 minutes on first download...\")\n",
+    "\n",
+    "model = nn.HorusModel(\n",
+    "    model_id=MODEL_ID,\n",
+    "    device=\"cpu\",\n",
+    "    cache_dir=CACHE_DIR,\n",
+    "    n_ctx=8192,  # Original context window\n",
+    "    verbose=False\n",
+    ").load()\n",
+    "\n",
+    "print(\"✅ Model loaded successfully!\")\n",
+    "print(f\"Context Window: 8192 tokens\")\n",
+    "print(f\"Chat Template: horus_unified\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 5: Setup Replica TTS"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Initialize Replica TTS\n",
+    "tts = nn.ReplicaTTS(voice_id=REPLICA_VOICE)\n",
+    "\n",
+    "# Test voice\n",
+    "print(\"🔊 Testing Replica TTS...\")\n",
+    "tts.save_to_file(\"Hello! I'm ready to chat with you.\", \"/content/test_voice.mp3\")\n",
+    "display(Audio(\"/content/test_voice.mp3\", autoplay=True))\n",
+    "print(\"✅ Voice test complete!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 6: Setup Thinking Mode (Optional)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if ENABLE_THINKING:\n",
+    "    # Wrap model with thinking mode\n",
+    "    thinker = nn.ThinkingMode(\n",
+    "        model,\n",
+    "        steps=[\"understand\", \"plan\", \"execute\", \"verify\"],\n",
+    "        show_thinking=True,\n",
+    "        concise=True,\n",
+    "        max_tokens_per_step=100,\n",
+    "        max_final_tokens=200\n",
+    "    )\n",
+    "    chat_model = thinker\n",
+    "    print(\"🧠 Thinking Mode: ENABLED\")\n",
+    "    print(\"Thinking will be shown between <think> tags\")\n",
+    "else:\n",
+    "    chat_model = model\n",
+    "    print(\"🧠 Thinking Mode: DISABLED\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 7: Chat Function with Voice Output"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def chat_with_voice(user_message, show_thinking=ENABLE_THINKING):\n",
+    "    \"\"\"Chat with Horus and get voice response\"\"\"\n",
+    "    \n",
+    "    print(f\"\\n👤 You: {user_message}\")\n",
+    "    print(\"🤖 Horus is thinking...\")\n",
+    "    \n",
+    "    if show_thinking and ENABLE_THINKING:\n",
+    "        # Get response with thinking\n",
+    "        response = chat_model.chat(user_message)\n",
+    "        \n",
+    "        # Display thinking\n",
+    "        if response.thinking:\n",
+    "            print(\"\\n🧠 <think>\")\n",
+    "            print(response.thinking)\n",
+    "            print(\"</think>\")\n",
+    "        \n",
+    "        text_response = response.content\n",
+    "    else:\n",
+    "        # Normal chat\n",
+    "        messages = [{\"role\": \"user\", \"content\": user_message}]\n",
+    "        response = model.chat(messages, max_new_tokens=200)\n",
+    "        text_response = response.content\n",
+    "    \n",
+    "    # Generate audio\n",
+    "    audio_file = f\"/content/response_{int(time.time())}.mp3\"\n",
+    "    tts.save_to_file(text_response, audio_file)\n",
+    "    \n",
+    "    # Play audio\n",
+    "    print(\"\\n🔊 Audio Response:\")\n",
+    "    display(Audio(audio_file, autoplay=True))\n",
+    "    \n",
+    "    # Display text\n",
+    "    print(\"\\n📝 Text Response:\")\n",
+    "    print(f\"🤖 Horus: {text_response}\")\n",
+    "    \n",
+    "    return text_response\n",
+    "\n",
+    "print(\"✅ Chat function ready!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 8: Interactive Chat (Try it!)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example 1: Simple greeting\n",
+    "chat_with_voice(\"Hello! Introduce yourself briefly.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example 2: Ask a question\n",
+    "chat_with_voice(\"What is 15 times 23?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example 3: Complex question (shows thinking if enabled)\n",
+    "chat_with_voice(\"Explain how photosynthesis works in simple terms.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 9: Custom Chat (Enter your own message)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Type your own message here\n",
+    "your_message = \"Tell me a short joke\"  # Change this to your message\n",
+    "\n",
+    "chat_with_voice(your_message)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 10: Telegram Bot Setup (Optional)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if ENABLE_TELEGRAM:\n",
+    "    print(\"🤖 Setting up Telegram Bot...\")\n",
+    "    \n",
+    "    # Create NeuralNode instance\n",
+    "    ai = nn.NeuralNode(\n",
+    "        provider=\"horus\",\n",
+    "        model=MODEL_ID,\n",
+    "        model_settings={\"cache_dir\": CACHE_DIR}\n",
+    "    )\n",
+    "    \n",
+    "    # Create agent with thinking\n",
+    "    agent = ai.agent(\n",
+    "        agent_type=\"simple\",\n",
+    "        skills=[\"datetime\"],\n",
+    "        thinking=ENABLE_THINKING\n",
+    "    )\n",
+    "    \n",
+    "    # Configure bot\n",
+    "    bot_config = nn.TelegramBotConfig(\n",
+    "        token=TELEGRAM_TOKEN,\n",
+    "        enable_voice=True,\n",
+    "        enable_documents=True,\n",
+    "        reply_mode=\"both\",  # text + voice\n",
+    "        voice_reply_voice_id=REPLICA_VOICE,\n",
+    "    )\n",
+    "    \n",
+    "    # Create bot\n",
+    "    bot = nn.TelegramBot(\n",
+    "        token=TELEGRAM_TOKEN,\n",
+    "        agent=agent,\n",
+    "        config=bot_config,\n",
+    "    )\n",
+    "    \n",
+    "    print(\"✅ Telegram bot configured!\")\n",
+    "    print(\"\\n🚀 To start the bot, run:\")\n",
+    "    print(\"   bot.start()\")\n",
+    "    print(\"\\n⚠️  Note: This will block the notebook until stopped\")\n",
+    "    print(\"   Press Ctrl+C to stop\")\n",
+    "    \n",
+    "    # Ask before starting\n",
+    "    start = input(\"\\nStart Telegram bot now? (y/n): \").lower().strip()\n",
+    "    if start == \"y\":\n",
+    "        print(\"\\n🟢 Starting Telegram bot...\")\n",
+    "        print(\"You can now chat with Horus on Telegram!\")\n",
+    "        try:\n",
+    "            bot.start()\n",
+    "        except KeyboardInterrupt:\n",
+    "            print(\"\\n🛑 Bot stopped by user\")\n",
+    "else:\n",
+    "    print(\"⏸️  Telegram bot disabled. Set ENABLE_TELEGRAM = True to enable.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Summary & Quick Reference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Quick reference\n",
+    "print(\"═\" * 60)\n",
+    "print(\"NeuralNode v2.0.2 - Horus + Replica Demo\")\n",
+    "print(\"═\" * 60)\n",
+    "print(\"\\n✅ Features Ready:\")\n",
+    "print(f\"   • Model: Horus Q8 (8192 context)\")\n",
+    "print(f\"   • Voice: Replica {REPLICA_VOICE}\")\n",
+    "print(f\"   • Thinking: {'ON' if ENABLE_THINKING else 'OFF'}\")\n",
+    "print(f\"   • Telegram: {'ON' if ENABLE_TELEGRAM else 'OFF'}\")\n",
+    "print(\"\\n📌 Quick Commands:\")\n",
+    "print(\"   chat_with_voice('Your message')\")\n",
+    "print(\"\\n📝 Notes:\")\n",
+    "print(\"   • Change ENABLE_THINKING to toggle thinking mode\")\n",
+    "print(\"   • Change ENABLE_TELEGRAM to toggle Telegram bot\")\n",
+    "print(\"   • Voice responses auto-play\")\n",
+    "print(\"   • Text responses shown below audio\")\n",
+    "print(\"═\" * 60)"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "gpuType": "T4",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.10.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

{neuralnode-2.0.2 → neuralnode-2.0.4}/pyproject.toml

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

@@ -42,7 +42,7 @@ Quick Start::
     text = sr.listen()
 """
 
-__version__ = "2.0.2"
+__version__ = "2.0.4"
 __author__ = "NeuralNode Contributors"
 
 # ── Core types ────────────────────────────────────────────────────────────────
@@ -227,6 +227,7 @@ except ImportError:
 
 # Logging helper
 from .utils.logger import get_logger, setup_logging
+from .utils.dependencies import ensure_feature_dependencies
 
 
 
@@ -681,6 +682,7 @@ __all__ = [
 
     # Utilities
     "get_logger", "setup_logging",
+    "ensure_feature_dependencies",
     "check_openai_blocked",
 ]
 

{neuralnode-2.0.2 → neuralnode-2.0.4}/src/neuralnode/integrations/slack.py

@@ -182,10 +182,9 @@ class SlackBot:
             handler = SocketModeHandler(self.app, self.app_token)
             handler.start()
         else:
-            # HTTP mode
-            from slack_bolt.adapter.fastapi import SlackRequestHandler
-            # Run as FastAPI app
-            pass
+            # HTTP mode (built-in Bolt web server)
+            self.logger.info(f"Starting Slack HTTP mode on port {port}")
+            self.app.start(port=port)
 
 
 def create_slack_bot(

{neuralnode-2.0.2 → neuralnode-2.0.4}/src/neuralnode/integrations/telegram.py

@@ -14,6 +14,8 @@ import json
 import os
 import re
 import tempfile
+import urllib.error
+import urllib.request
 from dataclasses import dataclass, field
 from datetime import datetime
 from pathlib import Path
@@ -22,6 +24,7 @@ from typing import Any, Dict, List, Optional
 from ..agents import _strip_thinking
 from ..core import BaseAgent, ensure_llm_response
 from ..rag import load_documents
+from ..utils.dependencies import ensure_feature_dependencies
 
 try:
     from telegram import Update
@@ -32,6 +35,29 @@ except ImportError:
     TELEGRAM_AVAILABLE = False
 
 
+def _refresh_telegram_imports() -> None:
+    global TELEGRAM_AVAILABLE, Update, Application, CommandHandler, ContextTypes, MessageHandler, filters
+    try:
+        from telegram import Update as _Update
+        from telegram.ext import (
+            Application as _Application,
+            CommandHandler as _CommandHandler,
+            ContextTypes as _ContextTypes,
+            MessageHandler as _MessageHandler,
+            filters as _filters,
+        )
+
+        Update = _Update
+        Application = _Application
+        CommandHandler = _CommandHandler
+        ContextTypes = _ContextTypes
+        MessageHandler = _MessageHandler
+        filters = _filters
+        TELEGRAM_AVAILABLE = True
+    except ImportError:
+        TELEGRAM_AVAILABLE = False
+
+
 @dataclass
 class TelegramSession:
     """User session in Telegram bot."""
@@ -67,6 +93,8 @@ class TelegramBotConfig:
     document_chunk_limit: int = 6
     max_document_chars: int = 16000
     download_dir: Optional[str] = None
+    validate_token_on_start: bool = True
+    auto_install_deps: bool = True
 
 
 class TelegramBot:
@@ -79,6 +107,10 @@ class TelegramBot:
         config: Optional[TelegramBotConfig] = None,
         system_prompt: Optional[str] = None,
     ):
+        self.config = config or TelegramBotConfig(token=token)
+        if not TELEGRAM_AVAILABLE and self.config.auto_install_deps:
+            ensure_feature_dependencies("telegram", auto_install=True)
+            _refresh_telegram_imports()
         if not TELEGRAM_AVAILABLE:
             raise ImportError(
                 "python-telegram-bot required. Install with: pip install python-telegram-bot"
@@ -86,7 +118,6 @@ class TelegramBot:
 
         self.token = token
         self.agent = agent
-        self.config = config or TelegramBotConfig(token=token)
         self.system_prompt = system_prompt or "You are a helpful AI assistant on Telegram."
 
         self.sessions: Dict[int, TelegramSession] = {}
@@ -139,6 +170,16 @@ class TelegramBot:
         target.mkdir(parents=True, exist_ok=True)
         return target
 
+    def validate_token(self, timeout: int = 10) -> bool:
+        """Validate BotFather token against Telegram `getMe` endpoint."""
+        url = f"https://api.telegram.org/bot{self.token}/getMe"
+        try:
+            with urllib.request.urlopen(url, timeout=timeout) as response:
+                payload = json.loads(response.read().decode("utf-8", errors="ignore"))
+            return bool(payload.get("ok"))
+        except (urllib.error.URLError, TimeoutError, ValueError):
+            return False
+
     async def _download_telegram_file(self, file_id: str, filename: str) -> Path:
         telegram_file = await self.application.bot.get_file(file_id)
         target = self._get_download_dir() / filename
@@ -482,6 +523,8 @@ class TelegramBot:
         if self._running:
             print("Bot is already running.")
             return
+        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.application = Application.builder().token(self.token).build()
         self._setup_handlers()
@@ -494,6 +537,8 @@ class TelegramBot:
         self._running = True
 
         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.application = Application.builder().token(self.token).build()
             self._setup_handlers()
             await self.application.initialize()

{neuralnode-2.0.2 → neuralnode-2.0.4}/src/neuralnode/integrations/whatsapp.py

@@ -191,13 +191,22 @@ class WhatsAppWebBot:
         """
         self.logger.info("Starting WhatsApp Web (unofficial)...")
         self.logger.warning("Using unofficial library - may break with WhatsApp updates")
-        
-        # Note: This is a placeholder as the actual implementation
-        # depends on the specific library version and is subject to change
-        # Users should refer to the library's documentation
-        raise NotImplementedError(
-            "WhatsApp Web integration requires manual setup. "
-            "Please refer to whatsapp-web.py documentation."
+
+        # Initialize client from the installed whatsapp library and run it
+        # using whichever startup method is available in that version.
+        self.client = WhatsAppClient()
+
+        start_methods = ("start", "run", "run_forever", "listen")
+        for method_name in start_methods:
+            method = getattr(self.client, method_name, None)
+            if callable(method):
+                self.logger.info(f"WhatsApp Web client starting via `{method_name}()`")
+                method()
+                return
+
+        raise RuntimeError(
+            "Unsupported whatsapp-web client API. "
+            "Expected one of: start(), run(), run_forever(), listen()."
         )