neuralnode 2.1.10__tar.gz → 2.1.12__tar.gz

{neuralnode-2.1.10 → neuralnode-2.1.12}/PKG-INFO

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

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

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

{neuralnode-2.1.10 → neuralnode-2.1.12}/src/neuralnode/providers/horus.py

@@ -477,13 +477,23 @@ class HorusProvider(BaseLLMProvider):
                 with redirect_stdout(devnull), redirect_stderr(devnull):
                     yield
             finally:
-                if old_stdout_fd is not None:
-                    os.dup2(old_stdout_fd, 1)
-                    os.close(old_stdout_fd)
-                if old_stderr_fd is not None:
-                    os.dup2(old_stderr_fd, 2)
-                    os.close(old_stderr_fd)
-                devnull.close()
+                # Always restore fds and close devnull, even if yield raised.
+                try:
+                    if old_stdout_fd is not None:
+                        os.dup2(old_stdout_fd, 1)
+                        os.close(old_stdout_fd)
+                except OSError:
+                    pass
+                try:
+                    if old_stderr_fd is not None:
+                        os.dup2(old_stderr_fd, 2)
+                        os.close(old_stderr_fd)
+                except OSError:
+                    pass
+                try:
+                    devnull.close()
+                except OSError:
+                    pass
 
     def _resolve_device(self) -> str:
         if torch is not None and torch.cuda.is_available():
@@ -532,10 +542,12 @@ class HorusProvider(BaseLLMProvider):
             return False
         if not cls._is_gguf_model_id(model_id):
             return False
-        # Check the registry first
+        # Check the registry first (both 'task' and 'type' fields)
         info = cls.HORUS_MODELS.get(model_id, {})
         if str(info.get("task", "")).lower() == "text-to-image":
             return True
+        if str(info.get("type", "")).lower() == "gguf" and "lens" in model_id.lower():
+            return True
         # Heuristic: "lens" in the model path means text-to-image
         return "lens" in model_id.lower()
 
@@ -661,6 +673,16 @@ class HorusProvider(BaseLLMProvider):
                             self.tokenizer = horus_tokenizer
                             self.transformer = horus_transformer
                             self.vae = horus_vae
+
+                            # Initialize VAE scale factor and image processor
+                            vae_scale = 8
+                            if hasattr(self, "vae") and self.vae is not None:
+                                if hasattr(self.vae, "config") and getattr(self.vae.config, "block_out_channels", None) is not None:
+                                    vae_scale = 2 ** (len(self.vae.config.block_out_channels) - 1)
+                            self.vae_scale_factor = vae_scale
+                            
+                            from diffusers.image_processor import VaeImageProcessor
+                            self.image_processor = VaeImageProcessor(vae_scale_factor=self.vae_scale_factor * 2)
                     
                     self.model = PatchedZImagePipeline.from_pretrained(
                         repo_id,
@@ -721,13 +743,28 @@ class HorusProvider(BaseLLMProvider):
                     "Install with: pip install gguf"
                 )
 
-        # Force diffusers to recognize the newly installed gguf package
+        # Force diffusers to recognize the newly installed gguf package.
+        # Guard against versions like 'N/A' (local/editable builds) that break
+        # packaging.version.parse and cause an InvalidVersion crash inside
+        # diffusers.quantizers.gguf.gguf_quantizer.validate_environment().
         try:
             import sys
+            import importlib.metadata
+            from packaging.version import Version
+            try:
+                raw_version = importlib.metadata.version("gguf")
+                # Validate the version string before injecting it.
+                Version(raw_version)
+                version = raw_version
+            except Exception:
+                # Fall back to a known-good sentinel that satisfies diffusers >= 0.10.0 check
+                version = "0.19.0"
             if "diffusers.utils.import_utils" in sys.modules:
                 sys.modules["diffusers.utils.import_utils"]._gguf_available = True
+                sys.modules["diffusers.utils.import_utils"]._gguf_version = version
             import diffusers.utils.import_utils as diffusers_import_utils
             diffusers_import_utils._gguf_available = True
+            diffusers_import_utils._gguf_version = version
         except Exception:
             pass
 
@@ -791,13 +828,35 @@ class HorusProvider(BaseLLMProvider):
                     **transformer_kwargs
                 )
             except Exception as exc:
+                # Try without quantization_config first (handles shape mismatch
+                # caused by mismatched ZImageTransformer2DModel config when
+                # the GGUF was built with a different architecture variant).
+                plain_kwargs = {"torch_dtype": compute_dtype}
                 try:
                     transformer = ZImageTransformer2DModel.from_single_file(
                         model_path,
-                        torch_dtype=compute_dtype
+                        **plain_kwargs
                     )
                 except Exception:
-                    raise RuntimeError(f"Failed to load GGUF transformer from '{model_path}': {exc}")
+                    # Last resort: allow size mismatch so at least something loads
+                    try:
+                        transformer = ZImageTransformer2DModel.from_single_file(
+                            model_path,
+                            ignore_mismatched_sizes=True,
+                            low_cpu_mem_usage=False,
+                            **plain_kwargs
+                        )
+                        logger.warning(
+                            "Loaded GGUF transformer with ignored size mismatches. "
+                            "Image quality may be degraded. Consider using the full (non-GGUF) "
+                            "Horus-Lens-1.0 model for best results."
+                        )
+                    except Exception:
+                        raise RuntimeError(
+                            f"Failed to load GGUF transformer from '{model_path}': {exc}\n"
+                            "Hint: The GGUF file may be incompatible with the installed diffusers "
+                            "version. Try: pip install --upgrade diffusers"
+                        )
 
         base_repo_id = "tokenaii/Horus-Lens-1.0"
         pipeline_kwargs: Dict[str, Any] = {
@@ -843,6 +902,16 @@ class HorusProvider(BaseLLMProvider):
                     self.tokenizer = horus_tokenizer
                     self.transformer = horus_transformer
                     self.vae = horus_vae
+
+                    # Initialize VAE scale factor and image processor
+                    vae_scale = 8
+                    if hasattr(self, "vae") and self.vae is not None:
+                        if hasattr(self.vae, "config") and getattr(self.vae.config, "block_out_channels", None) is not None:
+                            vae_scale = 2 ** (len(self.vae.config.block_out_channels) - 1)
+                    self.vae_scale_factor = vae_scale
+                    
+                    from diffusers.image_processor import VaeImageProcessor
+                    self.image_processor = VaeImageProcessor(vae_scale_factor=self.vae_scale_factor * 2)
             
             with self._quiet_native_output():
                 self.model = PatchedZImagePipeline.from_pretrained(
@@ -891,23 +960,25 @@ class HorusProvider(BaseLLMProvider):
             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",
-                    message=r".*You are sending unauthenticated requests to the HF Hub.*",
-                )
-                model_path = hf_hub_download(
-                    repo_id=repo_id,
-                    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:
-                    os.environ.pop("HF_HUB_DISABLE_PROGRESS_BARS", None)
-                else:
-                    os.environ["HF_HUB_DISABLE_PROGRESS_BARS"] = prev_disable_progress
+            try:
+                with warnings.catch_warnings():
+                    warnings.filterwarnings(
+                        "ignore",
+                        message=r".*You are sending unauthenticated requests to the HF Hub.*",
+                    )
+                    model_path = hf_hub_download(
+                        repo_id=repo_id,
+                        filename=filename,
+                        cache_dir=self.cache_dir,
+                        local_files_only=self.local_files_only,
+                        token=self.token,
+                    )
+            finally:
+                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,
@@ -1518,17 +1589,23 @@ class HorusProvider(BaseLLMProvider):
         # Add tool descriptions to system prompt if tools are provided
         if tools:
             tool_desc = self._format_tool_descriptions(tools)
+            tool_section = (
+                "\n\nAvailable tools:\n"
+                + tool_desc
+                + "\n\nTo call a tool, respond with valid JSON: "
+                  '{"tool": "<name>", "arguments": {"<param>": "<value>"}}'
+            )
             # Find system message or add one
             has_system = False
             for m in normalized:
                 if m["role"] == "system":
-                    m["content"] = m["content"] + "\n\n" + TOOL_CALLING_PROMPT.format(tool_descriptions=tool_desc)
+                    m["content"] = m["content"] + tool_section
                     has_system = True
                     break
             if not has_system:
                 normalized.insert(0, {
                     "role": "system",
-                    "content": UNIFIED_SYSTEM_PROMPT + "\n\n" + TOOL_CALLING_PROMPT.format(tool_descriptions=tool_desc)
+                    "content": UNIFIED_SYSTEM_PROMPT + tool_section
                 })
         
         prompt = self._render_prompt(normalized)
@@ -1571,7 +1648,7 @@ class HorusProvider(BaseLLMProvider):
         )
 
     async def achat(self, messages: List[Dict[str, Any]], **kwargs) -> Union[LLMResponse, Iterator[StreamingChunk]]:
-        loop = asyncio.get_event_loop()
+        loop = asyncio.get_running_loop()
         return await loop.run_in_executor(None, lambda: self.chat(messages, **kwargs))
 
     def complete(self, prompt: str, model: Optional[str] = None, **kwargs) -> LLMResponse:
@@ -1699,8 +1776,7 @@ class HorusProvider(BaseLLMProvider):
     
     async def aembed(self, texts: Union[str, List[str]], model: Optional[str] = None, **kwargs) -> Union[List[float], List[List[float]]]:
         """Async version of embed - runs in executor."""
-        import asyncio
-        loop = asyncio.get_event_loop()
+        loop = asyncio.get_running_loop()
         return await loop.run_in_executor(None, lambda: self.embed(texts, model=model, **kwargs))
 
     def get_model_info(self) -> Dict[str, Any]: