iatoolkit 0.91.1__py3-none-any.whl → 1.7.0__py3-none-any.whl

iatoolkit/__init__.py

@@ -3,7 +3,7 @@
 #
 # IAToolkit is open source software.
 
-__version__ = "0.91.1"
+__version__ = "1.7.0"
 
 # Expose main classes and functions at the top level of the package
 
@@ -17,13 +17,14 @@ from .base_company import BaseCompany
 # --- Services ---
 from iatoolkit.services.query_service import QueryService
 from iatoolkit.services.document_service import DocumentService
-from iatoolkit.services.search_service import SearchService
+from iatoolkit.services.knowledge_base_service import KnowledgeBaseService
 from iatoolkit.services.sql_service import SqlService
 from iatoolkit.services.load_documents_service import LoadDocumentsService
 from iatoolkit.infra.call_service import CallServiceClient
 from iatoolkit.services.profile_service import ProfileService
 from iatoolkit.services.mail_service import MailService
 from iatoolkit.repositories.models import Base as OrmModel
+from iatoolkit.base_company import BaseCompany
 
 __all__ = [
     'IAToolkit',
@@ -35,10 +36,11 @@ __all__ = [
     'QueryService',
     'SqlService',
     'DocumentService',
-    'SearchService',
+    'KnowledgeBaseService',
     'LoadDocumentsService',
     'CallServiceClient',
     'ProfileService',
     'MailService',
-    'OrmModel'
+    'OrmModel',
+    'BaseCompany',
 ]

iatoolkit/base_company.py

@@ -5,21 +5,8 @@
 
 # companies/base_company.py
 from abc import ABC, abstractmethod
-from iatoolkit.repositories.profile_repo import ProfileRepo
-from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
-from iatoolkit.repositories.models import Company
-from iatoolkit.core import IAToolkit
-
 
 class BaseCompany(ABC):
-    def __init__(self):
-        # Obtener el inyector global y resolver las dependencias internamente
-        injector = IAToolkit.get_instance().get_injector()
-        self.profile_repo: ProfileRepo = injector.get(ProfileRepo)
-        self.llm_query_repo: LLMQueryRepo = injector.get(LLMQueryRepo)
-        self.company: Company | None = None
-        self.company_short_name = ''
-
 
     @abstractmethod
     # execute the specific action configured in the intent table
@@ -28,9 +15,6 @@ class BaseCompany(ABC):
 
     @abstractmethod
     def register_cli_commands(self, app):
-        """
-        optional method for a company definition of it's cli commands
-        """
         pass
 
     def unsupported_operation(self, tag):

iatoolkit/cli_commands.py

@@ -14,12 +14,13 @@ def register_core_commands(app):
 
     @app.cli.command("api-key")
     @click.argument("company_short_name")
-    def api_key(company_short_name: str):
+    @click.argument("key_name")
+    def api_key(company_short_name: str, key_name: str):
         """⚙️ Genera una nueva API key para una compañía ya registrada."""
         try:
             profile_service = IAToolkit.get_instance().get_injector().get(ProfileService)
             click.echo(f"🔑 Generating API-KEY for company: '{company_short_name}'...")
-            result = profile_service.new_api_key(company_short_name)
+            result = profile_service.new_api_key(company_short_name, key_name)
 
             if 'error' in result:
                 click.echo(f"❌ Error: {result['error']}")
@@ -44,17 +45,5 @@ def register_core_commands(app):
             logging.exception(e)
             click.echo(f"Error: {str(e)}")
 
-    @app.cli.command("exec-tasks")
-    @click.argument("company_short_name")
-    def exec_pending_tasks(company_short_name: str):
-        from iatoolkit.services.tasks_service import TaskService
-        task_service = IAToolkit.get_instance().get_injector().get(TaskService)
-
-        try:
-            result = task_service.trigger_pending_tasks(company_short_name)
-            click.echo(result['message'])
-        except Exception as e:
-            logging.exception(e)
-            click.echo(f"Error: {str(e)}")
 
 

iatoolkit/common/exceptions.py

@@ -38,6 +38,7 @@ class IAToolkitException(Exception):
         INVALID_USER = 26
         VECTOR_STORE_ERROR = 27
         EMBEDDING_ERROR = 28
+        MODEL = 29
 
 
 

iatoolkit/common/interfaces/asset_storage.py

@@ -0,0 +1,34 @@
+from enum import Enum
+from typing import List
+import abc
+
+
+class AssetType(Enum):
+    CONFIG = "config"
+    PROMPT = "prompts"
+    SCHEMA = "schema"
+    CONTEXT = "context"
+
+
+class AssetRepository(abc.ABC):
+    @abc.abstractmethod
+    def exists(self, company_short_name: str, asset_type: AssetType, filename: str) -> bool:
+        pass
+
+    @abc.abstractmethod
+    def read_text(self, company_short_name: str, asset_type: AssetType, filename: str) -> str:
+        pass
+
+    @abc.abstractmethod
+    def list_files(self, company_short_name: str, asset_type: AssetType, extension: str = None) -> List[str]:
+        pass
+
+    @abc.abstractmethod
+    def write_text(self, company_short_name: str, asset_type: AssetType, filename: str, content: str) -> None:
+        """Creates or updates a text asset."""
+        pass
+
+    @abc.abstractmethod
+    def delete(self, company_short_name: str, asset_type: AssetType, filename: str) -> None:
+        """Deletes an asset if it exists."""
+        pass

iatoolkit/common/interfaces/database_provider.py

@@ -0,0 +1,43 @@
+import abc
+from typing import Any, List, Dict, Union
+
+class DatabaseProvider(abc.ABC):
+    """
+    Abstract interface for interacting with a database source.
+    Handles both metadata introspection and query execution.
+    """
+
+    # --- Schema Methods ---
+    @abc.abstractmethod
+    def get_database_structure(self) -> dict:
+        """
+        Returns the structure of the database (tables, columns, types)
+        Format:
+        {
+            "table_name": {
+                "columns": [
+                    {"name": "col1", "type": "VARCHAR", "nullable": True, "pk": True},
+                    ...
+                ]
+            }
+        }
+        """
+        pass
+
+    # --- Execution Methods ---
+    @abc.abstractmethod
+    def execute_query(self, query: str, commit: bool = False) -> Union[List[Dict[str, Any]], Dict[str, int]]:
+        """
+        Executes a query and returns:
+         - A list of dicts for SELECT (rows).
+         - A dict {'rowcount': N} for INSERT/UPDATE/DELETE.
+        """
+        pass
+
+    @abc.abstractmethod
+    def commit(self) -> None:
+        pass
+
+    @abc.abstractmethod
+    def rollback(self) -> None:
+        pass

iatoolkit/common/model_registry.py

@@ -0,0 +1,159 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from injector import inject, singleton
+from typing import Literal
+
+
+HistoryType = Literal["server_side", "client_side"]
+ProviderType = Literal["openai", "gemini", "deepseek", "xai", "anthropic", "unknown"]
+
+
+@dataclass(frozen=True)
+class ModelMetadata:
+    """Static metadata for a logical family of models."""
+    provider: ProviderType
+    history_type: HistoryType
+
+
+@singleton
+class ModelRegistry:
+    """
+    Central registry for model metadata.
+
+    Responsibilities:
+    - Map a model name to its provider (openai, gemini, deepseek, etc.).
+    - Decide which history strategy to use for a model (server_side / client_side).
+    - Provide convenience helpers (is_openai, is_gemini, is_deepseek, etc.).
+    """
+
+    @inject
+    def __init__(self):
+        # Hardcoded rules for now; can be extended or loaded from config later.
+        # The order of patterns matters: first match wins.
+        self._provider_patterns: dict[ProviderType, tuple[str, ...]] = {
+            "openai": ("gpt", "gpt-5", "gpt-5-mini", "gpt-5.1"),
+            "gemini": ("gemini", "gemini-3"),
+            "deepseek": ("deepseek",),
+            "xai": ("grok", "grok-1", "grok-beta"),
+            "anthropic": ("claude", "claude-3", "claude-2"),
+        }
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def get_provider(self, model: str) -> ProviderType:
+        """
+        Returns the logical provider for a given model name.
+
+        Examples:
+            "gpt-4o"        -> "openai"
+            "gemini-pro"    -> "gemini"
+            "deepseek-chat" -> "deepseek"
+        """
+        if not model:
+            return "unknown"
+
+        model_lower = model.lower()
+        for provider, patterns in self._provider_patterns.items():
+            if any(pat in model_lower for pat in patterns):
+                return provider
+
+        return "unknown"
+
+    def get_request_defaults(self, model: str) -> dict:
+        """
+        Return per-model request defaults to keep model-specific policy centralized.
+
+        Notes:
+        - This should only include keys that are supported by the target provider.
+        - Callers should merge these defaults with user-provided params (do not mutate inputs).
+        """
+        model_lower = (model or "").lower()
+        provider = self.get_provider(model_lower)
+
+        # Conservative defaults: do not send provider-specific knobs unless we know they are supported.
+        defaults = {"text": {}, "reasoning": {}}
+
+        # OpenAI/xAI (OpenAI-compatible) support 'text.verbosity' and 'reasoning.effort' in our current integration.
+        if provider in ("openai", "xai"):
+            defaults["text"] = {"verbosity": "low"}
+
+            # Fine-grained per-model tuning.
+            if model_lower in ("gpt-5", "gpt-5-mini"):
+                defaults["reasoning"] = {"effort": "minimal"}
+            elif model_lower == "gpt-5.1":
+                defaults["reasoning"] = {"effort": "low", "summary": "auto"}
+
+        # Gemini/DeepSeek/unknown: keep defaults empty to avoid sending unsupported parameters.
+        return defaults
+
+    def resolve_request_params(self, model: str, text: dict | None = None, reasoning: dict | None = None) -> dict:
+        """
+        Resolve provider/model defaults and merge them with caller-provided overrides.
+
+        Rules:
+        - Defaults come from get_request_defaults(model).
+        - Caller overrides win over defaults.
+        - Input dictionaries are never mutated.
+        """
+        defaults = self.get_request_defaults(model)
+
+        merged_text: dict = {}
+        merged_text.update(defaults.get("text") or {})
+        merged_text.update(text or {})
+
+        merged_reasoning: dict = {}
+        merged_reasoning.update(defaults.get("reasoning") or {})
+        merged_reasoning.update(reasoning or {})
+
+        return {
+            "text": merged_text,
+            "reasoning": merged_reasoning,
+        }
+
+    def get_history_type(self, model: str) -> HistoryType:
+        """
+        Returns the history strategy for a given model.
+
+        Current rules:
+        - openai/xai/anthropic: server_side (API manages conversation state via ids)
+        - gemini/deepseek/unknown: client_side (we manage full message history)
+        """
+        provider = self.get_provider(model)
+
+        if provider in ("openai", "xai", "anthropic"):
+            return "server_side"
+
+        # Default for gemini, deepseek and any unknown provider
+        return "client_side"
+
+    # ------------------------------------------------------------------
+    # Convenience helpers (used during migration)
+    # ------------------------------------------------------------------
+
+    def is_openai_model(self, model: str) -> bool:
+        return self.get_provider(model) == "openai"
+
+    def is_gemini_model(self, model: str) -> bool:
+        return self.get_provider(model) == "gemini"
+
+    def is_deepseek_model(self, model: str) -> bool:
+        return self.get_provider(model) == "deepseek"
+
+    def is_xai_model(self, model: str) -> bool:
+        return self.get_provider(model) == "xai"
+
+    def is_anthropic_model(self, model: str) -> bool:
+        return self.get_provider(model) == "anthropic"

iatoolkit/common/routes.py

@@ -12,8 +12,6 @@ def register_views(app):
 
     from iatoolkit.views.init_context_api_view import InitContextApiView
     from iatoolkit.views.llmquery_api_view import LLMQueryApiView
-    from iatoolkit.views.tasks_api_view import TaskApiView
-    from iatoolkit.views.tasks_review_api_view import TaskReviewApiView
     from iatoolkit.views.signup_view import SignupView
     from iatoolkit.views.verify_user_view import VerifyAccountView
     from iatoolkit.views.forgot_password_view import ForgotPasswordView
@@ -26,10 +24,14 @@ def register_views(app):
     from iatoolkit.views.profile_api_view import UserLanguageApiView
     from iatoolkit.views.embedding_api_view import EmbeddingApiView
     from iatoolkit.views.login_view import LoginView, FinalizeContextView
+    from iatoolkit.views.configuration_api_view import ConfigurationApiView, ValidateConfigurationApiView
     from iatoolkit.views.logout_api_view import LogoutApiView
     from iatoolkit.views.home_view import HomeView
+    from iatoolkit.views.chat_view import ChatView
     from iatoolkit.views.static_page_view import StaticPageView
     from iatoolkit.views.root_redirect_view import RootRedirectView
+    from iatoolkit.views.users_api_view import UsersApiView
+    from iatoolkit.views.rag_api_view import RagApiView
 
     # assign root '/' to our new redirect logic
     app.add_url_rule('/home', view_func=RootRedirectView.as_view('root_redirect'))
@@ -40,6 +42,10 @@ def register_views(app):
     # login for the iatoolkit integrated frontend
     app.add_url_rule('/<company_short_name>/login', view_func=LoginView.as_view('login'))
 
+    # Chat Route (Direct Access)
+    app.add_url_rule('/<company_short_name>/chat',
+                     view_func=ChatView.as_view('chat'))
+
     # this endpoint is called when onboarding_shell finish the context load
     app.add_url_rule(
         '/<company_short_name>/finalize',
@@ -70,6 +76,10 @@ def register_views(app):
     app.add_url_rule('/<company_short_name>/verify/<token>', view_func=VerifyAccountView.as_view('verify_account'))
     app.add_url_rule('/<company_short_name>/forgot-password', view_func=ForgotPasswordView.as_view('forgot_password'))
     app.add_url_rule('/<company_short_name>/change-password/<token>', view_func=ChangePasswordView.as_view('change_password'))
+    app.add_url_rule(
+        '/<string:company_short_name>/api/company-users',
+        view_func=UsersApiView.as_view('company-users')
+    )
 
     # main chat query, used by the JS in the browser (with credentials)
     # can be used also for executing iatoolkit prompts
@@ -83,9 +93,32 @@ def register_views(app):
     app.add_url_rule('/<company_short_name>/api/history', view_func=HistoryApiView.as_view('history'))
     app.add_url_rule('/<company_short_name>/api/help-content', view_func=HelpContentApiView.as_view('help-content'))
 
-    # tasks management endpoints: create task, and review answer
-    app.add_url_rule('/tasks', view_func=TaskApiView.as_view('tasks'))
-    app.add_url_rule('/tasks/review/<int:task_id>', view_func=TaskReviewApiView.as_view('tasks-review'))
+    # --- RAG API Routes ---
+    rag_view = RagApiView.as_view('rag_api')
+
+    # 1. List Files (POST for filters)
+    app.add_url_rule('/api/rag/<company_short_name>/files',
+                     view_func=rag_view,
+                     methods=['POST'],
+                     defaults={'action': 'list_files'})
+
+    # 2. Delete File
+    app.add_url_rule('/api/rag/<company_short_name>/files/<int:document_id>',
+                     view_func=rag_view,
+                     methods=['DELETE'],
+                     defaults={'action': 'delete_file'})
+
+    # 3. Search Lab
+    app.add_url_rule('/api/rag/<company_short_name>/search',
+                     view_func=rag_view,
+                     methods=['POST'],
+                     defaults={'action': 'search'})
+
+    # 4. Get File Content (View/Download)
+    app.add_url_rule('/api/rag/<company_short_name>/files/<int:document_id>/content',
+                     view_func=rag_view,
+                     methods=['GET'],
+                     defaults={'action': 'get_file_content'})
 
     # this endpoint is for upload documents into the vector store (api-key)
     app.add_url_rule('/api/load-document', view_func=LoadDocumentApiView.as_view('load-document'), methods=['POST'])
@@ -94,6 +127,15 @@ def register_views(app):
     app.add_url_rule('/<company_short_name>/api/embedding',
                      view_func=EmbeddingApiView.as_view('embedding_api'))
 
+    # company configuration
+    app.add_url_rule('/<company_short_name>/api/configuration',
+                     view_func=ConfigurationApiView.as_view('configuration'),
+                     methods=['GET', 'POST', 'PATCH'],)
+
+    app.add_url_rule('/<company_short_name>/api/configuration/validate',
+                     view_func=ValidateConfigurationApiView.as_view('configuration-validate'),
+                     methods=['GET'])
+
     # static pages
     # url: /pages/foundation o /pages/implementation_plan
     static_view = StaticPageView.as_view('static_pages')

iatoolkit/common/util.py

@@ -157,6 +157,31 @@ class Utility:
             schema = yaml.safe_load(f)
         return schema
 
+    def load_yaml_from_string(self, yaml_content: str) -> dict:
+        """
+        Parses a YAML string into a dictionary securely.
+        """
+        try:
+            yaml_content = yaml_content.replace('\t', '  ')
+            return yaml.safe_load(yaml_content) or {}
+        except yaml.YAMLError as e:
+            logging.error(f"Error parsing YAML string: {e}")
+            return {}
+
+    def dump_yaml_to_string(self, config: dict) -> str:
+        """
+        Dumps a dictionary into a YAML formatted string.
+        It uses default flow style False to ensure block format (readable YAML).
+        """
+        try:
+            # default_flow_style=False ensures lists and dicts are expanded (not inline like JSON)
+            # allow_unicode=True ensures characters like accents are preserved
+            return yaml.safe_dump(config, default_flow_style=False, allow_unicode=True, sort_keys=False)
+        except yaml.YAMLError as e:
+            logging.error(f"Error dumping YAML to string: {e}")
+            raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                                     f"Failed to generate YAML: {e}")
+
     def generate_context_for_schema(self, entity_name: str, schema_file: str = None, schema: dict = {}) -> str:
         if not schema_file and not schema:
             raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
@@ -186,9 +211,13 @@ class Utility:
             root_name = list(schema.keys())[0]
             root_details = schema[root_name]
 
+            # support this format
+            if root_details.get('columns'):
+                root_details = root_details['columns']
+
             if isinstance(root_details, dict):
                 # Las claves de metadatos describen el objeto en sí, no sus propiedades hijas.
-                METADATA_KEYS = ['description', 'type', 'format', 'items', 'properties']
+                METADATA_KEYS = ['description', 'type', 'format', 'items', 'properties', 'pk']
 
                 # Las propiedades son las claves restantes en el diccionario.
                 properties = {
@@ -231,6 +260,8 @@ class Utility:
             description = details.get('description', '')
             data_type = details.get('type', 'any')
             output.append(f"{indent_str}- **`{name.lower()}`** ({data_type}): {description}")
+            # if 'pk' in details and details['pk']:
+            #    output.append(f"{indent_str}- **Primary Key**: {details['pk']}")
 
             child_indent_str = '  ' * (indent_level + 1)
 
@@ -340,15 +371,3 @@ class Utility:
             logging.exception(e)
             raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
                                f'Error al buscar archivos en el directorio {directory}: {str(e)}') from e
-
-    def is_openai_model(self, model: str) -> bool:
-        openai_models = [
-            'gpt-5', 'gpt'
-        ]
-        return any(openai_model in model.lower() for openai_model in openai_models)
-
-    def is_gemini_model(self, model: str) -> bool:
-        gemini_models = [
-            'gemini', 'gemini-2.5-pro', 'gemini-3'
-        ]
-        return any(gemini_model in model.lower() for gemini_model in gemini_models)

iatoolkit/company_registry.py

@@ -6,6 +6,7 @@
 from typing import Dict, Type, Any, Optional
 from .base_company import BaseCompany
 import logging
+from injector import inject
 
 
 class CompanyRegistry:
@@ -14,6 +15,7 @@ class CompanyRegistry:
     Allow the client to register companies and instantiate them with dependency injection.
     """
 
+    @inject
     def __init__(self):
         self._company_classes: Dict[str, Type[BaseCompany]] = {}
         self._company_instances: Dict[str, BaseCompany] = {}
@@ -85,6 +87,9 @@ def get_company_registry() -> CompanyRegistry:
     """Get the global company registry instance."""
     return _company_registry
 
+def get_registered_companies() -> Dict[str, Type[BaseCompany]]:
+    return _company_registry.get_registered_companies()
+
 
 def set_company_registry(registry: CompanyRegistry) -> None:
     """