naas-abi-core 1.0.0__py3-none-any.whl

naas_abi_core/models/Model.py

@@ -0,0 +1,198 @@
+import os
+from datetime import datetime
+from enum import Enum
+from typing import Annotated, Dict, Optional
+
+from langchain_core.language_models.chat_models import BaseChatModel
+from naas_abi_core.models.OpenRouter import ChatOpenRouter
+from pydantic import Field
+
+OPENROUTER_MODEL_MAPPING: Dict[str, str] = {
+    "gpt-5": "openai/gpt-5",
+    "gpt-5-mini": "openai/gpt-5-mini",
+    "gpt-5-nano": "openai/gpt-5-nano",
+    "gpt-4.1": "openai/gpt-4.1",
+    "gpt-4.1-mini": "openai/gpt-4.1-mini",
+    "o3-deep-research": "openai/o3-deep-research",
+    "o4-mini-deep-research": "openai/o4-mini-deep-research",
+    "o3-mini": "openai/o3-mini",
+    "sonar-pro-search": "perplexity/sonar-pro-search",
+    "sonar-reasoning-pro": "perplexity/sonar-reasoning-pro",
+    "sonar-pro": "perplexity/sonar-pro",
+    "sonar-deep-research": "perplexity/sonar-deep-research",
+    "sonar-reasoning": "perplexity/sonar-reasoning",
+    "sonar": "perplexity/sonar",
+    "claude-haiku-4-5-20251001": "anthropic/claude-haiku-4.5",
+    "claude-sonnet-4-5-20250929": "anthropic/claude-sonnet-4.5",
+    "claude-opus-4-1-20250805": "anthropic/claude-opus-4.1",
+    "claude-opus-4-20250514": "anthropic/claude-opus-4",
+    "claude-sonnet-4-20250514": "anthropic/claude-sonnet-4",
+    "claude-3-7-sonnet-20250219": "anthropic/claude-3.7-sonnet",
+    "qwen3:8b": "qwen/qwen3-8b",
+    "mistral-large-2411": "mistralai/mistral-large-2411",
+    "mistral-medium-2508": "mistralai/mistral-medium-3.1",
+    "mistral-small-2506": "mistralai/mistral-small",
+    "grok-4": "x-ai/grok-4",
+    "gemini-2.5-flash": "google/gemini-2.5-flash",
+}
+
+
+class ModelType(Enum):
+    CHAT = "chat"
+
+
+class Model:
+    model_id: Annotated[str, Field(description="Unique identifier for the model")]
+    provider: Annotated[
+        str,
+        Field(
+            description="The provider of the model (e.g. 'openai', 'anthropic', 'openrouter', 'aws bedrock', etc.)"
+        ),
+    ]
+    model: Annotated[
+        BaseChatModel, Field(description="The base model chat from Langchain")
+    ]
+    name: Annotated[
+        Optional[str],
+        Field(
+            description="Display name of the model (e.g. 'GPT-4.1', 'Claude Sonnet 4.5', 'Grok 4', 'Mistral Large', 'Gemini 2.5 Flash', etc.)"
+        ),
+    ]
+    owner: Annotated[Optional[str], Field(description="The owner/creator of the model")]
+    description: Annotated[
+        Optional[str],
+        Field(
+            description="The description of the model (e.g. 'GPT-4.1 is OpenAI's most advanced model with superior performance across text, code, and reasoning tasks.', 'Claude Sonnet 4.5 is Anthropic's most advanced Sonnet model to date, optimized for real-world agents and coding workflows.', 'Grok 4 is xAI's latest multimodal model with SOTA cost-efficiency and a 2M token context window. It comes in two flavors: non-reasoning and reasoning. Read more about the model on xAI's [news post](http://x.ai/news/grok-4-fast). Reasoning can be enabled using the `reasoning` `enabled` parameter in the API. [Learn more in our docs](https://openrouter.ai/docs/use-cases/reasoning-tokens#controlling-reasoning-tokens)', 'Mistral Large is Mistral's latest large model with superior performance across text, code, and reasoning tasks.', 'Gemini 2.5 Flash is Google's latest multimodal model with superior performance across text, code, and reasoning tasks.', etc.)"
+        ),
+    ]
+    image: Annotated[Optional[str], Field(description="The image of the model")]
+    created_at: Annotated[
+        Optional[datetime], Field(description="The date and time the model was created")
+    ]
+    canonical_slug: Annotated[
+        Optional[str], Field(description="Canonical slug for the model")
+    ]
+    hugging_face_id: Annotated[
+        Optional[str], Field(description="Hugging Face model identifier, if applicable")
+    ]
+    pricing: Annotated[
+        Optional[dict], Field(description="Pricing information for the model")
+    ]
+    architecture: Annotated[
+        Optional[dict], Field(description="Model architecture information")
+    ]
+    top_provider: Annotated[
+        Optional[dict],
+        Field(description="Information about the top provider for this model"),
+    ]
+    per_request_limits: Annotated[
+        Optional[dict], Field(description="Per-request token limits")
+    ]
+    supported_parameters: Annotated[
+        Optional[list], Field(description="List of supported parameters for this model")
+    ]
+    default_parameters: Annotated[
+        Optional[dict], Field(description="Default parameters for this model")
+    ]
+
+    def __init__(
+        self,
+        model_id: str,
+        provider: str,
+        model: BaseChatModel,
+        name: Optional[str] = None,
+        owner: Optional[str] = None,
+        description: Optional[str] = None,
+        image: Optional[str] = None,
+        created_at: Optional[datetime] = None,
+        canonical_slug: Optional[str] = None,
+        hugging_face_id: Optional[str] = None,
+        pricing: Optional[dict] = None,
+        architecture: Optional[dict] = None,
+        top_provider: Optional[dict] = None,
+        per_request_limits: Optional[dict] = None,
+        supported_parameters: Optional[list] = None,
+        default_parameters: Optional[dict] = None,
+    ):
+        self.model_id = model_id
+        self.provider = provider
+
+        # If OPENROUTER_API_KEY is set, use ChatOpenRouter as BaseChatModel
+        if (
+            os.getenv("OPENROUTER_API_KEY")
+            and os.getenv("AI_MODE") == "cloud"
+            and isinstance(model, BaseChatModel)
+            and not isinstance(model, ChatOpenRouter)
+        ):
+            if model_id in OPENROUTER_MODEL_MAPPING:
+                self.model = ChatOpenRouter(
+                    model_name=OPENROUTER_MODEL_MAPPING[model_id]
+                )
+            else:
+                raise ValueError(f"""Model '{model_id}' from provider '{provider}' not found in OPENROUTER_MODEL_MAPPING. 
+                Please add it to the mapping in lib/abi/models/Model.py.""")
+        else:
+            self.model = model
+
+        self.name = name
+        self.owner = owner
+        self.description = description
+        self.image = image
+        self.created_at = created_at
+        self.canonical_slug = canonical_slug
+        self.hugging_face_id = hugging_face_id
+        self.pricing = pricing
+        self.architecture = architecture
+        self.top_provider = top_provider
+        self.per_request_limits = per_request_limits
+        self.supported_parameters = supported_parameters
+        self.default_parameters = default_parameters
+
+
+class ChatModel(Model):
+    model: BaseChatModel
+    context_window: Annotated[
+        Optional[int], Field(description="Maximum context length in tokens")
+    ]
+    model_type: ModelType = ModelType.CHAT
+
+    def __init__(
+        self,
+        model_id: str,
+        provider: str,
+        model: BaseChatModel,
+        context_window: Optional[int] = None,
+        name: Optional[str] = None,
+        owner: Optional[str] = None,
+        description: Optional[str] = None,
+        image: Optional[str] = None,
+        created_at: Optional[datetime] = None,
+        canonical_slug: Optional[str] = None,
+        hugging_face_id: Optional[str] = None,
+        pricing: Optional[dict] = None,
+        architecture: Optional[dict] = None,
+        top_provider: Optional[dict] = None,
+        per_request_limits: Optional[dict] = None,
+        supported_parameters: Optional[list] = None,
+        default_parameters: Optional[dict] = None,
+    ):
+        super().__init__(
+            model_id=model_id,
+            provider=provider,
+            model=model,
+            name=name,
+            owner=owner,
+            description=description,
+            image=image,
+            created_at=created_at,
+            canonical_slug=canonical_slug,
+            hugging_face_id=hugging_face_id,
+            pricing=pricing,
+            architecture=architecture,
+            top_provider=top_provider,
+            per_request_limits=per_request_limits,
+            supported_parameters=supported_parameters,
+            default_parameters=default_parameters,
+        )
+        self.model_type = ModelType.CHAT
+        self.context_window = context_window

naas_abi_core/models/OpenRouter.py

@@ -0,0 +1,15 @@
+import os
+from langchain_openai import ChatOpenAI  # using the OpenAI LLM class as wrapper
+from pydantic import SecretStr
+from dotenv import load_dotenv
+load_dotenv()
+
+class ChatOpenRouter(ChatOpenAI):
+    def __init__(self, model_name: str, **kwargs):
+        api_key = SecretStr(os.environ["OPENROUTER_API_KEY"])
+        super().__init__(
+            model=model_name,
+            api_key=api_key,
+            base_url="https://openrouter.ai/api/v1",
+            **kwargs,
+        )

naas_abi_core/models/OpenRouter_test.py

@@ -0,0 +1,36 @@
+from naas_abi_core.models.OpenRouter import ChatOpenRouter
+
+
+def test_openai():
+    llm = ChatOpenRouter(model_name="openai/gpt-4.1")
+    result = llm.invoke("What is the capital of France?").content
+    assert result is not None, result
+    assert "Paris" in result, result
+
+
+def test_anthropic():
+    llm = ChatOpenRouter(model_name="anthropic/claude-sonnet-4.5")
+    result = llm.invoke("What is the capital of France?").content
+    assert result is not None, result
+    assert "Paris" in result, result
+
+
+def test_xai():
+    llm = ChatOpenRouter(model_name="x-ai/grok-4")
+    result = llm.invoke("What is the capital of France?").content
+    assert result is not None, result
+    assert "Paris" in result, result
+
+
+def test_mistral():
+    llm = ChatOpenRouter(model_name="mistralai/mistral-large")
+    result = llm.invoke("What is the capital of France?").content
+    assert result is not None, result
+    assert "Paris" in result, result
+
+
+def test_gemini():
+    llm = ChatOpenRouter(model_name="google/gemini-2.5-flash")
+    result = llm.invoke("What is the capital of France?").content
+    assert result is not None, result
+    assert "Paris" in result, result

naas_abi_core/module/Module.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+import glob
+import os
+from typing import Dict, List
+
+from naas_abi_core import logger
+from naas_abi_core.engine.engine_configuration.EngineConfiguration import GlobalConfig
+from naas_abi_core.engine.EngineProxy import EngineProxy
+from naas_abi_core.integration.integration import Integration
+from naas_abi_core.module.ModuleAgentLoader import ModuleAgentLoader
+from naas_abi_core.pipeline.pipeline import Pipeline
+from naas_abi_core.services.agent.Agent import Agent
+from naas_abi_core.workflow.workflow import Workflow
+from pydantic import BaseModel, ConfigDict
+
+
+class ModuleDependencies:
+    __modules: List[str]
+    __services: List[type]
+
+    def __init__(self, modules: List[str], services: List[type]):
+        self.__modules = modules
+        self.__services = services
+
+    def _get_modules(self) -> List[str]:
+        return self.__modules
+
+    def _set_modules(self, modules: List[str]) -> None:
+        self.__modules = modules
+
+    modules = property(_get_modules, _set_modules)
+
+    def _get_services(self) -> List[type]:
+        return self.__services
+
+    def _set_services(self, services: List[type]) -> None:
+        self.__services = services
+
+    services = property(_get_services, _set_services)
+
+
+class ModuleConfiguration(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    global_config: GlobalConfig
+
+
+class BaseModule:
+    """Base interface class for ABI modules."""
+
+    _instances: Dict[type, "BaseModule"] = {}
+
+    _engine: EngineProxy
+    _configuration: ModuleConfiguration
+    dependencies: ModuleDependencies = ModuleDependencies(modules=[], services=[])
+
+    __ontologies: List[str] = []
+    __agents: List[type[Agent]] = []
+    __integrations: List[Integration] = []
+    __workflows: List[Workflow] = []
+    __pipelines: List[Pipeline] = []
+
+    def __init__(self, engine: EngineProxy, configuration: ModuleConfiguration):
+        assert isinstance(configuration, ModuleConfiguration), (
+            "configuration must be an instance of ModuleConfiguration"
+        )
+        logger.debug(f"Initializing module {self.__module__.split('.')[0]}")
+        self._engine = engine
+        self._configuration = configuration
+
+        assert hasattr(self.__class__, "Configuration"), (
+            "BaseModule must have a Configuration class"
+        )
+        assert type(self.__class__.Configuration) is type(ModuleConfiguration), (
+            "BaseModule.Configuration must be a subclass of ModuleConfiguration"
+        )
+
+        self._instances[self.__class__] = self
+
+    @classmethod
+    def get_dependencies(cls) -> List[str]:
+        """Return the list of module dependencies."""
+        return getattr(cls, "dependencies", [])
+
+    @classmethod
+    def get_instance(cls) -> "BaseModule":
+        if cls not in cls._instances:
+            raise ValueError(f"Module {cls} not initialized")
+        return cls._instances[cls]
+
+    @property
+    def engine(self) -> EngineProxy:
+        return self._engine
+
+    @property
+    def configuration(self) -> ModuleConfiguration:
+        return self._configuration
+
+    @property
+    def ontologies(self) -> List[str]:
+        return self.__ontologies
+
+    @property
+    def agents(self) -> List[type[Agent]]:
+        return self.__agents
+
+    @property
+    def integrations(self) -> List[Integration]:
+        return self.__integrations
+
+    @property
+    def workflows(self) -> List[Workflow]:
+        return self.__workflows
+
+    @property
+    def pipelines(self) -> List[Pipeline]:
+        return self.__pipelines
+
+    def on_load(self):
+        logger.debug(f"on_load for module {self.__module__.split('.')[0]}")
+        self.__load_ontologies()
+
+        self.__agents = ModuleAgentLoader.load_agents(self.__class__)
+
+    def on_initialized(self):
+        """
+        Called after all modules have been loaded and the engine is fully initialized.
+
+        Use this method to perform post-initialization steps that require other modules,
+        services, or ontologies to be available and loaded.
+        """
+        logger.debug(f"on_initialized for module {self.__module__.split('.')[0]}")
+
+    def on_unloaded(self):
+        pass
+
+    def __load_ontologies(self):
+        if os.path.exists(os.path.join(self.__module__.split(".")[0], "ontologies")):
+            for file in glob.glob(
+                os.path.join(self.module_path, "ontologies", "**", "*.ttl"),
+                recursive=True,
+            ):
+                self.ontologies.append(file)
+
+
+# class IModule(ABC):
+#     """Base interface class for ABI modules.
+
+#     This class serves as the base interface for all modules in the src/modules directory.
+
+#     The IModule class provides a default loading mechanism.
+
+
+#     The default loading mechanism will:
+#     1. Load all agents from the module's 'agents' directory
+#     2. Initialize module configuration and state
+
+#     Attributes:
+#         agents (List[Agent]): List of agents loaded from the module
+#     """
+
+#     agents: List[Agent]
+#     triggers: List[tuple[tuple[Any, Any, Any], OntologyEvent, Callable]]
+#     ontologies: List[str]
+
+#     def __init__(self, module_path: str, module_import_path: str, imported_module: Any):
+#         self.module_path = module_path
+#         self.module_import_path = module_import_path
+#         self.imported_module = imported_module
+#         self.triggers = []
+#         self.ontologies = []
+#         self.agents = []
+
+#     def check_requirements(self):
+#         if hasattr(self.imported_module, "requirements"):
+#             if not self.imported_module.requirements():
+#                 logger.error(f"❌ Module {self.module_import_path} failed to meet requirements.")
+#                 raise SystemExit(f"Application crashed due to module loading failure: {self.module_import_path}")
+
+#     def load(self):
+#         try:
+#             self.check_requirements()
+#             # self.__load_agents()
+#             self.__load_triggers()
+#             self.__load_ontologies()
+#         except Exception as e:
+#             logger.error(f"❌ Critical error loading module {self.module_import_path}: {e}")
+#             raise SystemExit(f"Application crashed due to module loading failure: {self.module_import_path}")
+
+#     def load_agents(self):
+#         try:
+#             self.__load_agents()
+#         except Exception as e:
+#             import traceback
+#             logger.error(f"❌ Critical error loading agents for module {self.module_import_path}: {e}")
+#             traceback.print_exc()
+#             raise SystemExit(f"Application crashed due to agent loading failure: {self.module_import_path}")
+
+#     def __load_agents(self):
+#         # Load agents
+#         self.agents = []
+#         loaded_agent_names = set()
+
+#         # Find all agent files recursively
+#         for root, _, files in os.walk(self.module_path):
+#             for file in files:
+#                 if file.endswith("Agent.py") and not file.endswith("Agent_test.py"):
+#                     # Get relative path from module root to agent file
+#                     rel_path = os.path.relpath(root, self.module_path)
+#                     # Convert path to import format
+#                     import_path = rel_path.replace(os.sep, ".")
+#                     if import_path == ".":
+#                         agent_path = self.module_import_path + "." + file[:-3]
+#                     else:
+#                         agent_path = self.module_import_path + "." + import_path + "." + file[:-3]
+
+#                     module = importlib.import_module(agent_path)
+#                     if hasattr(module, "create_agent"):
+#                         agent = module.create_agent()
+#                         if agent is not None:
+#                             agent_name = getattr(agent, "name", None)
+#                             if agent_name and agent_name not in loaded_agent_names:
+#                                 self.agents.append(agent)
+#                                 loaded_agent_names.add(agent_name)
+#                             else:
+#                                 logger.warning(f"Skipping duplicate agent: {agent_name}")
+
+#     def __load_triggers(self):
+#         if os.path.exists(os.path.join(self.module_path, "triggers.py")):
+#             module = importlib.import_module(self.module_import_path + ".triggers")
+#             if hasattr(module, "triggers"):
+#                 self.triggers = module.triggers
+
+#     def __load_ontologies(self):
+#         if os.path.exists(os.path.join(self.module_path, "ontologies")):
+#             for file in glob.glob(
+#                 os.path.join(self.module_path, "ontologies", "**", "*.ttl"),
+#                 recursive=True,
+#             ):
+#                 self.ontologies.append(file)
+
+#     def on_initialized(self):
+#         if hasattr(self.imported_module, "on_initialized"):
+#             self.imported_module.on_initialized()

naas_abi_core/module/ModuleAgentLoader.py

@@ -0,0 +1,49 @@
+import importlib
+import os
+from typing import List
+
+from naas_abi_core.module.ModuleUtils import find_class_module_root_path
+from naas_abi_core.services.agent.Agent import Agent
+from naas_abi_core.utils.Logger import logger
+
+
+class ModuleAgentLoader:
+    @classmethod
+    def load_agents(cls, class_: type) -> List[type[Agent]]:
+        agents: List[type[Agent]] = []
+        module_root_path = find_class_module_root_path(class_)
+
+        agents_path = module_root_path / "agents"
+
+        logger.debug(f"Loading agents from {agents_path}")
+
+        if os.path.exists(agents_path):
+            for file in os.listdir(agents_path):
+                if file.endswith(".py") and not file.endswith("test.py"):
+                    agent_module_path = (
+                        f"{class_.__module__}.agents.{file.replace('.py', '')}"
+                    )
+                    agent_module = importlib.import_module(agent_module_path)
+                    for key, value in agent_module.__dict__.items():
+                        if (
+                            isinstance(value, type)
+                            and issubclass(value, Agent)
+                            and value.__module__.split(".")[0]
+                            == class_.__module__.split(".")[
+                                0
+                            ]  # This makes sure we only load agents from the same module.
+                        ):
+                            if not hasattr(key, "New") and hasattr(
+                                agent_module, "create_agent"
+                            ):
+                                setattr(
+                                    getattr(agent_module, key),
+                                    "New",
+                                    getattr(agent_module, "create_agent"),
+                                )
+
+                            agents.append(getattr(agent_module, key))
+
+        logger.debug(f"Agents: {agents}")
+
+        return agents

naas_abi_core/module/ModuleUtils.py

@@ -0,0 +1,20 @@
+import inspect
+from pathlib import Path
+
+
+def find_class_module_root_path(class_: type) -> Path:
+    class_file_path = inspect.getfile(class_)
+    class_path = Path(class_file_path)
+    class_directory = str(class_path.parent)
+    return Path(class_directory)
+    # logger.debug(f"Class directory: {class_.__module__}")
+    # logger.debug(f"Class file path: {class_directory}")
+    # module_name = class_.__module__.split(".")[0]
+
+    # # find last occurrence of module_name in class_directory
+    # module_root_path = class_directory[
+    #     : class_directory.rfind(module_name) + len(module_name)
+    # ]
+
+    # logger.debug(f"Module root path: {module_root_path}")
+    # return Path(module_root_path)