neuralnode 2.1.2__tar.gz → 2.1.4__tar.gz

{neuralnode-2.1.2 → neuralnode-2.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuralnode
-Version: 2.1.2
+Version: 2.1.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
@@ -92,9 +92,11 @@ Requires-Dist: groq>=0.4.0; extra == 'groq'
 Provides-Extra: horus
 Requires-Dist: accelerate>=0.24.0; extra == 'horus'
 Requires-Dist: bitsandbytes>=0.41.0; extra == 'horus'
+Requires-Dist: diffusers>=0.30.0; extra == 'horus'
 Requires-Dist: einops>=0.7.0; extra == 'horus'
 Requires-Dist: huggingface-hub>=0.23.0; extra == 'horus'
 Requires-Dist: llama-cpp-python>=0.2.0; extra == 'horus'
+Requires-Dist: pillow>=10.0.0; extra == 'horus'
 Requires-Dist: protobuf>=3.20.0; extra == 'horus'
 Requires-Dist: scipy>=1.10.0; extra == 'horus'
 Requires-Dist: sentencepiece>=0.1.99; extra == 'horus'
@@ -210,6 +212,8 @@ All Horus models use:
 - unified chat template: `horus_unified`
 - unified context window: `8192`
 
+Horus downloads are public-only. Private or gated Hugging Face repositories are not supported.
+
 ```python
 import neuralnode as nn
 
@@ -243,6 +247,20 @@ Supported IDs currently include:
 - `tokenaii/Horus-1.0-4B-GGUF/Horus-1.0-4B-Q6_K.gguf`
 - `tokenaii/Horus-1.0-4B-GGUF/Horus-1.0-4B-Q8_0.gguf`
 - `tokenaii/Horus-1.0-4B-GGUF/Horus-1.0-4B-F16.gguf`
+- `tokenaii/Horus-Lens-1.0`
+
+### Horus Lens text-to-image
+
+```python
+import neuralnode as nn
+
+model = nn.HorusLensModel("tokenaii/Horus-Lens-1.0").load()
+model.generate_image(
+    "A detailed cinematic image of an ancient Egyptian AI lab, golden light",
+    output_path="outputs/horus_lens.png",
+    seed=42,
+)
+```
 
 ## Replica TTS
 

{neuralnode-2.1.2 → neuralnode-2.1.4}/README.md

@@ -44,6 +44,8 @@ All Horus models use:
 - unified chat template: `horus_unified`
 - unified context window: `8192`
 
+Horus downloads are public-only. Private or gated Hugging Face repositories are not supported.
+
 ```python
 import neuralnode as nn
 
@@ -77,6 +79,20 @@ Supported IDs currently include:
 - `tokenaii/Horus-1.0-4B-GGUF/Horus-1.0-4B-Q6_K.gguf`
 - `tokenaii/Horus-1.0-4B-GGUF/Horus-1.0-4B-Q8_0.gguf`
 - `tokenaii/Horus-1.0-4B-GGUF/Horus-1.0-4B-F16.gguf`
+- `tokenaii/Horus-Lens-1.0`
+
+### Horus Lens text-to-image
+
+```python
+import neuralnode as nn
+
+model = nn.HorusLensModel("tokenaii/Horus-Lens-1.0").load()
+model.generate_image(
+    "A detailed cinematic image of an ancient Egyptian AI lab, golden light",
+    output_path="outputs/horus_lens.png",
+    seed=42,
+)
+```
 
 ## Replica TTS
 

{neuralnode-2.1.2 → neuralnode-2.1.4}/docs/documentation.md

@@ -103,6 +103,7 @@ Current Horus guarantees:
 - chat template is unified as `horus_unified`
 - Horus can use Replica TTS
 - Horus can use TurboQuant on Transformers-based generation paths
+- Horus downloads are public-only
 
 Example:
 
@@ -133,6 +134,20 @@ Available Horus model IDs:
 - `tokenaii/Horus-1.0-4B-GGUF/Horus-1.0-4B-Q6_K.gguf`
 - `tokenaii/Horus-1.0-4B-GGUF/Horus-1.0-4B-Q8_0.gguf`
 - `tokenaii/Horus-1.0-4B-GGUF/Horus-1.0-4B-F16.gguf`
+- `tokenaii/Horus-Lens-1.0`
+
+Horus Lens text-to-image example:
+
+```python
+import neuralnode as nn
+
+model = nn.HorusLensModel("tokenaii/Horus-Lens-1.0").load()
+model.generate_image(
+    "A detailed cinematic image of an ancient Egyptian AI lab, golden light",
+    output_path="outputs/horus_lens.png",
+    seed=42,
+)
+```
 
 ## Replica
 

neuralnode-2.1.4/examples/horus_codes_camples/02_horus_lens.py

@@ -0,0 +1,16 @@
+"""
+Generate an image with Horus Lens.
+"""
+
+import neuralnode as nn
+
+
+model = nn.HorusLensModel("tokenaii/Horus-Lens-1.0").load()
+
+model.generate_image(
+    "A detailed cinematic image of an ancient Egyptian AI lab, golden light",
+    output_path="outputs/horus_lens.png",
+    seed=42,
+)
+
+print("Saved image to outputs/horus_lens.png")

{neuralnode-2.1.2 → neuralnode-2.1.4}/examples/horus_codes_camples/README.md

@@ -12,6 +12,7 @@ This folder contains code examples for downloading and using Horus models.
 | `tokenaii/Horus-1.0-4B-GGUF/Horus-1.0-4B-Q6_K.gguf` | 3.71 GB | GGUF 6-bit | Better quality with reasonable memory |
 | `tokenaii/Horus-1.0-4B-GGUF/Horus-1.0-4B-Q8_0.gguf` | 4.8 GB | GGUF 8-bit | Good quality with ~50% memory savings |
 | `tokenaii/Horus-1.0-4B-GGUF/Horus-1.0-4B-F16.gguf` | 9.83 GB | GGUF 16-bit | Maximum quality, same as original |
+| `tokenaii/Horus-Lens-1.0` | Unknown | Text-to-image | Image generation from prompts |
 
 ## Installation
 
@@ -33,7 +34,7 @@ print(response.content)
 
 ### Basic Usage
 - `01_basic_usage.py` - Simple download and use
-- `02_with_token.py` - Private models with HF token
+- `02_horus_lens.py` - Generate an image with Horus Lens
 - `03_one_liner.py` - One-liner usage
 - `04_custom_cache.py` - Custom download location
 

neuralnode-2.1.4/examples/horus_download_guide.py

@@ -0,0 +1,39 @@
+"""
+Horus public model download and usage guide.
+
+NeuralNode Horus downloads are public-only. If a Hugging Face repository is
+private or gated, loading fails instead of using credentials.
+"""
+
+import neuralnode as nn
+
+
+def example_simple_chat_model():
+    model = nn.HorusModel("tokenaii/horus").load()
+    response = model.chat([{"role": "user", "content": "Hello!"}])
+    print(response.content)
+
+
+def example_custom_cache():
+    model = nn.HorusModel(
+        "tokenaii/horus",
+        cache_dir="D:/Models/Horus",
+    ).load()
+    print(model.get_model_info())
+
+
+def example_lens_image():
+    model = nn.HorusLensModel("tokenaii/Horus-Lens-1.0").load()
+    model.generate_image(
+        "A cinematic portrait of an ancient Egyptian AI oracle, detailed, warm light",
+        output_path="outputs/horus_lens.png",
+        seed=42,
+    )
+    print("Saved image to outputs/horus_lens.png")
+
+
+if __name__ == "__main__":
+    print(nn.HorusModel.list_available_models())
+    example_simple_chat_model()
+    example_custom_cache()
+    example_lens_image()

{neuralnode-2.1.2 → neuralnode-2.1.4}/examples/horus_transformers_features.py

@@ -292,21 +292,12 @@ def example_8_generation_params():
     print()
 
 
-def example_9_network_auth():
-    """Network and authentication options."""
+def example_9_network_options():
+    """Network and download options."""
     print("=" * 70)
-    print("Example 9: Network & Authentication")
+    print("Example 9: Network & Download Options")
     print("=" * 70)
-    
-    # With HuggingFace token (for private/gated models)
-    model_token = nn.HorusModel(
-        "tokenaii/horus",
-        token="hf_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-    ).load()
-    
-    # Via environment variable (recommended):
-    # export HF_TOKEN="your_token_here"
-    
+
     # With proxy
     model_proxy = nn.HorusModel(
         "tokenaii/horus",
@@ -328,7 +319,7 @@ def example_9_network_auth():
         resume_download=True,
     ).load()
     
-    print("[OK] Network & auth options demonstrated")
+    print("[OK] Network and download options demonstrated")
     print()
 
 
@@ -492,7 +483,7 @@ if __name__ == "__main__":
         # example_6_attention_options()
         # example_7_advanced_loading()
         # example_8_generation_params()
-        # example_9_network_auth()
+        # example_9_network_options()
         # example_10_model_info()
         example_11_list_models()
         # example_12_chat_templates()

{neuralnode-2.1.2 → neuralnode-2.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "neuralnode"
-version = "2.1.2"
+version = "2.1.4"
 description = "Comprehensive AI Framework with 50+ LLM Providers, Advanced Agents, Chains, Memory, RAG, and 100+ Tools"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -66,12 +66,14 @@ horus = [
     "huggingface_hub>=0.23.0",
     "torch>=2.0.0",
     "transformers>=4.35.0",
+    "diffusers>=0.30.0",
     "accelerate>=0.24.0",
     "bitsandbytes>=0.41.0",        # 4-bit/8-bit quantization
     "sentencepiece>=0.1.99",        # Tokenization
     "protobuf>=3.20.0",             # Model serialization
     "scipy>=1.10.0",                # Math operations
     "einops>=0.7.0",                # Tensor operations
+    "pillow>=10.0.0",               # Image output
 ]
 
 # Flash Attention (Windows requires special install)

{neuralnode-2.1.2 → neuralnode-2.1.4}/src/neuralnode/__init__.py

@@ -42,7 +42,7 @@ Quick Start::
     text = sr.listen()
 """
 
-__version__ = "2.1.2"
+__version__ = "2.1.4"
 __author__ = "NeuralNode Contributors"
 
 # ── Core types ────────────────────────────────────────────────────────────────
@@ -83,8 +83,11 @@ from .providers import (
     UniversalLocalProvider,
     # Custom models
     Horus,
+    HorusLensModel,
     HorusModel,
     HorusProvider,
+    load_horus_lens,
+    print_model_list,
 )
 
 # ── Memory ────────────────────────────────────────────────────────────────────
@@ -648,7 +651,7 @@ __all__ = [
     "OllamaProvider", "AnthropicProvider", "GoogleProvider",
     "GroqProvider", "MistralProvider", "CohereProvider", "DeepSeekProvider",
     "LlamaCppProvider", "TransformersProvider", "UniversalLocalProvider",
-    "Horus", "HorusModel", "HorusProvider",
+    "Horus", "HorusLensModel", "HorusModel", "HorusProvider", "load_horus_lens", "print_model_list",
 
     # Memory
     "ConversationMemory", "FileMemory", "SlidingWindowMemory", "SummaryMemory",

{neuralnode-2.1.2 → neuralnode-2.1.4}/src/neuralnode/providers/__init__.py

@@ -108,12 +108,15 @@ from .universal_local import UniversalLocalProvider, load_local_model
 
 # ── Custom Model Providers ─────────────────────────────────────────────────────
 try:
-    from .horus import HorusProvider, HorusModel, Horus, load_horus
+    from .horus import HorusProvider, HorusModel, HorusLensModel, Horus, load_horus, load_horus_lens, print_model_list
 except ImportError:
     HorusProvider = None  # type: ignore
     HorusModel = None  # type: ignore
+    HorusLensModel = None  # type: ignore
     Horus = None  # type: ignore
     load_horus = None  # type: ignore
+    load_horus_lens = None  # type: ignore
+    print_model_list = None  # type: ignore
 
 # MLX Provider (Apple Silicon — optional)
 try:
@@ -235,5 +238,5 @@ __all__ = [
     "UniversalLocalProvider", "load_local_model",
     
     # Custom Models
-    "HorusProvider", "HorusModel", "Horus", "load_horus",
+    "HorusProvider", "HorusModel", "HorusLensModel", "Horus", "load_horus", "load_horus_lens", "print_model_list",
 ]

{neuralnode-2.1.2 → neuralnode-2.1.4}/src/neuralnode/providers/horus.py

@@ -34,6 +34,14 @@ except ImportError:
     AutoTokenizer = None
     TextIteratorStreamer = None
 
+try:
+    from diffusers import DiffusionPipeline
+
+    DIFFUSERS_AVAILABLE = True
+except ImportError:
+    DIFFUSERS_AVAILABLE = False
+    DiffusionPipeline = None
+
 try:
     import llama_cpp
     from llama_cpp import Llama
@@ -70,6 +78,17 @@ def _refresh_transformers_imports() -> None:
         TRANSFORMERS_AVAILABLE = False
 
 
+def _refresh_diffusers_imports() -> None:
+    global DIFFUSERS_AVAILABLE, DiffusionPipeline
+    try:
+        from diffusers import DiffusionPipeline as _DiffusionPipeline
+
+        DiffusionPipeline = _DiffusionPipeline
+        DIFFUSERS_AVAILABLE = True
+    except ImportError:
+        DIFFUSERS_AVAILABLE = False
+
+
 def _refresh_llama_imports() -> None:
     global LLAMA_CPP_AVAILABLE, llama_cpp, Llama
     try:
@@ -205,6 +224,14 @@ class HorusProvider(BaseLLMProvider):
             "quantization": "F16",
             "file_size": "9.83 GB",
         },
+        "tokenaii/Horus-Lens-1.0": {
+            "name": "Horus-Lens-1.0",
+            "official_name": "Horus-Lens-1.0",
+            "size": "Unknown",
+            "type": "text-to-image",
+            "repo_id": "tokenaii/Horus-Lens-1.0",
+            "task": "text-to-image",
+        },
     }
 
     CHAT_TEMPLATES = {
@@ -276,20 +303,36 @@ class HorusProvider(BaseLLMProvider):
         **kwargs,
     ):
         self.auto_install_deps = auto_install_deps
-        if not self._is_gguf_model_id(model_id) and not TRANSFORMERS_AVAILABLE and self.auto_install_deps:
+
+        # `create_provider("horus", model="...")` passes `model`; map it to Horus `model_id`.
+        forwarded_model = kwargs.pop("model", None)
+        if forwarded_model:
+            model_id = str(forwarded_model)
+
+        # Case-insensitive normalization of model_id to match keys in HORUS_MODELS
+        matched_key = None
+        for k in self.HORUS_MODELS.keys():
+            if k.lower() == model_id.lower():
+                matched_key = k
+                break
+        if matched_key:
+            model_id = matched_key
+
+        is_lens_model = self._is_text_to_image_model_id(model_id)
+        if (
+            not is_lens_model
+            and not self._is_gguf_model_id(model_id)
+            and not TRANSFORMERS_AVAILABLE
+            and self.auto_install_deps
+        ):
             ensure_feature_dependencies("horus_transformers", auto_install=True)
             _refresh_transformers_imports()
-        if not self._is_gguf_model_id(model_id) and not TRANSFORMERS_AVAILABLE:
+        if not is_lens_model and not self._is_gguf_model_id(model_id) and not TRANSFORMERS_AVAILABLE:
             raise ImportError(
                 "transformers and torch are required for Horus transformers models. "
                 "Install with: pip install transformers torch"
             )
 
-        # `create_provider("horus", model="...")` passes `model`; map it to Horus `model_id`.
-        forwarded_model = kwargs.pop("model", None)
-        if forwarded_model:
-            model_id = str(forwarded_model)
-
         super().__init__(model=model_id, **kwargs)
 
         self.model_id = model_id
@@ -316,7 +359,9 @@ class HorusProvider(BaseLLMProvider):
         self.local_files_only = local_files_only
         self.trust_remote_code = trust_remote_code
 
-        self.token = token or os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_TOKEN")
+        if token and not suppress_warnings:
+            logger.warning("Horus downloads are public-only; the provided credential was ignored.")
+        self.token = None
         self.proxies = proxies
         self.force_download = force_download
         self.resume_download = resume_download
@@ -414,12 +459,26 @@ class HorusProvider(BaseLLMProvider):
     def _is_gguf_model_id(model_id: str) -> bool:
         return model_id.lower().endswith(".gguf")
 
+    @classmethod
+    def _is_text_to_image_model_id(cls, model_id: str) -> bool:
+        if not model_id:
+            return False
+        info = cls.HORUS_MODELS.get(model_id, {})
+        if str(info.get("type", "")).lower() == "text-to-image":
+            return True
+        return "lens" in model_id.lower()
+
     def _build_model_info(self) -> Dict[str, Any]:
         base = dict(self.HORUS_MODELS.get(self.model_id, {}))
         base.setdefault("name", self.model_id.split("/")[-1])
         base.setdefault("official_name", self._infer_official_name(self.model_id))
         base.setdefault("size", "Unknown")
-        base.setdefault("type", "gguf" if self._is_gguf_model_id(self.model_id) else "safetensors")
+        base.setdefault(
+            "type",
+            "text-to-image"
+            if self._is_text_to_image_model_id(self.model_id)
+            else ("gguf" if self._is_gguf_model_id(self.model_id) else "safetensors"),
+        )
         if base.get("type") == "gguf" and "quantization" not in base:
             _, filename = self._split_repo_and_filename(self.model_id)
             quant_match = re.search(r"-(Q\d(?:_[A-Z0-9]+)?|TQ\d(?:_[A-Z0-9]+)?|F16|BF16)\.gguf$", filename, flags=re.IGNORECASE)
@@ -443,6 +502,8 @@ class HorusProvider(BaseLLMProvider):
         self._configure_external_logging()
         if self.model is not None:
             return self
+        if self._is_text_to_image_model_id(self.model_id):
+            return self._load_text_to_image()
         if self._is_gguf_model_id(self.model_id):
             return self._load_gguf()
         return self._load_transformers()
@@ -460,6 +521,85 @@ class HorusProvider(BaseLLMProvider):
         except Exception:
             pass
 
+    def _load_text_to_image(self) -> "HorusProvider":
+        if not DIFFUSERS_AVAILABLE and self.auto_install_deps:
+            ensure_feature_dependencies("horus_lens", auto_install=True)
+            _refresh_diffusers_imports()
+            _refresh_transformers_imports()
+        if not DIFFUSERS_AVAILABLE:
+            raise ImportError(
+                "diffusers, transformers, torch, accelerate, and pillow are required for Horus Lens.\n"
+                "Install with:\n"
+                "  pip install \"neuralnode[horus]\"\n"
+                "or:\n"
+                "  pip install diffusers transformers torch accelerate pillow"
+            )
+        if torch is None:
+            _refresh_transformers_imports()
+        if torch is None:
+            raise ImportError("torch is required for Horus Lens text-to-image generation.")
+
+        repo_id = self._model_info.get("repo_id", self.model_id)
+        pipeline_kwargs: Dict[str, Any] = {
+            "cache_dir": self.cache_dir,
+            "local_files_only": self.local_files_only,
+            "trust_remote_code": self.trust_remote_code,
+        }
+        if self.revision:
+            pipeline_kwargs["revision"] = self.revision
+        if self.variant:
+            pipeline_kwargs["variant"] = self.variant
+        if self.torch_dtype is not None:
+            pipeline_kwargs["torch_dtype"] = self.torch_dtype
+
+        try:
+            # Check if this model is Horus-Lens-1.0 which requires custom component mapping
+            if "horus-lens-1.0" in repo_id.lower():
+                try:
+                    try:
+                        from diffusers import ZImagePipeline
+                    except ImportError:
+                        from diffusers.pipelines.z_image.pipeline_z_image import ZImagePipeline
+
+                    class PatchedZImagePipeline(ZImagePipeline):
+                        def __init__(
+                            self,
+                            horus_scheduler,
+                            horus_text_encoder,
+                            horus_tokenizer,
+                            horus_transformer,
+                            horus_vae,
+                        ):
+                            super().__init__(
+                                scheduler=horus_scheduler,
+                                text_encoder=horus_text_encoder,
+                                tokenizer=horus_tokenizer,
+                                transformer=horus_transformer,
+                                vae=horus_vae,
+                            )
+                    
+                    self.model = DiffusionPipeline.from_pretrained(
+                        repo_id,
+                        pipeline_class=PatchedZImagePipeline,
+                        **pipeline_kwargs
+                    )
+                except Exception:
+                    # Fallback to default load if patch fails
+                    self.model = DiffusionPipeline.from_pretrained(repo_id, **pipeline_kwargs)
+            else:
+                self.model = DiffusionPipeline.from_pretrained(repo_id, **pipeline_kwargs)
+        except Exception as exc:
+            raise RuntimeError(
+                f"Failed to load Horus Lens from '{repo_id}'. "
+                "Only public Hugging Face repositories are supported."
+            ) from exc
+
+        if hasattr(self.model, "to"):
+            self.model = self.model.to(self.device)
+        if hasattr(self.model, "set_progress_bar_config") and self.suppress_native_output:
+            self.model.set_progress_bar_config(disable=True)
+        return self
+
     def _load_gguf(self) -> "HorusProvider":
         if not HF_HUB_AVAILABLE and self.auto_install_deps:
             ensure_feature_dependencies("horus_gguf", auto_install=True)
@@ -501,7 +641,6 @@ class HorusProvider(BaseLLMProvider):
                     filename=filename,
                     cache_dir=self.cache_dir,
                     local_files_only=self.local_files_only,
-                    token=self.token,
                 )
             if self.suppress_native_output:
                 if prev_disable_progress is None:
@@ -616,8 +755,6 @@ class HorusProvider(BaseLLMProvider):
             "resume_download": self.resume_download,
             "use_fast": True,
         }
-        if self.token:
-            tokenizer_kwargs["token"] = self.token
         if resolved_subfolder:
             tokenizer_kwargs["subfolder"] = resolved_subfolder
         if self.revision:
@@ -643,8 +780,6 @@ class HorusProvider(BaseLLMProvider):
             "proxies": self.proxies,
             "force_download": self.force_download,
         }
-        if self.token:
-            model_kwargs["token"] = self.token
         if resolved_subfolder:
             model_kwargs["subfolder"] = resolved_subfolder
         if self.revision:
@@ -1027,6 +1162,53 @@ class HorusProvider(BaseLLMProvider):
             return "Hello! How can I help you?"
         return cleaned
 
+    def generate_image(
+        self,
+        prompt: str,
+        output_path: Optional[str] = None,
+        negative_prompt: Optional[str] = None,
+        width: Optional[int] = None,
+        height: Optional[int] = None,
+        num_inference_steps: int = 30,
+        guidance_scale: float = 7.5,
+        seed: Optional[int] = None,
+        **kwargs,
+    ) -> Any:
+        """Generate an image with a Horus text-to-image model and optionally save it."""
+        if not self._is_text_to_image_model_id(self.model_id):
+            raise RuntimeError("generate_image is only available for Horus text-to-image models.")
+        self.load()
+        if self.model is None:
+            raise RuntimeError("Horus text-to-image model is not loaded.")
+
+        call_kwargs: Dict[str, Any] = {
+            "prompt": prompt,
+            "num_inference_steps": num_inference_steps,
+            "guidance_scale": guidance_scale,
+            **kwargs,
+        }
+        if negative_prompt:
+            call_kwargs["negative_prompt"] = negative_prompt
+        if width is not None:
+            call_kwargs["width"] = int(width)
+        if height is not None:
+            call_kwargs["height"] = int(height)
+        if seed is not None and torch is not None:
+            generator_device = self.device if self.device == "cuda" else "cpu"
+            call_kwargs["generator"] = torch.Generator(device=generator_device).manual_seed(int(seed))
+
+        with self._quiet_native_output():
+            result = self.model(**call_kwargs)
+        images = getattr(result, "images", None)
+        if not images:
+            raise RuntimeError("Horus text-to-image generation did not return an image.")
+        image = images[0]
+        if output_path:
+            path = Path(output_path)
+            path.parent.mkdir(parents=True, exist_ok=True)
+            image.save(path)
+        return image
+
     def chat(
         self,
         messages: List[Dict[str, Any]],
@@ -1043,6 +1225,9 @@ class HorusProvider(BaseLLMProvider):
         response_format: Optional[Dict] = None,
         **kwargs,
     ) -> Union[LLMResponse, Iterator[StreamingChunk]]:
+        if self._is_text_to_image_model_id(self.model_id):
+            raise RuntimeError("Horus Lens is a text-to-image model. Use generate_image(prompt) instead of chat().")
+
         normalized = self._normalize_messages(messages)
         
         # Add tool descriptions to system prompt if tools are provided
@@ -1108,6 +1293,9 @@ class HorusProvider(BaseLLMProvider):
         return self.chat([{"role": "user", "content": prompt}], model=model, **kwargs)
 
     def stream_chat(self, messages: List[Dict[str, str]], **kwargs) -> Iterator[StreamingChunk]:
+        if self._is_text_to_image_model_id(self.model_id):
+            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)
 
@@ -1515,10 +1703,23 @@ class HorusModel(HorusProvider):
 
 
 Horus = HorusModel
+HorusLensModel = HorusModel
 
 
 def load_horus(model_id: str = "tokenaii/horus", **kwargs) -> HorusProvider:
     return HorusProvider(model_id=model_id, **kwargs).load()
 
 
-__all__ = ["HorusProvider", "HorusModel", "Horus", "load_horus", "print_model_list"]
+def load_horus_lens(model_id: str = "tokenaii/Horus-Lens-1.0", **kwargs) -> HorusProvider:
+    return HorusProvider(model_id=model_id, **kwargs).load()
+
+
+__all__ = [
+    "HorusProvider",
+    "HorusModel",
+    "HorusLensModel",
+    "Horus",
+    "load_horus",
+    "load_horus_lens",
+    "print_model_list",
+]

{neuralnode-2.1.2 → neuralnode-2.1.4}/src/neuralnode/utils/dependencies.py

@@ -22,6 +22,14 @@ FEATURE_DEPENDENCIES: Dict[str, List[Tuple[str, str]]] = {
         ("llama_cpp", "llama-cpp-python>=0.2.0"),
         ("huggingface_hub", "huggingface_hub>=0.23.0"),
     ],
+    "horus_lens": [
+        ("torch", "torch>=2.0.0"),
+        ("diffusers", "diffusers>=0.30.0"),
+        ("transformers", "transformers>=4.35.0"),
+        ("accelerate", "accelerate>=0.24.0"),
+        ("PIL", "pillow>=10.0.0"),
+        ("huggingface_hub", "huggingface_hub>=0.23.0"),
+    ],
     "replica_tts": [
         ("edge_tts", "edge-tts>=6.1.0"),
     ],
@@ -77,4 +85,3 @@ def ensure_feature_dependencies(feature: str, auto_install: bool = True) -> bool
 
 
 __all__ = ["FEATURE_DEPENDENCIES", "ensure_feature_dependencies"]
-