swarmauri 0.11.0.dev1__tar.gz → 0.11.0.dev6__tar.gz

{swarmauri-0.11.0.dev1 → swarmauri-0.11.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarmauri
-Version: 0.11.0.dev1
+Version: 0.11.0.dev6
 Summary: Swarmauri namespace microkernel for registry-backed imports, plugin discovery, and composable intelligence infrastructure components.
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -29,15 +29,17 @@ Provides-Extra: full
 Provides-Extra: llms
 Requires-Dist: httpx (>=0.27.0)
 Requires-Dist: pydantic (>=2.9.2)
-Requires-Dist: swarmauri_base
-Requires-Dist: swarmauri_core
+Requires-Dist: swarmauri_base (>=0.11.0.dev6,<0.12)
+Requires-Dist: swarmauri_core (>=0.11.0.dev6,<0.12)
 Requires-Dist: swarmauri_embedding_doc2vec ; extra == "default"
 Requires-Dist: swarmauri_embedding_doc2vec ; extra == "full"
 Requires-Dist: swarmauri_embedding_nmf ; extra == "default"
 Requires-Dist: swarmauri_embedding_nmf ; extra == "full"
 Requires-Dist: swarmauri_llm_ai21 ; extra == "llms"
 Requires-Dist: swarmauri_llm_anthropic ; extra == "llms"
+Requires-Dist: swarmauri_llm_azureopenai ; extra == "llms"
 Requires-Dist: swarmauri_llm_cerebras ; extra == "llms"
+Requires-Dist: swarmauri_llm_cloudflare ; extra == "llms"
 Requires-Dist: swarmauri_llm_cohere ; extra == "llms"
 Requires-Dist: swarmauri_llm_deepinfra ; extra == "llms"
 Requires-Dist: swarmauri_llm_deepseek ; extra == "llms"
@@ -48,17 +50,19 @@ Requires-Dist: swarmauri_llm_hyperbolic ; extra == "llms"
 Requires-Dist: swarmauri_llm_leptonai ; extra == "llms"
 Requires-Dist: swarmauri_llm_llamacpp ; extra == "llms"
 Requires-Dist: swarmauri_llm_mistral ; extra == "llms"
+Requires-Dist: swarmauri_llm_nvidia_nim ; extra == "llms"
 Requires-Dist: swarmauri_llm_openai ; extra == "llms"
 Requires-Dist: swarmauri_llm_perplexity ; extra == "llms"
 Requires-Dist: swarmauri_llm_playht ; extra == "llms"
 Requires-Dist: swarmauri_llm_whisper ; extra == "llms"
+Requires-Dist: swarmauri_llm_xai ; extra == "llms"
 Requires-Dist: swarmauri_parser_beautifulsoupelement ; extra == "default"
 Requires-Dist: swarmauri_parser_beautifulsoupelement ; extra == "full"
 Requires-Dist: swarmauri_parser_keywordextractor ; extra == "default"
 Requires-Dist: swarmauri_parser_keywordextractor ; extra == "full"
 Requires-Dist: swarmauri_signing_ed25519 ; extra == "default"
 Requires-Dist: swarmauri_signing_ed25519 ; extra == "full"
-Requires-Dist: swarmauri_standard
+Requires-Dist: swarmauri_standard (>=0.11.0.dev8,<0.12)
 Requires-Dist: swarmauri_tool_matplotlib ; extra == "default"
 Requires-Dist: swarmauri_tool_matplotlib ; extra == "full"
 Requires-Dist: swarmauri_vectorstore_doc2vec ; extra == "default"
@@ -217,7 +221,10 @@ Inspect registered first-party and discovered component paths:
 ```python
 from swarmauri.plugin_citizenship_registry import PluginCitizenshipRegistry
 
-for public_path, module_path in PluginCitizenshipRegistry.total_registry().items():
+for (
+    public_path,
+    module_path,
+) in PluginCitizenshipRegistry.total_registry().items():
     print(public_path, "->", module_path)
 ```
 

{swarmauri-0.11.0.dev1 → swarmauri-0.11.0.dev6}/README.md

@@ -148,7 +148,10 @@ Inspect registered first-party and discovered component paths:
 ```python
 from swarmauri.plugin_citizenship_registry import PluginCitizenshipRegistry
 
-for public_path, module_path in PluginCitizenshipRegistry.total_registry().items():
+for (
+    public_path,
+    module_path,
+) in PluginCitizenshipRegistry.total_registry().items():
     print(public_path, "->", module_path)
 ```
 

{swarmauri-0.11.0.dev1 → swarmauri-0.11.0.dev6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "swarmauri"
-version = "0.11.0.dev1"
+version = "0.11.0.dev6"
 description = "Swarmauri namespace microkernel for registry-backed imports, plugin discovery, and composable intelligence infrastructure components."
 keywords = [
     "swarmauri",
@@ -49,9 +49,9 @@ dependencies = [
     "httpx>=0.27.0",
     "pydantic>=2.9.2",
     "typing_extensions",
-    "swarmauri_core",
-    "swarmauri_base",
-    "swarmauri_standard",
+    "swarmauri_core>=0.11.0.dev6,<0.12",
+    "swarmauri_base>=0.11.0.dev6,<0.12",
+    "swarmauri_standard>=0.11.0.dev8,<0.12",
 ]
 
 [project.optional-dependencies]
@@ -82,7 +82,9 @@ full = [
 llms = [
     "swarmauri_llm_ai21",
     "swarmauri_llm_anthropic",
+    "swarmauri_llm_azureopenai",
     "swarmauri_llm_cerebras",
+    "swarmauri_llm_cloudflare",
     "swarmauri_llm_cohere",
     "swarmauri_llm_deepinfra",
     "swarmauri_llm_deepseek",
@@ -93,10 +95,12 @@ llms = [
     "swarmauri_llm_leptonai",
     "swarmauri_llm_llamacpp",
     "swarmauri_llm_mistral",
+    "swarmauri_llm_nvidia_nim",
     "swarmauri_llm_openai",
     "swarmauri_llm_perplexity",
     "swarmauri_llm_playht",
     "swarmauri_llm_whisper",
+    "swarmauri_llm_xai",
 ]
 
 [tool.uv.sources]
@@ -105,7 +109,9 @@ swarmauri_base = { workspace = true }
 swarmauri_standard = { workspace = true }
 swarmauri_llm_ai21 = { workspace = true }
 swarmauri_llm_anthropic = { workspace = true }
+swarmauri_llm_azureopenai = { workspace = true }
 swarmauri_llm_cerebras = { workspace = true }
+swarmauri_llm_cloudflare = { workspace = true }
 swarmauri_llm_cohere = { workspace = true }
 swarmauri_llm_deepinfra = { workspace = true }
 swarmauri_llm_deepseek = { workspace = true }
@@ -116,10 +122,12 @@ swarmauri_llm_hyperbolic = { workspace = true }
 swarmauri_llm_leptonai = { workspace = true }
 swarmauri_llm_llamacpp = { workspace = true }
 swarmauri_llm_mistral = { workspace = true }
+swarmauri_llm_nvidia_nim = { workspace = true }
 swarmauri_llm_openai = { workspace = true }
 swarmauri_llm_perplexity = { workspace = true }
 swarmauri_llm_playht = { workspace = true }
 swarmauri_llm_whisper = { workspace = true }
+swarmauri_llm_xai = { workspace = true }
 swarmauri_vectorstore_doc2vec = { workspace = true }
 swarmauri_embedding_doc2vec = { workspace = true }
 #swarmauri_embedding_tfidf = { workspace = true }
@@ -173,3 +181,17 @@ dev = [
     "ruff>=0.9.9",
     "pytest-benchmark>=4.0.0",
 ]
+
+[tool.ruff]
+extend = "../pyproject.toml"
+
+[tool.ruff.lint]
+ignore = [
+    "BLE001",
+    "E501",
+    "RUF012",
+    "S110",
+    "SIM118",
+    "TRY004",
+    "TRY401",
+]

{swarmauri-0.11.0.dev1 → swarmauri-0.11.0.dev6}/swarmauri/__init__.py

@@ -1,5 +1,6 @@
-import sys as _sys
 import logging
+import sys as _sys
+
 from .importer import SwarmauriImporter
 from .plugin_manager import discover_and_register_plugins
 

{swarmauri-0.11.0.dev1 → swarmauri-0.11.0.dev6}/swarmauri/cli.py

@@ -1,8 +1,9 @@
 import argparse
 import logging
 import subprocess
+
+from swarmauri.plugin_manager import determine_plugin_manager, get_entry_points
 from swarmauri.registry import list_registry
-from swarmauri.plugin_manager import get_entry_points, determine_plugin_manager
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)

{swarmauri-0.11.0.dev1 → swarmauri-0.11.0.dev6}/swarmauri/importer.py

@@ -1,13 +1,13 @@
 # importer.py
 
-import sys
 import importlib
 import logging
+import sys
 from importlib.machinery import ModuleSpec
 from types import ModuleType
 
-from .plugin_citizenship_registry import PluginCitizenshipRegistry
 from .interface_registry import InterfaceRegistry
+from .plugin_citizenship_registry import PluginCitizenshipRegistry
 
 logger = logging.getLogger(__name__)
 
@@ -48,10 +48,8 @@ class SwarmauriImporter:
             )
             if external_module_path:
                 logger.debug(
-                    (
-                        f"Found external module mapping: {fullname} -> "
-                        f"{external_module_path}"
-                    )
+                    f"Found external module mapping: {fullname} -> "
+                    f"{external_module_path}"
                 )
                 return ModuleSpec(fullname, self)
 
@@ -62,10 +60,8 @@ class SwarmauriImporter:
             if external_module_path:
                 # If we detect lazy strategy, then we utilize LazyLoader
                 logger.debug(
-                    (
-                        f"Found external module mapping: {fullname} -> "
-                        f"{external_module_path}"
-                    )
+                    f"Found external module mapping: {fullname} -> "
+                    f"{external_module_path}"
                 )
                 return ModuleSpec(fullname, importlib.util.LazyLoader(self))
 
@@ -80,7 +76,8 @@ class SwarmauriImporter:
 
         if spec.name in sys.modules:
             logger.debug(
-                f"Module '{spec.name}' already in sys.modules. Returning cached module."  # noqa: E501
+                f"Module '{spec.name}' already in sys.modules. Returning "
+                f"cached module."
             )
             return sys.modules[spec.name]
 
@@ -89,7 +86,8 @@ class SwarmauriImporter:
         )
         if external_module_path:
             logger.debug(
-                f"Importing external module '{spec.name}' from '{external_module_path}'"  # noqa: E501
+                f"Importing external module '{spec.name}' from "
+                f"'{external_module_path}'"
             )
             module = importlib.import_module(external_module_path)
             sys.modules[spec.name] = module

{swarmauri-0.11.0.dev1 → swarmauri-0.11.0.dev6}/swarmauri/interface_registry.py

@@ -8,10 +8,9 @@ Provides mechanisms to retrieve and manage interface classes based on resource
 namespaces.
 """
 
-from typing import Optional, Type, Dict, Any, List
 import importlib
 import logging
-
+from typing import Any
 
 # Configure logging
 logger = logging.getLogger(__name__)
@@ -27,7 +26,7 @@ class InterfaceRegistry:
     namespaces.
     """
 
-    INTERFACE_IMPORT_PATHS: Dict[str, Optional[str]] = {
+    INTERFACE_IMPORT_PATHS: dict[str, str | None] = {
         "swarmauri.agents": "swarmauri_base.agents.AgentBase",
         "swarmauri.chains": "swarmauri_base.chains.ChainBase",
         "swarmauri.chunkers": "swarmauri_base.chunkers.ChunkerBase",
@@ -49,8 +48,15 @@ class InterfaceRegistry:
         "swarmauri.factories": "swarmauri_base.factories.FactoryBase",
         "swarmauri.image_gens": "swarmauri_base.image_gens.ImageGenBase",
         "swarmauri.llms": "swarmauri_base.llms.LLMBase",
+        "swarmauri.live_models": ("swarmauri_base.live_models.LiveModelBase"),
+        "swarmauri.model_providers": (
+            "swarmauri_base.model_providers.ModelProviderBase"
+        ),
         "swarmauri.tool_llms": "swarmauri_base.tool_llms.ToolLLMBase",
         "swarmauri.tts": "swarmauri_base.tts.TTSBase",
+        "swarmauri.video_lipsync": (
+            "swarmauri_base.video_lipsync.LipSyncBase"
+        ),
         "swarmauri.ocrs": "swarmauri_base.ocrs.OCRBase",
         "swarmauri.stt": "swarmauri_base.stt.STTBase",
         "swarmauri.storage_adapters": (
@@ -72,7 +78,11 @@ class InterfaceRegistry:
         "swarmauri.schema_converters": (
             "swarmauri_base.schema_converters.SchemaConverterBase"
         ),
+        "swarmauri.retrievers": ("swarmauri_base.retrievers.RetrieverBase"),
         "swarmauri.skills": "swarmauri_base.skills.SkillBase",
+        "swarmauri.similarities": (
+            "swarmauri_base.similarities.SimilarityBase"
+        ),
         "swarmauri.service_registries": (
             "swarmauri_base.service_registries.ServiceRegistryBase"
         ),
@@ -111,14 +121,14 @@ class InterfaceRegistry:
         "swarmauri.tokens": "swarmauri_base.tokens.TokenServiceBase",
     }
 
-    INTERFACE_REGISTRY: Dict[str, Optional[Type[Any]]] = {
+    INTERFACE_REGISTRY: dict[str, type[Any] | None] = {
         key: None for key in INTERFACE_IMPORT_PATHS
     }
 
     @classmethod
     def get_interface_for_resource(
         cls, resource_kind: str
-    ) -> Optional[Type[Any]]:
+    ) -> type[Any] | None:
         """
         Retrieve the interface class for a given resource kind.
 
@@ -149,14 +159,15 @@ class InterfaceRegistry:
             )
         else:
             logger.debug(
-                f"Retrieved interface '{interface.__name__}' for resource kind '{resource_kind}'."  # noqa: E501
+                f"Retrieved interface '{interface.__name__}' for resource "
+                f"kind '{resource_kind}'."
             )
 
         return interface
 
     @classmethod
     def register_interface(
-        cls, resource_kind: str, interface_class: Optional[Type[Any]]
+        cls, resource_kind: str, interface_class: type[Any] | None
     ) -> None:
         """
         Register or update the interface class for a given resource kind.
@@ -177,12 +188,14 @@ class InterfaceRegistry:
                 f"{interface_class.__module__}.{interface_class.__name__}"
             )
             logger.info(
-                f"Registered interface '{interface_class.__name__}' for resource kind '{resource_kind}'."  # noqa: E501
+                f"Registered interface '{interface_class.__name__}' for "
+                f"resource kind '{resource_kind}'."
             )
         else:
             cls.INTERFACE_IMPORT_PATHS[resource_kind] = None
             logger.info(
-                f"Removed interface association for resource kind '{resource_kind}'."  # noqa: E501
+                f"Removed interface association for resource kind "
+                f"'{resource_kind}'."
             )
 
     @classmethod
@@ -195,7 +208,7 @@ class InterfaceRegistry:
         cls.register_interface(resource_kind, None)
 
     @classmethod
-    def list_registered_interfaces(cls) -> Dict[str, Optional[Type[Any]]]:
+    def list_registered_interfaces(cls) -> dict[str, type[Any] | None]:
         """
         List all registered resource kinds and their corresponding interfaces.
 
@@ -205,7 +218,7 @@ class InterfaceRegistry:
         return cls.INTERFACE_REGISTRY.copy()
 
     @classmethod
-    def list_registered_namespaces(cls) -> List[str]:
+    def list_registered_namespaces(cls) -> list[str]:
         """
         Lists all registered interface namespaces.
 

{swarmauri-0.11.0.dev1 → swarmauri-0.11.0.dev6}/swarmauri/plugin_citizenship_registry.py

@@ -10,7 +10,6 @@ first, second, and third-class citizens within the swarmauri framework.
 
 import logging
 from importlib.metadata import EntryPoint
-from typing import Dict, Optional
 
 # Configure logger
 logger = logging.getLogger(__name__)
@@ -50,7 +49,63 @@ class PluginCitizenshipRegistry:
     """
 
     # Class variables for registries
-    FIRST_CLASS_REGISTRY: Dict[str, str] = {
+    FIRST_CLASS_REGISTRY: dict[str, str] = {
+        "swarmauri.agents.PackageMaintenanceAgent": (
+            "swarmauri_agent_package_maintenance.PackageMaintenanceAgent"
+        ),
+        "swarmauri.tools.RunPackageChecks": (
+            "swarmauri_tool_runpackagechecks.RunPackageChecks"
+        ),
+        "swarmauri.tools.UnregisterRuntimeTool": (
+            "swarmauri_tool_unregisterruntimetool.UnregisterRuntimeTool"
+        ),
+        "swarmauri.tools.ReplaceRuntimeTool": (
+            "swarmauri_tool_replaceruntimetool.ReplaceRuntimeTool"
+        ),
+        "swarmauri.tools.ListRuntimeTools": (
+            "swarmauri_tool_listruntimetools.ListRuntimeTools"
+        ),
+        "swarmauri.tools.InspectRuntimeTool": (
+            "swarmauri_tool_inspectruntimetool.InspectRuntimeTool"
+        ),
+        "swarmauri.tools.RegisterRuntimeTool": (
+            "swarmauri_tool_registerruntimetool.RegisterRuntimeTool"
+        ),
+        "swarmauri.toolkits.SkillsetToolkit": (
+            "swarmauri_toolkit_skillset.SkillsetToolkit"
+        ),
+        "swarmauri.tools.ReadSkillResource": (
+            "swarmauri_tool_readskillresource.ReadSkillResource"
+        ),
+        "swarmauri.tools.ActivateSkill": (
+            "swarmauri_tool_activateskill.ActivateSkill"
+        ),
+        "swarmauri.tools.InspectSkill": (
+            "swarmauri_tool_inspectskill.InspectSkill"
+        ),
+        "swarmauri.tools.ListSkills": "swarmauri_tool_listskills.ListSkills",
+        "swarmauri.tools.CancelProcessTool": (
+            "swarmauri_tool_cancelprocess.CancelProcessTool"
+        ),
+        "swarmauri.tools.WriteStdinTool": (
+            "swarmauri_tool_writestdin.WriteStdinTool"
+        ),
+        "swarmauri.tools.ReadProcessOutputTool": (
+            "swarmauri_tool_readprocessoutput.ReadProcessOutputTool"
+        ),
+        "swarmauri.tools.RunBashScriptTool": (
+            "swarmauri_tool_runbashscript.RunBashScriptTool"
+        ),
+        "swarmauri.tools.RunCommandTool": (
+            "swarmauri_tool_runcommand.RunCommandTool"
+        ),
+        "swarmauri.messages.AnswerMessage": (
+            "swarmauri_standard.messages.AnswerMessage"
+        ),
+        "swarmauri.messages.QuestionMessage": (
+            "swarmauri_standard.messages.QuestionMessage"
+        ),
+        "swarmauri.tools.AskUserTool": "swarmauri_tool_askuser.AskUserTool",
         "swarmauri.skills.DummyFileSystemSkill": (
             "swarmauri_skill_dummy_filesystem.DummyFileSystemSkill"
         ),
@@ -85,6 +140,9 @@ class PluginCitizenshipRegistry:
         "swarmauri.signings.JwsSignerVerifier": (
             "swarmauri_signing_jws.JwsSignerVerifier"
         ),
+        "swarmauri.similarities.GzipSimilarity": (
+            "swarmauri_similarity_gzip.GzipSimilarity"
+        ),
         "swarmauri.cipher_suites.JwaCipherSuite": (
             "swarmauri_cipher_suite_jwa.JwaCipherSuite"
         ),
@@ -193,10 +251,16 @@ class PluginCitizenshipRegistry:
         "swarmauri.storage_adapters.S3StorageAdapter": (
             "swarmauri_storage_s3.S3StorageAdapter"
         ),
+        "swarmauri.storage_adapters.WebDAVStorageAdapter": (
+            "swarmauri_storage_webdav.WebDAVStorageAdapter"
+        ),
         "swarmauri.agents.ExampleAgent": "swm_example_package.ExampleAgent",
         "swarmauri.agents.QAAgent": "swarmauri_standard.agents.QAAgent",
         "swarmauri.agents.RagAgent": "swarmauri_standard.agents.RagAgent",
         "swarmauri.agents.SkillAgent": "swarmauri_agent_skill.SkillAgent",
+        "swarmauri.agents.TextToSpeechAgent": (
+            "swarmauri_agent_texttospeech.TextToSpeechAgent"
+        ),
         "swarmauri.agents.SimpleConversationAgent": (
             "swarmauri_standard.agents.SimpleConversationAgent"
         ),
@@ -353,11 +417,16 @@ class PluginCitizenshipRegistry:
         "swarmauri.stt.OpenaiSTT": "swarmauri_standard.stt.OpenaiSTT",
         "swarmauri.tts.HyperbolicTTS": "swarmauri_standard.tts.HyperbolicTTS",
         "swarmauri.tts.OpenaiTTS": "swarmauri_standard.tts.OpenaiTTS",
+        "swarmauri.tts.PlayHTModel": "swarmauri_tts_playht.PlayHTModel",
         "swarmauri.tts.PlayhtTTS": "swarmauri_standard.tts.PlayhtTTS",
-        "swarmauri.vlms.FalVLM": "swarmauri_standard.vlms.FalVLM",
-        "swarmauri.vlms.GroqVLM": "swarmauri_standard.vlms.GroqVLM",
+        "swarmauri.vlms.OpenAIVLM": "swarmauri_llm_openai.OpenAIVLM",
+        "swarmauri.vlms.GeminiVLM": "swarmauri_llm_gemini.GeminiVLM",
+        "swarmauri.vlms.AnthropicVLM": "swarmauri_llm_anthropic.AnthropicVLM",
+        "swarmauri.vlms.MistralVLM": "swarmauri_llm_mistral.MistralVLM",
+        "swarmauri.vlms.FalVLM": "swarmauri_llm_falai.FalVLM",
+        "swarmauri.vlms.GroqVLM": "swarmauri_llm_groq.GroqVLM",
         "swarmauri.vlms.HyperbolicVLM": (
-            "swarmauri_standard.vlms.HyperbolicVLM"
+            "swarmauri_llm_hyperbolic.HyperbolicVLM"
         ),
         "swarmauri.measurements.CompletenessMeasurement": (
             "swarmauri_standard.measurements.CompletenessMeasurement"
@@ -514,6 +583,9 @@ class PluginCitizenshipRegistry:
         # "swarmauri_standard.tools.MatplotlibCsvTool",
         # "swarmauri.tools.MatplotlibTool":
         # "swarmauri_standard.tools.MatplotlibTool",
+        "swarmauri.tools.SubprocessTool": (
+            "swarmauri_tool_subprocess.SubprocessTool"
+        ),
         "swarmauri.tools.Parameter": "swarmauri_standard.tools.Parameter",
         "swarmauri.tools.RequestsTool": (
             "swarmauri_standard.tools.RequestsTool"
@@ -547,6 +619,9 @@ class PluginCitizenshipRegistry:
         "swarmauri.transports.HttpsUnicastTransport": (
             "swarmauri_transport_https_unicast.HttpsUnicastTransport"
         ),
+        "swarmauri.transports.RetryingHttpClient": (
+            "swarmauri_transport_retry.RetryingHttpClient"
+        ),
         "swarmauri.transports.PubSubTransport": (
             "swarmauri_standard.transports.PubSubTransport"
         ),
@@ -677,9 +752,6 @@ class PluginCitizenshipRegistry:
         "swarmauri.logger_formatters.LoggerFormatter": (
             "swarmauri_standard.logger_formatters.LoggerFormatter"
         ),
-        "swarmauri.middlewares.AuthMiddleware": (
-            "swarmauri_middleware_auth.AuthMiddleware"
-        ),
         "swarmauri.middlewares.BulkheadMiddleware": (
             "swarmauri_middleware_bulkhead.BulkheadMiddleware"
         ),
@@ -695,6 +767,9 @@ class PluginCitizenshipRegistry:
         "swarmauri.middlewares.GzipCompressionMiddleware": (
             "swarmauri_middleware_gzipcompression.GzipCompressionMiddleware"
         ),
+        "swarmauri.middlewares.JWTMiddleware": (
+            "swarmauri_middleware_jwt.JWTMiddleware"
+        ),
         "swarmauri.middlewares.LlamaGuardMiddleware": (
             "swarmauri_middleware_llamaguard.LlamaGuardMiddleware"
         ),
@@ -737,18 +812,90 @@ class PluginCitizenshipRegistry:
         ),
     }
     _KNOWN_GROUPS_CACHE: set[str] | None = None
-    SECOND_CLASS_REGISTRY: Dict[str, str] = {
+    SECOND_CLASS_REGISTRY: dict[str, str] = {
+        "swarmauri.video_lipsync.SyncLabsLipSync": (
+            "swarmauri_video_lipsync_synclabs.SyncLabsLipSync"
+        ),
+        "swarmauri.model_providers.GeminiProvider": (
+            "swarmauri_provider_gemini.GeminiProvider"
+        ),
+        "swarmauri.model_providers.OpenAIProvider": (
+            "swarmauri_provider_openai.OpenAIProvider"
+        ),
+        "swarmauri.model_providers.OpenRouterProvider": (
+            "swarmauri_provider_openrouter.OpenRouterProvider"
+        ),
+        "swarmauri.model_providers.XAIProvider": (
+            "swarmauri_provider_xai.XAIProvider"
+        ),
+        "swarmauri.model_providers.QwenProvider": (
+            "swarmauri_provider_qwen.QwenProvider"
+        ),
+        "swarmauri.model_providers.AmazonNovaProvider": (
+            "swarmauri_provider_amazon_nova.AmazonNovaProvider"
+        ),
+        "swarmauri.live_models.GeminiLiveModel": (
+            "swarmauri_live_model_gemini.GeminiLiveModel"
+        ),
+        "swarmauri.live_models.OpenAIRealtimeModel": (
+            "swarmauri_live_model_openai.OpenAIRealtimeModel"
+        ),
+        "swarmauri.live_models.OpenAIResponsesWSModel": (
+            "swarmauri_live_model_openai.OpenAIResponsesWSModel"
+        ),
+        "swarmauri.live_models.XAIRealtimeModel": (
+            "swarmauri_live_model_xai.XAIRealtimeModel"
+        ),
+        "swarmauri.live_models.QwenOmniRealtimeModel": (
+            "swarmauri_live_model_qwen.QwenOmniRealtimeModel"
+        ),
+        "swarmauri.live_models.NovaSonicLiveModel": (
+            "swarmauri_live_model_amazon_nova.NovaSonicLiveModel"
+        ),
+        "swarmauri.agents.RealtimeAgent": (
+            "swarmauri_agent_realtime.RealtimeAgent"
+        ),
+        "swarmauri.transports.HttpxClient": (
+            "swarmauri_transport_httpx.HttpxClient"
+        ),
+        "swarmauri.transports.WebSocketClient": (
+            "swarmauri_transport_websocket.WebSocketClient"
+        ),
+        "swarmauri.transports.AwsEventStreamClient": (
+            "swarmauri_transport_aws_eventstream.AwsEventStreamClient"
+        ),
+        "swarmauri.tools.QueryImageVectorStoreTool": (
+            "swarmauri_tool_queryimagevectorstore.QueryImageVectorStoreTool"
+        ),
+        "swarmauri.tools.QueryKnowledgeBaseTool": (
+            "swarmauri_tool_queryknowledgebase.QueryKnowledgeBaseTool"
+        ),
         "swarmauri.image_gens.LeptonAIImgGenModel": (
             "swarmauri_llm_leptonai.LeptonAIImgGenModel"
         ),
         "swarmauri.llms.AI21StudioModel": "swarmauri_llm_ai21.AI21StudioModel",
+        "swarmauri.image_gens.OpenRouterImgGenModel": (
+            "swarmauri_llm_openrouter.OpenRouterImgGenModel"
+        ),
         "swarmauri.llms.AnthropicModel": (
             "swarmauri_llm_anthropic.AnthropicModel"
         ),
         "swarmauri.llms.AnthropicToolModel": (
             "swarmauri_llm_anthropic.AnthropicToolModel"
         ),
+        "swarmauri.llms.AzureOpenAIModel": (
+            "swarmauri_llm_azureopenai.AzureOpenAIModel"
+        ),
+        "swarmauri.llms.AzureOpenAIToolModel": (
+            "swarmauri_llm_azureopenai.AzureOpenAIToolModel"
+        ),
         "swarmauri.llms.CerebrasModel": "swarmauri_llm_cerebras.CerebrasModel",
+        "swarmauri.llms.CloudflareWorkersAIModel": (
+            "swarmauri_llm_cloudflare.CloudflareWorkersAIModel"
+        ),
+        "swarmauri.llms.CloudflareWorkersAIToolModel": (
+            "swarmauri_llm_cloudflare.CloudflareWorkersAIToolModel"
+        ),
         "swarmauri.llms.CohereModel": "swarmauri_llm_cohere.CohereModel",
         "swarmauri.llms.CohereToolModel": (
             "swarmauri_llm_cohere.CohereToolModel"
@@ -783,25 +930,41 @@ class PluginCitizenshipRegistry:
         "swarmauri.llms.MistralToolModel": (
             "swarmauri_llm_mistral.MistralToolModel"
         ),
+        "swarmauri.llms.NvidiaNIMModel": (
+            "swarmauri_llm_nvidia_nim.NvidiaNIMModel"
+        ),
+        "swarmauri.llms.NvidiaNIMToolModel": (
+            "swarmauri_llm_nvidia_nim.NvidiaNIMToolModel"
+        ),
         "swarmauri.llms.OpenAIAudio": "swarmauri_llm_openai.OpenAIAudio",
         "swarmauri.llms.OpenAIAudioTTS": "swarmauri_llm_openai.OpenAIAudioTTS",
         "swarmauri.llms.OpenAIModel": "swarmauri_llm_openai.OpenAIModel",
+        "swarmauri.llms.OpenRouterModel": (
+            "swarmauri_llm_openrouter.OpenRouterModel"
+        ),
         "swarmauri.llms.OpenAIToolModel": (
             "swarmauri_llm_openai.OpenAIToolModel"
         ),
         "swarmauri.llms.PerplexityModel": (
             "swarmauri_llm_perplexity.PerplexityModel"
         ),
-        "swarmauri.llms.PlayHTModel": "swarmauri_llm_playht.PlayHTModel",
         "swarmauri.llms.WhisperLargeModel": (
             "swarmauri_llm_whisper.WhisperLargeModel"
         ),
+        "swarmauri.llms.XAIModel": "swarmauri_llm_xai.XAIModel",
+        "swarmauri.llms.XAIToolModel": "swarmauri_llm_xai.XAIToolModel",
         "swarmauri.tool_llms.OpenAIToolModel": (
             "swarmauri_llm_openai.OpenAIToolModel"
         ),
+        "swarmauri.tool_llms.OpenRouterToolModel": (
+            "swarmauri_llm_openrouter.OpenRouterToolModel"
+        ),
         "swarmauri.tool_llms.AnthropicToolModel": (
             "swarmauri_llm_anthropic.AnthropicToolModel"
         ),
+        "swarmauri.tool_llms.AzureOpenAIToolModel": (
+            "swarmauri_llm_azureopenai.AzureOpenAIToolModel"
+        ),
         "swarmauri.tool_llms.CohereToolModel": (
             "swarmauri_llm_cohere.CohereToolModel"
         ),
@@ -814,11 +977,21 @@ class PluginCitizenshipRegistry:
         "swarmauri.tool_llms.MistralToolModel": (
             "swarmauri_llm_mistral.MistralToolModel"
         ),
+        "swarmauri.tool_llms.CloudflareWorkersAIToolModel": (
+            "swarmauri_llm_cloudflare.CloudflareWorkersAIToolModel"
+        ),
+        "swarmauri.tool_llms.NvidiaNIMToolModel": (
+            "swarmauri_llm_nvidia_nim.NvidiaNIMToolModel"
+        ),
+        "swarmauri.tool_llms.XAIToolModel": "swarmauri_llm_xai.XAIToolModel",
+        "swarmauri.vlms.OpenRouterVLM": (
+            "swarmauri_llm_openrouter.OpenRouterVLM"
+        ),
     }
-    THIRD_CLASS_REGISTRY: Dict[str, str] = {}
+    THIRD_CLASS_REGISTRY: dict[str, str] = {}
 
     @classmethod
-    def total_registry(cls) -> Dict[str, str]:
+    def total_registry(cls) -> dict[str, str]:
         """
         Property: total_registry
 
@@ -860,17 +1033,20 @@ class PluginCitizenshipRegistry:
 
         if class_type not in registry_map:
             logger.error(
-                f"Invalid class type '{class_type}'. Must be 'first', 'second', or 'third'."  # noqa: E501
+                f"Invalid class type '{class_type}'. Must be 'first', "
+                f"'second', or 'third'."
             )
             raise ValueError(
-                f"Invalid class type '{class_type}'. Must be 'first', 'second', or 'third'."  # noqa: E501
+                f"Invalid class type '{class_type}'. Must be 'first', "
+                f"'second', or 'third'."
             )
 
         registry = registry_map[class_type]
 
         if resource_path in registry:
             logger.debug(
-                f"Resource path '{resource_path}' already exists in the {class_type}-class registry. Skipping registration."  # noqa: E501
+                f"Resource path '{resource_path}' already exists in the "
+                f"{class_type}-class registry. Skipping registration."
             )
             return
 
@@ -878,10 +1054,8 @@ class PluginCitizenshipRegistry:
         registry[resource_path] = module_path
         cls._KNOWN_GROUPS_CACHE = None
         logger.info(
-            (
-                f"Added to {class_type}-class registry: {resource_path} -> "
-                f"{module_path}"
-            )
+            f"Added to {class_type}-class registry: {resource_path} -> "
+            f"{module_path}"
         )
 
     @classmethod
@@ -903,20 +1077,24 @@ class PluginCitizenshipRegistry:
 
         if class_type not in registry_map:
             logger.error(
-                f"Invalid class type '{class_type}'. Must be 'first', 'second', or 'third'."  # noqa: E501
+                f"Invalid class type '{class_type}'. Must be 'first', "
+                f"'second', or 'third'."
             )
             raise ValueError(
-                f"Invalid class type '{class_type}'. Must be 'first', 'second', or 'third'."  # noqa: E501
+                f"Invalid class type '{class_type}'. Must be 'first', "
+                f"'second', or 'third'."
             )
 
         registry = registry_map[class_type]
 
         if resource_path not in registry:
             logger.error(
-                f"Resource path '{resource_path}' does not exist in the {class_type}-class registry."  # noqa: E501
+                f"Resource path '{resource_path}' does not exist in the "
+                f"{class_type}-class registry."
             )
             raise KeyError(
-                f"Resource path '{resource_path}' does not exist in the {class_type}-class registry."  # noqa: E501
+                f"Resource path '{resource_path}' does not exist in the "
+                f"{class_type}-class registry."
             )
 
         # Remove from the specific registry
@@ -927,7 +1105,7 @@ class PluginCitizenshipRegistry:
         )
 
     @classmethod
-    def list_registry(cls, class_type: Optional[str] = None) -> Dict[str, str]:
+    def list_registry(cls, class_type: str | None = None) -> dict[str, str]:
         """
         List all entries in a specific registry or the total registry.
 
@@ -949,17 +1127,19 @@ class PluginCitizenshipRegistry:
 
         if class_type not in registry_map:
             logger.error(
-                f"Invalid class type '{class_type}'. Must be 'first', 'second', or 'third'."  # noqa: E501
+                f"Invalid class type '{class_type}'. Must be 'first', "
+                f"'second', or 'third'."
             )
             raise ValueError(
-                f"Invalid class type '{class_type}'. Must be 'first', 'second', or 'third'."  # noqa: E501
+                f"Invalid class type '{class_type}'. Must be 'first', "
+                f"'second', or 'third'."
             )
 
         logger.debug(f"Listing {class_type}-class registry.")
         return dict(registry_map[class_type])
 
     @classmethod
-    def get_external_module_path(cls, resource_path: str) -> Optional[str]:
+    def get_external_module_path(cls, resource_path: str) -> str | None:
         """
         Get the external module path for a given resource path.
 
@@ -970,7 +1150,8 @@ class PluginCitizenshipRegistry:
         module_path = cls.total_registry().get(resource_path)
         if module_path:
             logger.debug(
-                f"Retrieved module path '{module_path}' for resource path '{resource_path}'."  # noqa: E501
+                f"Retrieved module path '{module_path}' for resource path "
+                f"'{resource_path}'."
             )
         else:
             logger.debug(
@@ -1021,29 +1202,31 @@ class PluginCitizenshipRegistry:
 
         if class_type not in registry_map:
             logger.error(
-                f"Invalid class type '{class_type}'. Must be 'first', 'second', or 'third'."  # noqa: E501
+                f"Invalid class type '{class_type}'. Must be 'first', "
+                f"'second', or 'third'."
             )
             raise ValueError(
-                f"Invalid class type '{class_type}'. Must be 'first', 'second', or 'third'."  # noqa: E501
+                f"Invalid class type '{class_type}'. Must be 'first', "
+                f"'second', or 'third'."
             )
 
         registry = registry_map[class_type]
 
         if resource_path not in registry:
             logger.error(
-                f"Resource path '{resource_path}' does not exist in the {class_type}-class registry."  # noqa: E501
+                f"Resource path '{resource_path}' does not exist in the "
+                f"{class_type}-class registry."
             )
             raise KeyError(
-                f"Resource path '{resource_path}' does not exist in the {class_type}-class registry."  # noqa: E501
+                f"Resource path '{resource_path}' does not exist in the "
+                f"{class_type}-class registry."
             )
 
         old_module_path = registry[resource_path]
         registry[resource_path] = new_module_path
         logger.info(
-            (
-                f"Updated {class_type}-class registry entry: {resource_path} "
-                f"-> {new_module_path} (was: {old_module_path})"
-            )
+            f"Updated {class_type}-class registry entry: {resource_path} "
+            f"-> {new_module_path} (was: {old_module_path})"
         )
 
     @classmethod
@@ -1060,7 +1243,7 @@ class PluginCitizenshipRegistry:
         cls.remove_from_registry(class_type, resource_path)
 
     @classmethod
-    def list_all_registries(cls) -> Dict[str, Dict[str, str]]:
+    def list_all_registries(cls) -> dict[str, dict[str, str]]:
         """
         Lists all registries: first, second, third, and total.
 
@@ -1085,7 +1268,8 @@ class PluginCitizenshipRegistry:
         resource_path = f"{entry_point.group}.{entry_point.name}"
         is_first = resource_path in cls.FIRST_CLASS_REGISTRY
         logger.debug(
-            f"Plugin '{entry_point.name}' is {'first-class' if is_first else 'not first-class'}."  # noqa: E501
+            f"Plugin '{entry_point.name}' is "
+            f"{'first-class' if is_first else 'not first-class'}."
         )
         return is_first
 
@@ -1100,7 +1284,8 @@ class PluginCitizenshipRegistry:
         resource_path = f"{entry_point.group}.{entry_point.name}"
         is_second = resource_path in cls.SECOND_CLASS_REGISTRY
         logger.debug(
-            f"Plugin '{entry_point.name}' is {'second-class' if is_second else 'not second-class'}."  # noqa: E501
+            f"Plugin '{entry_point.name}' is "
+            f"{'second-class' if is_second else 'not second-class'}."
         )
         return is_second
 

{swarmauri-0.11.0.dev1 → swarmauri-0.11.0.dev6}/swarmauri/plugin_manager.py

@@ -7,10 +7,9 @@ import json
 import logging
 import sys
 from importlib.metadata import EntryPoint
-from typing import Any, Dict, Optional
+from typing import Any
 
 # from swarmauri_base.ComponentBase import ComponentBase
-
 from .interface_registry import InterfaceRegistry
 from .plugin_citizenship_registry import PluginCitizenshipRegistry
 
@@ -19,12 +18,12 @@ logger = logging.getLogger(__name__)
 # -----------------------------------------------------------------------------
 # 1. GLOBAL CACHE FOR ENTRY POINTS
 # -----------------------------------------------------------------------------
-_cached_entry_points: Dict[str, list[EntryPoint]] | None = None
+_cached_entry_points: dict[str, list[EntryPoint]] | None = None
 
 
 def _fetch_and_group_entry_points(
     group_prefix: str = "swarmauri.",
-) -> Dict[str, list[EntryPoint]]:
+) -> dict[str, list[EntryPoint]]:
     """Scan environment for relevant entry points grouped by namespace.
 
     The previous implementation skipped scanning once the
@@ -34,7 +33,7 @@ def _fetch_and_group_entry_points(
     overhead compared to scanning all entry points.
     """
 
-    grouped_entry_points: Dict[str, list[EntryPoint]] = {}
+    grouped_entry_points: dict[str, list[EntryPoint]] = {}
     try:
         if PluginCitizenshipRegistry.known_groups():
             target_groups = [
@@ -133,7 +132,8 @@ def process_plugin(entry_point: EntryPoint) -> bool:
         preliminary_path = f"swarmauri.{resource_kind}.{entry_point.name}"
         if PluginCitizenshipRegistry.resource_exists(preliminary_path):
             logger.debug(
-                f"Resource path '{preliminary_path}' already registered; skipping."  # noqa: E501
+                f"Resource path '{preliminary_path}' already registered; "
+                f"skipping."
             )
             return True
 
@@ -162,7 +162,8 @@ def process_plugin(entry_point: EntryPoint) -> bool:
             # Eager loading: load the plugin module
             plugin_object = entry_point.load()
             logger.debug(
-                f"Eagerly loaded plugin '{entry_point.name}' as {type(plugin_object)}"  # noqa: E501
+                f"Eagerly loaded plugin '{entry_point.name}' as "
+                f"{type(plugin_object)}"
             )
 
             # Determine plugin type based on entry point's object reference
@@ -181,7 +182,8 @@ def process_plugin(entry_point: EntryPoint) -> bool:
 
     except (ImportError, ModuleNotFoundError) as e:
         msg = (
-            f"Failed to import plugin '{entry_point.name}' from '{entry_point.value}'. "  # noqa: E501
+            f"Failed to import plugin '{entry_point.name}' from "
+            f"'{entry_point.value}'. "
             f"Check that it is installed and imports correctly. Error: {e}"
         )
         logger.error(msg)
@@ -196,7 +198,7 @@ def process_plugin(entry_point: EntryPoint) -> bool:
         return False
 
 
-def _load_plugin_metadata(entry_point: EntryPoint) -> Optional[Dict[str, Any]]:
+def _load_plugin_metadata(entry_point: EntryPoint) -> dict[str, Any] | None:
     """
     Attempts to load metadata.json from the plugin's distribution without
     loading the module.
@@ -244,7 +246,8 @@ def _load_plugin_metadata(entry_point: EntryPoint) -> Optional[Dict[str, Any]]:
             ) as f:
                 metadata = json.load(f)
                 logger.debug(
-                    f"Loaded metadata for plugin '{entry_point.name}': {metadata}"  # noqa: E501
+                    f"Loaded metadata for plugin '{entry_point.name}': "
+                    f"{metadata}"
                 )
                 return metadata
         else:
@@ -261,7 +264,8 @@ def _load_plugin_metadata(entry_point: EntryPoint) -> Optional[Dict[str, Any]]:
         )
     except json.JSONDecodeError as e:
         logger.error(
-            f"Invalid JSON in metadata.json for plugin '{entry_point.name}': {e}"  # noqa: E501
+            f"Invalid JSON in metadata.json for plugin '{entry_point.name}': "
+            f"{e}"
         )
     except Exception as e:
         logger.exception(
@@ -271,7 +275,7 @@ def _load_plugin_metadata(entry_point: EntryPoint) -> Optional[Dict[str, Any]]:
 
 
 def _register_lazy_plugin_from_metadata(
-    entry_point: EntryPoint, metadata: Dict[str, Any]
+    entry_point: EntryPoint, metadata: dict[str, Any]
 ) -> None:
     """
     Registers a lazy-loaded plugin's type and module in the registries based on
@@ -292,7 +296,8 @@ def _register_lazy_plugin_from_metadata(
         module_path, _, attr_path = entry_point.value.partition(":")
         if not module_path or not attr_path:
             msg = (
-                f"Invalid entry point value '{entry_point.value}' for plugin '{entry_point.name}'. "  # noqa: E501
+                f"Invalid entry point value '{entry_point.value}' for plugin "
+                f"'{entry_point.name}'. "
                 f"Expected format 'module_path:attribute_path'."
             )
             logger.error(msg)
@@ -328,7 +333,8 @@ def _register_lazy_plugin_from_metadata(
             citizenship, resource_path, module_path
         )
         logger.info(
-            f"Registered {citizenship}-class plugin '{type_name}' at '{resource_path}' [lazy]"  # noqa: E501
+            f"Registered {citizenship}-class plugin '{type_name}' at "
+            f"'{resource_path}' [lazy]"
         )
 
         # Import Spec
@@ -353,17 +359,20 @@ def _register_lazy_plugin_from_metadata(
 
     except KeyError as e:
         logger.error(
-            f"Missing required metadata field: {e} in plugin '{entry_point.name}'"  # noqa: E501
+            f"Missing required metadata field: {e} in plugin "
+            f"'{entry_point.name}'"
         )
         raise PluginValidationError(
             f"Missing required metadata field: {e}"
         ) from e
     except Exception as e:
         logger.exception(
-            f"Failed to register lazy plugin '{entry_point.name}' from metadata: {e}"  # noqa: E501
+            f"Failed to register lazy plugin '{entry_point.name}' from "
+            f"metadata: {e}"
         )
         raise PluginValidationError(
-            f"Failed to register lazy plugin '{entry_point.name}' from metadata: {e}"  # noqa: E501
+            f"Failed to register lazy plugin '{entry_point.name}' from "
+            f"metadata: {e}"
         ) from e
 
 
@@ -412,7 +421,7 @@ def _process_class_plugin(
     entry_point: EntryPoint,
     resource_path: str,
     plugin_class: Any,
-    metadata: Optional[Dict[str, Any]] = None,
+    metadata: dict[str, Any] | None = None,
 ) -> bool:
     """
     Processes and registers a class-based plugin.
@@ -434,18 +443,21 @@ def _process_class_plugin(
     try:
         # Step 1: Plugin class already loaded
         logger.debug(
-            f"Loaded plugin class '{plugin_class.__name__}' from '{entry_point.name}'"  # noqa: E501
+            f"Loaded plugin class '{plugin_class.__name__}' from "
+            f"'{entry_point.name}'"
         )
 
         # Step 2: Determine citizenship classification
         citizenship = determine_plugin_citizenship(entry_point)
         if citizenship:
             logger.info(
-                f"Plugin '{entry_point.name}' is classified as {citizenship}-class."  # noqa: E501
+                f"Plugin '{entry_point.name}' is classified as "
+                f"{citizenship}-class."
             )
         else:
             logger.warning(
-                f"Plugin '{entry_point.name}' has unrecognized citizenship and will not be registered."  # noqa: E501
+                f"Plugin '{entry_point.name}' has unrecognized citizenship "
+                f"and will not be registered."
             )
             return False
 
@@ -459,12 +471,16 @@ def _process_class_plugin(
             )
 
             if not issubclass(plugin_class, interface_class):
-                msg = f"Plugin '{entry_point.name}' must subclass '{interface_class.__name__}'."  # noqa: E501
+                msg = (
+                    f"Plugin '{entry_point.name}' must subclass "
+                    f"'{interface_class.__name__}'."
+                )
                 logger.error(msg)
                 raise PluginValidationError(msg)
 
             logger.info(
-                f"Validated class-based plugin '{plugin_class.__name__}' against interface '{interface_class.__name__}'"  # noqa: E501
+                f"Validated class-based plugin '{plugin_class.__name__}' "
+                f"against interface '{interface_class.__name__}'"
             )
 
         # Step 4: Register the plugin in PluginCitizenshipRegistry
@@ -479,7 +495,8 @@ def _process_class_plugin(
             citizenship, resource_path, module_path
         )
         logger.info(
-            f"Registered {citizenship}-class plugin '{plugin_class.__name__}' at '{resource_path}' in PluginCitizenshipRegistry"  # noqa: E501
+            f"Registered {citizenship}-class plugin '{plugin_class.__name__}' "
+            f"at '{resource_path}' in PluginCitizenshipRegistry"
         )
 
         # Step 5: Register the plugin class in ComponentBase.TYPE_REGISTRY
@@ -499,7 +516,8 @@ def _process_class_plugin(
 
     except PluginValidationError as e:
         logger.error(
-            f"Validation failed for class-based plugin '{entry_point.name}': {e}"  # noqa: E501
+            f"Validation failed for class-based plugin '{entry_point.name}': "
+            f"{e}"
         )
         raise
     except Exception as e:
@@ -515,7 +533,7 @@ def _process_module_plugin(
     entry_point: EntryPoint,
     resource_path: str,
     plugin_module: Any,
-    metadata: Optional[Dict[str, Any]] = None,
+    metadata: dict[str, Any] | None = None,
 ) -> bool:
     """
     Processes and registers a module-based plugin.
@@ -528,14 +546,16 @@ def _process_module_plugin(
     try:
         # Module already loaded
         logger.debug(
-            f"Loaded plugin module '{plugin_module.__name__}' from '{entry_point.name}'"  # noqa: E501
+            f"Loaded plugin module '{plugin_module.__name__}' from "
+            f"'{entry_point.name}'"
         )
 
         # Iterate through __all__ to process each attribute
         module_all = getattr(plugin_module, "__all__", [])
         if not module_all:
             logger.warning(
-                f"Module '{plugin_module.__name__}' does not define __all__; skipping."  # noqa: E501
+                f"Module '{plugin_module.__name__}' does not define __all__; "
+                f"skipping."
             )
             return False
 
@@ -543,7 +563,8 @@ def _process_module_plugin(
             try:
                 attr = getattr(plugin_module, attr_name)
                 logger.debug(
-                    f"Processing attribute '{attr_name}' in module '{plugin_module.__name__}'"  # noqa: E501
+                    f"Processing attribute '{attr_name}' in module "
+                    f"'{plugin_module.__name__}'"
                 )
 
                 if inspect.isclass(attr):
@@ -570,7 +591,10 @@ def _process_module_plugin(
                             )
                         )
                         if not issubclass(attr, interface_class):
-                            msg = f"Plugin class '{attr_name}' must subclass '{interface_class.__name__}'."  # noqa: E501
+                            msg = (
+                                f"Plugin class '{attr_name}' must subclass "
+                                f"'{interface_class.__name__}'."
+                            )
                             logger.error(msg)
                             raise PluginValidationError(msg)
 
@@ -581,7 +605,8 @@ def _process_module_plugin(
                             plugin_module.__name__,
                         )
                         logger.info(
-                            f"Registered {citizenship}-class plugin '{attr_name}' at '{class_resource_path}'"  # noqa: E501
+                            f"Registered {citizenship}-class plugin "
+                            f"'{attr_name}' at '{class_resource_path}'"
                         )
 
                         # Register in TYPE_REGISTRY
@@ -596,7 +621,8 @@ def _process_module_plugin(
 
                     elif citizenship is None:
                         logger.warning(
-                            f"Plugin class '{attr_name}' has unrecognized citizenship and will not be registered."  # noqa: E501
+                            f"Plugin class '{attr_name}' has unrecognized "
+                            f"citizenship and will not be registered."
                         )
 
                 elif inspect.ismodule(attr):
@@ -630,26 +656,29 @@ def _process_module_plugin(
                             plugin_module.__name__,
                         )
                         logger.info(
-                            f"Registered third-class generic plugin '{attr_name}' at '{generic_resource_path}'"  # noqa: E501
+                            f"Registered third-class generic plugin "
+                            f"'{attr_name}' at '{generic_resource_path}'"
                         )
                     else:
                         logger.warning(
-                            f"Generic plugin '{attr_name}' in module '{plugin_module.__name__}' "(  # noqa: E501
-                                "is not classified as third-class citizen and "  # noqa: E501
-                                "cannot be "
-                                "registered."
-                            )
+                            f"Generic plugin '{attr_name}' in module "
+                            f"'{plugin_module.__name__}' "
+                            "is not classified as third-class citizen and "
+                            "cannot be "
+                            "registered."
                         )
                         continue
 
             except PluginValidationError as ve:
                 logger.error(
-                    f"Validation failed for attribute '{attr_name}' in module '{plugin_module.__name__}': {ve}"  # noqa: E501
+                    f"Validation failed for attribute '{attr_name}' in module "
+                    f"'{plugin_module.__name__}': {ve}"
                 )
                 continue
             except Exception as e:
                 logger.exception(
-                    f"Failed to process attribute '{attr_name}' in module '{plugin_module.__name__}': {e}"  # noqa: E501
+                    f"Failed to process attribute '{attr_name}' in module "
+                    f"'{plugin_module.__name__}': {e}"
                 )
                 continue
 
@@ -668,7 +697,7 @@ def _process_generic_plugin(
     entry_point: EntryPoint,
     resource_path: str,
     _plugin_object: Any,
-    metadata: Optional[Dict[str, Any]] = None,
+    metadata: dict[str, Any] | None = None,
 ) -> bool:
     """
     Processes and registers a generic plugin.
@@ -683,7 +712,9 @@ def _process_generic_plugin(
         citizenship = determine_plugin_citizenship(entry_point)
         if citizenship != "third":
             logger.warning(
-                f"Generic plugin '{entry_point.name}' is not classified as third-class citizen and cannot be registered under protected namespaces."  # noqa: E501
+                f"Generic plugin '{entry_point.name}' is not classified as "
+                f"third-class citizen and cannot be registered under "
+                f"protected namespaces."
             )
             return False
 
@@ -692,7 +723,8 @@ def _process_generic_plugin(
             "third", resource_path, entry_point.value.split(":")[0]
         )
         logger.info(
-            f"Registered generic plugin '{entry_point.name}' under '{resource_path}' for lazy loading."  # noqa: E501
+            f"Registered generic plugin '{entry_point.name}' under "
+            f"'{resource_path}' for lazy loading."
         )
 
         # Register in TYPE_REGISTRY
@@ -715,7 +747,7 @@ def _process_generic_plugin(
 # -----------------------------------------------------------------------------
 # 4. HELPER FUNCTIONS
 # -----------------------------------------------------------------------------
-def determine_plugin_citizenship(entry_point: EntryPoint) -> Optional[str]:
+def determine_plugin_citizenship(entry_point: EntryPoint) -> str | None:
     """
     Determines the citizenship classification of a plugin based on its entry
     point.
@@ -777,7 +809,8 @@ def determine_plugin_citizenship(entry_point: EntryPoint) -> Optional[str]:
     # Check for Third-Class Plugins
     if group == "swarmauri.plugins":
         logger.debug(
-            f"Plugin '{name}' classified as third-class (mapped under 'swarmauri.plugins')."  # noqa: E501
+            f"Plugin '{name}' classified as third-class (mapped under "
+            f"'swarmauri.plugins')."
         )
         return "third"
 
@@ -792,23 +825,26 @@ def determine_plugin_citizenship(entry_point: EntryPoint) -> Optional[str]:
                 # Use PluginCitizenshipRegistry to check if it's first-class
                 if PluginCitizenshipRegistry.is_first_class(entry_point):
                     logger.debug(
-                        f"Plugin '{name}' classified as first-class (pre-registered)."  # noqa: E501
+                        f"Plugin '{name}' classified as first-class "
+                        f"(pre-registered)."
                     )
                     return "first"
                 else:
                     logger.debug(
-                        f"Plugin '{name}' classified as second-class (community-contributed)."  # noqa: E501
+                        f"Plugin '{name}' classified as second-class "
+                        f"(community-contributed)."
                     )
                     return "second"
 
     # If none of the conditions match, the plugin is unrecognized
     logger.warning(
-        f"Plugin '{name}' does not match any recognized citizenship classification."  # noqa: E501
+        f"Plugin '{name}' does not match any recognized citizenship "
+        f"classification."
     )
     return None
 
 
-def _extract_resource_kind_from_group(group: str) -> Optional[str]:
+def _extract_resource_kind_from_group(group: str) -> str | None:
     """
     Extract the resource kind from something like 'swarmauri.chunkers'
     or 'swarmauri.utils'. E.g. 'swarmauri.utils' => 'utils'.
@@ -840,7 +876,8 @@ def discover_and_register_plugins(group_prefix="swarmauri."):
                     )
                 except PluginValidationError as e:
                     logger.error(
-                        f"Skipping plugin '{ep.name}' due to validation error: {e}"  # noqa: E501
+                        f"Skipping plugin '{ep.name}' due to validation "
+                        f"error: {e}"
                     )
     except Exception as e:
         logger.exception(
@@ -848,7 +885,7 @@ def discover_and_register_plugins(group_prefix="swarmauri."):
         )
 
 
-def get_plugin_type_info(resource_path: str) -> Optional[Dict[str, Any]]:
+def get_plugin_type_info(resource_path: str) -> dict[str, Any] | None:
     """
     Retrieves the plugin's type information from the registries without loading
     the module.