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

naas_abi_core/engine/engine_loaders/EngineModuleLoader.py

@@ -0,0 +1,302 @@
+import importlib
+from typing import Dict, List
+
+import pydantic_core
+from naas_abi_core import logger
+from naas_abi_core.engine.engine_configuration.EngineConfiguration import (
+    EngineConfiguration,
+)
+from naas_abi_core.engine.EngineProxy import EngineProxy
+from naas_abi_core.engine.IEngine import IEngine
+from naas_abi_core.module.Module import (
+    BaseModule,
+    ModuleConfiguration,
+    ModuleDependencies,
+)
+
+
+class EngineModuleLoader:
+    __configuration: EngineConfiguration
+
+    __module_load_order: List[str] = []
+
+    __modules: Dict[str, BaseModule] = {}
+
+    __module_dependencies: Dict[str, ModuleDependencies] | None = None
+
+    def __init__(self, configuration: EngineConfiguration):
+        self.__configuration = configuration
+
+    @property
+    def modules(self) -> Dict[str, BaseModule]:
+        return self.__modules
+
+    @property
+    def module_load_order(self) -> List[str]:
+        return self.__module_load_order
+
+    @property
+    def ordered_modules(self) -> List[BaseModule]:
+        return [self.__modules[module_name] for module_name in self.__module_load_order]
+
+    def __topological_sort(self, dependencies: Dict[str, List[str]]) -> List[str]:
+        """
+        Perform topological sort on modules based on dependencies.
+        Returns a list of module names in load order.
+        Raises ValueError if circular dependency is detected.
+        """
+        # Build adjacency list and in-degree count
+        in_degree = {node: 0 for node in dependencies}
+        adj_list: Dict[str, List[str]] = {node: [] for node in dependencies}
+
+        for node, deps in dependencies.items():
+            for dep in deps:
+                soft_dependency = dep.endswith("#soft")
+                if dep.endswith("#soft"):
+                    dep = dep.replace("#soft", "")
+
+                if (
+                    dep not in dependencies and not soft_dependency
+                ):  # Soft modules are not required to be in the dependencies.
+                    logger.error(
+                        f"Module '{node}' depends on '{dep}' which is not enabled. "
+                        "Aborting."
+                    )
+                    raise ValueError(
+                        f"Module '{node}' depends on '{dep}' which is not enabled. "
+                        "Aborting."
+                    )
+                    continue
+
+                if dep in adj_list:
+                    adj_list[dep].append(node)
+                    in_degree[node] += 1
+
+        # Kahn's algorithm
+        queue = [node for node in in_degree if in_degree[node] == 0]
+        sorted_list = []
+
+        while queue:
+            # Sort queue for deterministic order when multiple nodes have in-degree 0
+            queue.sort()
+            node = queue.pop(0)
+            sorted_list.append(node)
+
+            for neighbor in adj_list[node]:
+                in_degree[neighbor] -= 1
+                if in_degree[neighbor] == 0:
+                    queue.append(neighbor)
+
+        # Check for circular dependencies
+        if len(sorted_list) != len(dependencies):
+            unprocessed = [node for node in dependencies if node not in sorted_list]
+            raise ValueError(
+                f"Circular dependency detected among modules: {unprocessed}. "
+                "Cannot determine load order."
+            )
+
+        logger.debug(f"Module load order: {sorted_list}")
+        return sorted_list
+
+    def module_dependencies_recursive(
+        self, module_name: str, module_dependencies: Dict[str, ModuleDependencies]
+    ) -> List[str]:
+        required_modules: List[str] = [module_name]
+        # This is not protected against circular dependencies.
+        # This is why it must be ran after the topological sort.
+        for dependency in module_dependencies[module_name].modules:
+            required_modules.append(dependency)
+            required_modules.extend(
+                self.module_dependencies_recursive(dependency, module_dependencies)
+            )
+        return list(set(required_modules))
+
+    def modules_dependencies_recursive(
+        self,
+        module_names: List[str],
+        module_dependencies: Dict[str, ModuleDependencies],
+    ) -> List[str]:
+        dependencies: List[str] = []
+        for module_name in module_names:
+            dependencies.extend(
+                self.module_dependencies_recursive(module_name, module_dependencies)
+            )
+        return list(set(dependencies))
+
+    def get_module_dependencies(
+        self, module_name: str, scanned_modules: List[str] = []
+    ) -> Dict[str, ModuleDependencies]:
+        dependencies: Dict[str, ModuleDependencies] = {}
+        logger.debug(f"Getting module dependencies for {module_name}")
+        is_soft_module = module_name.endswith("#soft")
+        module_name = module_name.replace("#soft", "")
+        if module_name in scanned_modules:
+            raise ValueError(
+                f"Circular dependency detected: {scanned_modules + [module_name]}"
+            )
+
+        module_config = next(
+            (m for m in self.__configuration.modules if m.module == module_name),
+            None,
+        )
+
+        if module_config is None and not is_soft_module:
+            raise ValueError(f"Module {module_name} not found in configuration")
+        elif module_config is None and is_soft_module:
+            # Soft modules are not required to be in the configuration.
+            # We return an empty dictionary.
+            return {}
+
+        assert module_config is not None, (
+            f"Module {module_name} configuration is not set in the configuration file"
+        )
+
+        if module_config.module is None:
+            raise ValueError(
+                f"Module {module_name} configuration module is not set in the configuration file"
+            )
+
+        module = importlib.import_module(module_config.module)
+        if module is None:
+            raise ValueError(
+                f"Error while trying to import module {module_config.module}"
+            )
+
+        assert hasattr(module, "ABIModule"), (
+            f"Module {module_config.module} does not have a ABIModule class"
+        )
+        assert hasattr(module.ABIModule, "get_dependencies"), (
+            f"Module {module_config.module} does not have a get_dependencies method"
+        )
+        dependencies[module_name] = module.ABIModule.get_dependencies()
+        assert isinstance(dependencies[module_name], ModuleDependencies), (
+            f"Module {module_config.module} get_dependencies method must return a ModuleDependencies object"
+        )
+
+        # We recursively get the dependencies of the module.
+        for module_dependency in dependencies[module_name].modules:
+            submodule_dependencies = self.get_module_dependencies(
+                module_dependency, scanned_modules + [module_name]
+            )
+            dependencies.update(submodule_dependencies)
+
+            # dependencies.modules.extend(submodule_dependencies.modules)
+            # dependencies.services.extend(submodule_dependencies.services)
+
+        # # Make sure we have unique modules and services.
+        # dependencies.modules = list(set(dependencies.modules))
+        # dependencies.services = list(set(dependencies.services))
+
+        logger.debug(f"Module dependencies for {module_name}: {dependencies}")
+
+        return dependencies
+
+    def get_modules_dependencies(
+        self, module_names: List[str] = []
+    ) -> Dict[str, ModuleDependencies]:
+        module_dependencies: Dict[str, ModuleDependencies] = {}
+        for module_config in self.__configuration.modules:
+            # We check if the module is required by the configuration.
+            if (
+                len(module_names) > 0
+                and module_config.module in module_names
+                and not module_config.enabled
+            ):
+                raise ValueError(
+                    f"Module {module_config.module} is not enabled but is required by the configuration"
+                )
+
+            if len(module_names) > 0 and module_config.module not in module_names:
+                continue
+
+            assert module_config.module is not None, (
+                f"Module {module_config.module} configuration module is not set in the configuration file"
+            )
+            if module_config.enabled:
+                module_dependencies.update(
+                    self.get_module_dependencies(module_config.module)
+                )
+        self.__module_dependencies = module_dependencies
+        return self.__module_dependencies
+
+    def load_modules(
+        self,
+        engine: IEngine,
+        module_names: List[str] = [],
+    ) -> Dict[str, BaseModule]:
+        self.__modules: Dict[str, BaseModule] = {}
+
+        if self.__module_dependencies is None:
+            # Call this to hydrate the __module_dependencies attribute.
+            self.__module_dependencies = self.get_modules_dependencies(module_names)
+
+        assert self.__module_dependencies is not None, (
+            "Module dependencies are not set after getting modules dependencies"
+        )
+
+        logger.debug(f"Module dependencies: {self.__module_dependencies}")
+
+        module_load_order = self.__topological_sort(
+            {
+                module_name: dependencies.modules
+                for module_name, dependencies in self.__module_dependencies.items()
+            }
+        )
+
+        self.__module_load_order = module_load_order
+
+        # We load the modules in the order of the topological sort
+        for module_name in self.__module_load_order:
+            module_config = next(
+                (m for m in self.__configuration.modules if m.module == module_name),
+                None,
+            )
+            if module_config is None:
+                raise ValueError(f"Module {module_name} not found in configuration")
+
+            if module_config.enabled:
+                if module_config.module:
+                    module = importlib.import_module(module_config.module)
+                    if not hasattr(module, "ABIModule"):
+                        raise ValueError(
+                            f"Module {module_config.module} does not have a Module class"
+                        )
+
+                    if not hasattr(module.ABIModule, "Configuration"):
+                        raise ValueError(
+                            f"Module {module_config.module} does not have a Configuration class"
+                        )
+
+                    assert type(module.ABIModule.Configuration) is type(
+                        ModuleConfiguration
+                    ), (
+                        f"Module {module_config.module} Configuration must be a subclass of ModuleConfiguration"
+                    )
+
+                    try:
+                        cfg = module.ABIModule.Configuration(
+                            global_config=self.__configuration.global_config,
+                            **module_config.config,
+                        )
+                    except pydantic_core._pydantic_core.ValidationError as e:
+                        raise ValueError(
+                            f"Error loading configuration for module {module_config.module}: {e}"
+                        ) from e
+
+                    # This effectively creates a new instance of the module.
+                    # It will call the constructor of the ABIModule class inside the module.
+                    module = module.ABIModule(
+                        EngineProxy(
+                            engine, module_name, self.__module_dependencies[module_name]
+                        ),
+                        cfg,
+                    )
+                    assert isinstance(module, BaseModule), (
+                        f"Module {module_config.module} is not a subclass of BaseModule"
+                    )
+                    self.__modules[module_name] = module
+                    module.on_load()
+                else:
+                    raise ValueError("module must be provided for a module")
+
+        return self.__modules

naas_abi_core/engine/engine_loaders/EngineOntologyLoader.py

@@ -0,0 +1,16 @@
+from typing import List
+
+from naas_abi_core import logger
+from naas_abi_core.module.Module import BaseModule
+from naas_abi_core.services.triple_store.TripleStoreService import TripleStoreService
+
+
+class EngineOntologyLoader:
+    @classmethod
+    def load_ontologies(
+        cls, triple_store: TripleStoreService, modules: List[BaseModule]
+    ) -> None:
+        logger.debug("Loading ontologies")
+        for module in modules:
+            for ontology in module.ontologies:
+                triple_store.load_schema(ontology)

naas_abi_core/engine/engine_loaders/EngineServiceLoader.py

@@ -0,0 +1,47 @@
+from typing import Dict, List
+
+from naas_abi_core import logger
+from naas_abi_core.engine.engine_configuration.EngineConfiguration import (
+    EngineConfiguration,
+)
+from naas_abi_core.engine.IEngine import IEngine
+from naas_abi_core.module.Module import ModuleDependencies
+from naas_abi_core.services.object_storage.ObjectStorageService import (
+    ObjectStorageService,
+)
+from naas_abi_core.services.secret.Secret import Secret
+from naas_abi_core.services.triple_store.TripleStoreService import TripleStoreService
+from naas_abi_core.services.vector_store.VectorStoreService import VectorStoreService
+
+
+class EngineServiceLoader:
+    __configuration: EngineConfiguration
+
+    def __init__(self, configuration: EngineConfiguration):
+        self.__configuration = configuration
+
+    def load_services(
+        self, module_dependencies: Dict[str, ModuleDependencies]
+    ) -> IEngine.Services:
+        services_to_load: List[type] = []
+
+        for _, module_dependency in module_dependencies.items():
+            services_to_load.extend(module_dependency.services)
+
+        services_to_load = list(set(services_to_load))
+        logger.debug(f"Services to load: {services_to_load}")
+
+        return IEngine.Services(
+            self.__configuration.services.object_storage.load()
+            if ObjectStorageService in services_to_load
+            else None,
+            self.__configuration.services.triple_store.load()
+            if TripleStoreService in services_to_load
+            else None,
+            self.__configuration.services.vector_store.load()
+            if VectorStoreService in services_to_load
+            else None,
+            self.__configuration.services.secret.load()
+            if Secret in services_to_load
+            else None,
+        )

naas_abi_core/integration/__init__.py

@@ -0,0 +1,7 @@
+from naas_abi_core.integration.integration import Integration as Integration
+from naas_abi_core.integration.integration import (
+    IntegrationConfiguration as IntegrationConfiguration,
+)
+from naas_abi_core.integration.integration import (
+    IntegrationConnectionError as IntegrationConnectionError,
+)

naas_abi_core/integration/integration.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+
+
+class IntegrationConnectionError(Exception):
+    pass
+
+
+@dataclass
+class IntegrationConfiguration:
+    pass
+
+
+class Integration:
+    """An Integration represents a way to interact with a third-party tool.
+
+    The Integration class serves as a base class for implementing connections to external services,
+    APIs, or tools. It provides a standardized interface for configuring and establishing these
+    connections.
+
+    Attributes:
+        __configuration (IntegrationConfiguration): Configuration instance containing
+            necessary credentials and settings for connecting to the third-party tool.
+    """
+
+    __configuration: IntegrationConfiguration
+
+    def __init__(self, configuration: IntegrationConfiguration):
+        self.__configuration = configuration

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,18 @@
+import os
+
+# from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI  # using the OpenAI LLM class as wrapper
+from pydantic import SecretStr
+
+# 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