iatoolkit 0.71.4__py3-none-any.whl → 1.4.2__py3-none-any.whl

iatoolkit/__init__.py

@@ -1,34 +1,46 @@
-"""
-IAToolkit Package
-"""
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+__version__ = "1.4.2"
 
 # Expose main classes and functions at the top level of the package
 
 # main IAToolkit class
-from .iatoolkit import IAToolkit, create_app, current_iatoolkit
+from iatoolkit.core import IAToolkit, create_app, current_iatoolkit
 
 # for registering the client companies
-from .company_registry import register_company
+from .company_registry import register_company, set_company_registry
 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',
     'create_app',
     'current_iatoolkit',
     'register_company',
+    'set_company_registry',
     'BaseCompany',
     'QueryService',
     'SqlService',
     'DocumentService',
-    'SearchService',
+    'KnowledgeBaseService',
     'LoadDocumentsService',
     'CallServiceClient',
+    'ProfileService',
+    'MailService',
+    'OrmModel',
+    'BaseCompany',
 ]

iatoolkit/base_company.py

@@ -5,87 +5,17 @@
 
 # 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.services.prompt_manager_service import PromptService
-from iatoolkit.repositories.models import Company, Function, PromptCategory
-from .iatoolkit 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.prompt_service: PromptService = injector.get(PromptService)
-        self.company: Company | None = None
-        self.company_short_name: str
-
-    def _create_company(self,
-                        short_name: str,
-                        name: str,
-                        parameters: dict | None = None,
-                        ) -> Company:
-        company_obj = Company(short_name=short_name,
-                              name=name,
-                              parameters=parameters)
-        self.company = self.profile_repo.create_company(company_obj)
-        return self.company
-
-    def _create_function(self, function_name: str, description: str, params: dict, **kwargs):
-        if not self.company:
-            raise ValueError("La compañía debe estar definida antes de crear una función.")
-
-        self.llm_query_repo.create_or_update_function(
-            Function(
-                company_id=self.company.id,
-                name=function_name,
-                description=description,
-                parameters=params,
-                system_function=False,
-                **kwargs
-            )
-        )
-
-    def _create_prompt_category(self, name: str, order: int) -> PromptCategory:
-        if not self.company:
-            raise ValueError("La compañía debe estar definida antes de crear una categoría.")
-
-        return self.llm_query_repo.create_or_update_prompt_category(
-            PromptCategory(name=name, order=order, company_id=self.company.id)
-        )
-
-    def _create_prompt(self, prompt_name: str, description: str, category: PromptCategory, order: int, **kwargs):
-        if not self.company:
-            raise ValueError("La compañía debe estar definida antes de crear un prompt.")
-
-        self.prompt_service.create_prompt(
-            prompt_name=prompt_name,
-            description=description,
-            order=order,
-            company=self.company,
-            category=category,
-            **kwargs
-        )
-
-    @abstractmethod
-    # get context specific for this company
-    def get_user_info(self, user_identifier: str) -> dict:
-        raise NotImplementedError("La subclase debe implementar el método get_user_info()")
 
     @abstractmethod
     # execute the specific action configured in the intent table
     def handle_request(self, tag: str, params: dict) -> dict:
         raise NotImplementedError("La subclase debe implementar el método handle_request()")
 
-
+    @abstractmethod
     def register_cli_commands(self, app):
-        """
-        optional method for a company definition of it's cli commands
-        """
         pass
 
-
     def unsupported_operation(self, tag):
         raise NotImplementedError(f"La operación '{tag}' no está soportada por esta empresa.")

iatoolkit/cli_commands.py

@@ -5,38 +5,38 @@
 
 import click
 import logging
-from .iatoolkit import IAToolkit
+from iatoolkit.core import IAToolkit
 from iatoolkit.services.profile_service import ProfileService
 
+
 def register_core_commands(app):
     """Registra los comandos CLI del núcleo de IAToolkit."""
 
     @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"🔑 Generando API key para '{company_short_name}'...")
-            result = profile_service.new_api_key(company_short_name)
+            click.echo(f"🔑 Generating API-KEY for company: '{company_short_name}'...")
+            result = profile_service.new_api_key(company_short_name, key_name)
 
             if 'error' in result:
                 click.echo(f"❌ Error: {result['error']}")
-                click.echo("👉 Asegúrate de que el nombre de la compañía es correcto y está registrada.")
+                click.echo("👉 Make sure the company is registered and valid.")
             else:
-                click.echo("✅ ¡Configuración lista! Agrega esta variable a tu entorno:")
+                click.echo("✅ ¡Api-key is ready! add this variable to your environment:")
                 click.echo(f"IATOOLKIT_API_KEY='{result['api-key']}'")
         except Exception as e:
             logging.exception(e)
-            click.echo(f"❌ Ocurrió un error inesperado durante la configuración: {e}")
+            click.echo(f"❌ unexpectd error during the configuration: {e}")
 
     @app.cli.command("encrypt-key")
     @click.argument("key")
     def encrypt_llm_api_key(key: str):
         from iatoolkit.common.util import Utility
 
-
-
         util = IAToolkit.get_instance().get_injector().get(Utility)
         try:
             encrypt_key = util.encrypt_key(key)
@@ -45,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

@@ -37,6 +37,8 @@ class IAToolkitException(Exception):
         LOAD_DOCUMENT_ERROR = 25
         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,38 @@
+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_all_table_names(self) -> List[str]:
+        pass
+
+    @abc.abstractmethod
+    def get_table_description(self,
+                              table_name: str,
+                              schema_object_name: str | None = None,
+                              exclude_columns: List[str] | None = None) -> str:
+        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

@@ -8,32 +8,33 @@ from flask import jsonify
 
 
 # this function register all the views
-def register_views(injector, app):
+def register_views(app):
 
-    from iatoolkit.views.index_view import IndexView
     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.login_simulation_view import LoginSimulationView
     from iatoolkit.views.signup_view import SignupView
     from iatoolkit.views.verify_user_view import VerifyAccountView
     from iatoolkit.views.forgot_password_view import ForgotPasswordView
     from iatoolkit.views.change_password_view import ChangePasswordView
-    from iatoolkit.views.file_store_api_view import FileStoreApiView
+    from iatoolkit.views.load_document_api_view import LoadDocumentApiView
     from iatoolkit.views.user_feedback_api_view import UserFeedbackApiView
     from iatoolkit.views.prompt_api_view import PromptApiView
     from iatoolkit.views.history_api_view import HistoryApiView
     from iatoolkit.views.help_content_api_view import HelpContentApiView
-    from iatoolkit.views.profile_api_view import UserLanguageApiView  # <-- Importa la nueva vista
+    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.external_login_view import ExternalLoginView, RedeemTokenApiView
+    from iatoolkit.views.load_company_configuration_api_view import LoadCompanyConfigurationApiView
     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
 
-    # iatoolkit home page
-    app.add_url_rule('/', view_func=IndexView.as_view('index'))
+    # assign root '/' to our new redirect logic
+    app.add_url_rule('/home', view_func=RootRedirectView.as_view('root_redirect'))
 
     # company home view
     app.add_url_rule('/<company_short_name>/home', view_func=HomeView.as_view('home'))
@@ -41,9 +42,9 @@ def register_views(injector, app):
     # login for the iatoolkit integrated frontend
     app.add_url_rule('/<company_short_name>/login', view_func=LoginView.as_view('login'))
 
-    # this is the login for external users
-    app.add_url_rule('/<company_short_name>/external_login',
-                     view_func=ExternalLoginView.as_view('external_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(
@@ -65,10 +66,6 @@ def register_views(injector, app):
     app.add_url_rule('/<company_short_name>/api/logout',
                      view_func=LogoutApiView.as_view('logout'))
 
-    # this endpoint is called by the JS for changing the token for a session
-    app.add_url_rule('/<string:company_short_name>/api/redeem_token',
-                     view_func = RedeemTokenApiView.as_view('redeem_token'))
-
     # init (reset) the company context
     app.add_url_rule('/<company_short_name>/api/init-context',
                      view_func=InitContextApiView.as_view('init-context'),
@@ -79,6 +76,10 @@ def register_views(injector, 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
@@ -92,17 +93,48 @@ def register_views(injector, 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', view_func=FileStoreApiView.as_view('load_api'))
+    app.add_url_rule('/api/load-document', view_func=LoadDocumentApiView.as_view('load-document'), methods=['POST'])
 
     # this endpoint is for generating embeddings for a given text
     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/load_configuration',
+                     view_func=LoadCompanyConfigurationApiView.as_view('load-configuration'))
+
+    # static pages
+    # url: /pages/foundation o /pages/implementation_plan
+    static_view = StaticPageView.as_view('static_pages')
+    app.add_url_rule('/pages/<page_name>', view_func=static_view, methods=['GET'])
 
     @app.route('/download/<path:filename>')
     def download_file(filename):
@@ -125,21 +157,10 @@ def register_views(injector, app):
         except FileNotFoundError:
             abort(404)
 
-    # login testing
-    app.add_url_rule('/<company_short_name>/login_test',
-                     view_func=LoginSimulationView.as_view('login_test'))
-
-    app.add_url_rule(
-        '/about',  # URL de la ruta
-        view_func=lambda: render_template('about.html'))
 
     app.add_url_rule('/version', 'version',
                      lambda: jsonify({"iatoolkit_version": current_app.config.get('VERSION', 'N/A')}))
 
 
-    # hacer que la raíz '/' vaya al home de iatoolkit
-    @app.route('/')
-    def root_redirect():
-        return redirect(url_for('index'))
 
 

iatoolkit/common/util.py

@@ -6,6 +6,7 @@
 import logging
 from typing import List
 from iatoolkit.common.exceptions import IAToolkitException
+from flask import request
 from injector import inject
 import os
 from jinja2 import Environment, FileSystemLoader
@@ -16,6 +17,7 @@ from cryptography.fernet import Fernet
 import base64
 
 
+
 class Utility:
     @inject
     def __init__(self):
@@ -97,6 +99,10 @@ class Utility:
             logging.exception(e)
             return None
 
+    def get_template_by_language(self, template_name: str, default_langueage: str = 'en') -> str:
+        # english is default
+        lang = request.args.get("lang", default_langueage)
+        return f'{template_name}_{lang}.html'
 
     def serialize(self, obj):
         if isinstance(obj, datetime) or isinstance(obj, date):
@@ -151,6 +157,17 @@ 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 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,
@@ -334,15 +351,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'
-        ]
-        return any(gemini_model in model.lower() for gemini_model in gemini_models)