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

iatoolkit/{infra/llm_client.py → services/llm_client_service.py}

@@ -8,6 +8,7 @@ from iatoolkit.repositories.models import Company, LLMQuery
 from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
 from sqlalchemy.exc import SQLAlchemyError, OperationalError
 from iatoolkit.common.util import Utility
+from iatoolkit.common.model_registry import ModelRegistry
 from injector import inject
 import time
 import markdown2
@@ -30,11 +31,13 @@ class llmClient:
     @inject
     def __init__(self,
                  llmquery_repo: LLMQueryRepo,
-                 llm_proxy_factory: LLMProxy,
+                 llm_proxy: LLMProxy,
+                 model_registry: ModelRegistry,
                  util: Utility
                  ):
         self.llmquery_repo = llmquery_repo
-        self.llm_proxy_factory = llm_proxy_factory
+        self.llm_proxy = llm_proxy
+        self.model_registry = model_registry
         self.util = util
         self._dispatcher = None # Cache for the lazy-loaded dispatcher
 
@@ -73,21 +76,15 @@ class llmClient:
         response = None
         sql_retry_count = 0
         force_tool_name = None
-        reasoning = {}
 
-        if model in ('gpt-5', 'gpt-5-mini'):
-            text['verbosity'] = "low"
-            reasoning = {"effort": 'minimal'}
-        elif model == 'gpt-5.1':
-            text['verbosity'] = "low"
-            reasoning = {"effort": 'low'}
+        # Resolve per-model defaults and apply overrides (without mutating inputs).
+        request_params = self.model_registry.resolve_request_params(model=model, text=text)
+        text_payload = request_params["text"]
+        reasoning = request_params["reasoning"]
 
         try:
             start_time = time.time()
-            logging.info(f"calling llm model '{model}' with {self.count_tokens(context)} tokens...")
-
-            # get the proxy for the company
-            llm_proxy = self.llm_proxy_factory.create_for_company(company)
+            logging.info(f"calling llm model '{model}' with {self.count_tokens(context, context_history)} tokens...")
 
             # this is the first call to the LLM on the iteration
             try:
@@ -96,13 +93,14 @@ class llmClient:
                     "content": context
                 }]
 
-                response = llm_proxy.create_response(
+                response = self.llm_proxy.create_response(
+                    company_short_name=company.short_name,
                     model=model,
+                    input=input_messages,
                     previous_response_id=previous_response_id,
                     context_history=context_history,
-                    input=input_messages,
                     tools=tools,
-                    text=text,
+                    text=text_payload,
                     reasoning=reasoning,
                 )
                 stats = self.get_stats(response)
@@ -130,8 +128,14 @@ class llmClient:
                     # execute the function call through the dispatcher
                     fcall_time = time.time()
                     function_name = tool_call.name
-                    args = json.loads(tool_call.arguments)
-                    logging.info(f"start execution fcall: {function_name}")
+
+                    try:
+                        args = json.loads(tool_call.arguments)
+                    except Exception as e:
+                        logging.error(f"[Dispatcher] json.loads failed: {e}")
+                        raise
+                    logging.debug(f"[Dispatcher] Parsed args = {args}")
+
                     try:
                         result = self.dispatcher.dispatch(
                             company_short_name=company.short_name,
@@ -163,6 +167,7 @@ class llmClient:
                     input_messages.append({
                         "type": "function_call_output",
                         "call_id": tool_call.call_id,
+                        "status": "completed",
                         "output": str(result)
                     })
                     function_calls = True
@@ -173,7 +178,7 @@ class llmClient:
                     f_calls.append(f_call_identity)
                     f_call_time += elapsed
 
-                    logging.info(f"[{company.short_name}] Tool end execution: {function_name} in {elapsed:.1f} secs.")
+                    logging.info(f"[{company.short_name}] end execution of tool: {function_name} in {elapsed:.1f} secs.")
 
                 if not function_calls:
                     break           # no more function calls, the answer to send back to llm
@@ -183,7 +188,8 @@ class llmClient:
                 if force_tool_name:
                     tool_choice_value = "required"
 
-                response = llm_proxy.create_response(
+                response = self.llm_proxy.create_response(
+                    company_short_name=company.short_name,
                     model=model,
                     input=input_messages,
                     previous_response_id=response.id,
@@ -191,7 +197,7 @@ class llmClient:
                     reasoning=reasoning,
                     tool_choice=tool_choice_value,
                     tools=tools,
-                    text=text
+                    text=text_payload,
                 )
                 stats_fcall = self.add_stats(stats_fcall, self.get_stats(response))
 
@@ -203,9 +209,11 @@ class llmClient:
             # decode the LLM response
             decoded_response = self.decode_response(response)
 
+            # Extract reasoning from the final response object
+            final_reasoning = getattr(response, 'reasoning_content', '')
+
             # save the query and response
             query = LLMQuery(user_identifier=user_identifier,
-                             task_id=0,
                              company_id=company.id,
                              query=question,
                              output=decoded_response.get('answer', ''),
@@ -230,6 +238,7 @@ class llmClient:
                 'response_id': response.id,
                 'query_id': query.id,
                 'model': model,
+                'reasoning_content': final_reasoning,
             }
         except SQLAlchemyError as db_error:
             # rollback
@@ -244,11 +253,10 @@ class llmClient:
 
             # log the error in the llm_query table
             query = LLMQuery(user_identifier=user_identifier,
-                             task_id=0,
                              company_id=company.id,
                              query=question,
                              output=error_message,
-                             response=response.output_text if response else {},
+                             response={},
                              valid_response=False,
                              function_calls=f_calls,
                              )
@@ -269,14 +277,15 @@ class llmClient:
 
         logging.info(f"initializing model '{model}' with company context: {self.count_tokens(company_base_context)} tokens...")
 
-        llm_proxy = self.llm_proxy_factory.create_for_company(company)
         try:
-            response = llm_proxy.create_response(
+            response = self.llm_proxy.create_response(
+                company_short_name=company.short_name,
                 model=model,
                 input=[{
                     "role": "system",
                     "content": company_base_context
-                }]
+                }],
+
             )
 
         except Exception as e:
@@ -423,7 +432,7 @@ class llmClient:
         html_answer = markdown2.markdown(answer).replace("\n", "")
         return html_answer
 
-    def count_tokens(self, text):
+    def count_tokens(self, text, history = []):
         # Codifica el texto y cuenta la cantidad de tokens
-        tokens = self.encoding.encode(text)
+        tokens = self.encoding.encode(text + json.dumps(history))
         return len(tokens)

iatoolkit/services/load_documents_service.py

@@ -1,17 +1,13 @@
 # Copyright (c) 2024 Fernando Libedinsky
 # Product: IAToolkit
 
-from iatoolkit.repositories.vs_repo import VSRepo
-from iatoolkit.repositories.document_repo import DocumentRepo
-from iatoolkit.repositories.models import Document, VSDoc, Company
-from iatoolkit.services.document_service import DocumentService
+from iatoolkit.repositories.models import Company
 from iatoolkit.services.configuration_service import ConfigurationService
-from langchain.text_splitter import RecursiveCharacterTextSplitter
+from iatoolkit.services.knowledge_base_service import KnowledgeBaseService
 from iatoolkit.infra.connectors.file_connector_factory import FileConnectorFactory
 from iatoolkit.services.file_processor_service import FileProcessorConfig, FileProcessor
 from iatoolkit.common.exceptions import IAToolkitException
 import logging
-import base64
 from injector import inject, singleton
 import os
 
@@ -19,31 +15,21 @@ import os
 @singleton
 class LoadDocumentsService:
     """
-    Orchestrates the process of loading, processing, and storing documents
-    from various sources defined in the company's configuration.
+    Orchestrates the discovery and loading of documents from configured sources.
+    Delegates the processing and ingestion logic to KnowledgeBaseService.
     """
     @inject
     def __init__(self,
                  config_service: ConfigurationService,
                  file_connector_factory: FileConnectorFactory,
-                 doc_service: DocumentService,
-                 doc_repo: DocumentRepo,
-                 vector_store: VSRepo,
+                 knowledge_base_service: KnowledgeBaseService
                  ):
         self.config_service = config_service
-        self.doc_service = doc_service
-        self.doc_repo = doc_repo
-        self.vector_store = vector_store
         self.file_connector_factory = file_connector_factory
+        self.knowledge_base_service = knowledge_base_service
 
         logging.getLogger().setLevel(logging.ERROR)
 
-        self.splitter = RecursiveCharacterTextSplitter(
-            chunk_size=1000,
-            chunk_overlap=100,
-            separators=["\n\n", "\n", "."]
-        )
-
     def load_sources(self,
                      company: Company,
                      sources_to_load: list[str] = None,
@@ -67,7 +53,7 @@ class LoadDocumentsService:
 
         if not sources_to_load:
             raise IAToolkitException(IAToolkitException.ErrorType.PARAM_NOT_FILLED,
-                                f"Missing sources to load for company '{company.short_name}'.")
+                                     f"Missing sources to load for company '{company.short_name}'.")
 
         base_connector_config = self._get_base_connector_config(knowledge_base_config)
         all_sources = knowledge_base_config.get('document_sources', {})
@@ -79,16 +65,24 @@ class LoadDocumentsService:
                 logging.warning(f"Source '{source_name}' not found in configuration for company '{company.short_name}'. Skipping.")
                 continue
 
+            collection = source_config.get('collection')
+            if not collection:
+                logging.warning(
+                    f"Document Source '{source_name}' missing collection definition en company.yaml, Skipping.")
+                continue
+
             try:
-                logging.info(f"Processing source '{source_name}' for company '{company.short_name}'...")
+                logging.info(f"company {company.short_name}: loading source '{source_name}' into collection '{collection}'...")
 
                 # Combine the base connector configuration with the specific path from the source.
                 full_connector_config = base_connector_config.copy()
                 full_connector_config['path'] = source_config.get('path')
+                full_connector_config['folder'] = source_config.get('folder')
 
                 # Prepare the context for the callback function.
                 context = {
                     'company': company,
+                    'collection': collection,
                     'metadata': source_config.get('metadata', {})
                 }
 
@@ -130,45 +124,29 @@ class LoadDocumentsService:
 
     def _file_processing_callback(self, company: Company, filename: str, content: bytes, context: dict = None):
         """
-        Callback method to process a single file. It extracts text, merges metadata,
-        and saves the document to both relational and vector stores.
+        Callback method to process a single file.
+        Delegates the actual ingestion (storage, vectorization) to KnowledgeBaseService.
         """
         if not company:
             raise IAToolkitException(IAToolkitException.ErrorType.MISSING_PARAMETER, "Missing company object in callback.")
 
-        if self.doc_repo.get(company_id=company.id, filename=filename):
-            logging.debug(f"File '{filename}' already exists for company '{company.id}'. Skipping.")
-            return
-
         try:
-            document_content = self.doc_service.file_to_txt(filename, content)
-
             # Get predefined metadata from the context passed by the processor.
             predefined_metadata = context.get('metadata', {}) if context else {}
 
-            # Save the document to the relational database.
-            session = self.doc_repo.session
-            new_document = Document(
-                company_id=company.id,
+            # Delegate heavy lifting to KnowledgeBaseService
+            new_document = self.knowledge_base_service.ingest_document_sync(
+                company=company,
                 filename=filename,
-                content=document_content,
-                content_b64=base64.b64encode(content).decode('utf-8'),
-                meta=predefined_metadata
+                content=content,
+                collection=context.get('collection'),
+                metadata=predefined_metadata
             )
-            session.add(new_document)
-            session.flush()  # Flush to get the new_document.id without committing.
-
-            # Split into chunks and prepare for vector store.
-            chunks = self.splitter.split_text(document_content)
-            vs_docs = [VSDoc(company_id=company.id, document_id=new_document.id, text=text) for text in chunks]
 
-            # Add document chunks to the vector store.
-            self.vector_store.add_document(company.short_name, vs_docs)
-
-            session.commit()
             return new_document
+
         except Exception as e:
-            self.doc_repo.session.rollback()
+            # We log here but re-raise to let FileProcessor handle the error counting/continue logic
             logging.exception(f"Error processing file '{filename}': {e}")
             raise IAToolkitException(IAToolkitException.ErrorType.LOAD_DOCUMENT_ERROR,
                                      f"Error while processing file: {filename}")

iatoolkit/services/profile_service.py

@@ -9,6 +9,7 @@ from iatoolkit.services.i18n_service import I18nService
 from iatoolkit.repositories.models import User, Company, ApiKey
 from flask_bcrypt import check_password_hash
 from iatoolkit.common.session_manager import SessionManager
+from iatoolkit.services.dispatcher_service import Dispatcher
 from iatoolkit.services.language_service import LanguageService
 from iatoolkit.services.user_session_context_service import UserSessionContextService
 from iatoolkit.services.configuration_service import ConfigurationService
@@ -19,7 +20,7 @@ import re
 import secrets
 import string
 import logging
-from iatoolkit.services.dispatcher_service import Dispatcher
+from typing import List, Dict
 
 
 class ProfileService:
@@ -41,7 +42,6 @@ class ProfileService:
         self.mail_service = mail_service
         self.bcrypt = Bcrypt()
 
-
     def login(self, company_short_name: str, email: str, password: str) -> dict:
         try:
             # check if user exists
@@ -65,6 +65,8 @@ class ProfileService:
                 return {'success': False,
                         "message": self.i18n_service.t('errors.services.account_not_verified')}
 
+            user_role = self.profile_repo.get_user_role_in_company(company.id, user.id)
+
             # 1. Build the local user profile dictionary here.
             # the user_profile variables are used on the LLM templates also (see in query_main.prompt)
             user_identifier = user.email
@@ -73,6 +75,7 @@ class ProfileService:
                 "user_fullname": f'{user.first_name} {user.last_name}',
                 "user_is_local": True,
                 "user_id": user.id,
+                "user_role": user_role,
                 "extras": {}
             }
 
@@ -320,19 +323,44 @@ class ProfileService:
     def get_company_by_short_name(self, short_name: str) -> Company:
         return self.profile_repo.get_company_by_short_name(short_name)
 
+    def get_company_users(self, company_short_name: str) -> List[Dict]:
+        company = self.profile_repo.get_company_by_short_name(company_short_name)
+        if not company:
+            return []
+
+        # get the company users from the repo
+        company_users =  self.profile_repo.get_company_users_with_details(company_short_name)
+
+        users_data = []
+        for user, role, last_access in company_users:
+            users_data.append({
+                "first_name": user.first_name,
+                "last_name": user.last_name,
+                "email": user.email,
+                "created": user.created_at,
+                "verified": user.verified,
+                "role": role or "user",
+                "last_access": last_access
+            })
+
+        return users_data
+
     def get_active_api_key_entry(self, api_key_value: str) -> ApiKey | None:
         return self.profile_repo.get_active_api_key_entry(api_key_value)
 
-    def new_api_key(self, company_short_name: str):
+    def new_api_key(self, company_short_name: str, key_name: str):
         company = self.get_company_by_short_name(company_short_name)
         if not company:
             return {"error": self.i18n_service.t('errors.company_not_found', company_short_name=company_short_name)}
 
+        if not key_name:
+            return {"error": self.i18n_service.t('errors.auth.api_key_name_required')}
+
         length = 40     # lenght of the api key
         alphabet = string.ascii_letters + string.digits
         key = ''.join(secrets.choice(alphabet) for i in range(length))
 
-        api_key = ApiKey(key=key, company_id=company.id)
+        api_key = ApiKey(key=key, company_id=company.id, key_name=key_name)
         self.profile_repo.create_api_key(api_key)
         return {"api-key": key}
 

iatoolkit/services/prompt_service.py

@@ -4,15 +4,16 @@
 # IAToolkit is open source software.
 
 from injector import inject
+from iatoolkit.common.interfaces.asset_storage import AssetRepository, AssetType
 from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
 from iatoolkit.services.i18n_service import I18nService
 from iatoolkit.repositories.profile_repo import ProfileRepo
 from collections import defaultdict
 from iatoolkit.repositories.models import Prompt, PromptCategory, Company
-import os
 from iatoolkit.common.exceptions import IAToolkitException
 import importlib.resources
 import logging
+import os
 
 # iatoolkit system prompts definitions
 _SYSTEM_PROMPTS = [
@@ -24,27 +25,37 @@ _SYSTEM_PROMPTS = [
 class PromptService:
     @inject
     def __init__(self,
+                 asset_repo: AssetRepository,
                  llm_query_repo: LLMQueryRepo,
                  profile_repo: ProfileRepo,
                  i18n_service: I18nService):
+        self.asset_repo = asset_repo
         self.llm_query_repo = llm_query_repo
         self.profile_repo = profile_repo
         self.i18n_service = i18n_service
 
-    def sync_company_prompts(self, company_instance, prompts_config: list, categories_config: list):
+    def sync_company_prompts(self, company_short_name: str, prompts_config: list, categories_config: list):
         """
         Synchronizes prompt categories and prompts from YAML config to Database.
         Strategies:
         - Categories: Create or Update existing based on name.
         - Prompts: Create or Update existing based on name. Soft-delete or Delete unused.
         """
+        if not prompts_config:
+            return
+
+        company = self.profile_repo.get_company_by_short_name(company_short_name)
+        if not company:
+            raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME,
+                                     f'Company {company_short_name} not found')
+
         try:
             # 1. Sync Categories
             category_map = {}
 
             for i, category_name in enumerate(categories_config):
                 category_obj = PromptCategory(
-                    company_id=company_instance.company.id,
+                    company_id=company.id,
                     name=category_name,
                     order=i + 1
                 )
@@ -69,10 +80,10 @@ class PromptService:
                 filename = f"{prompt_name}.prompt"
 
                 new_prompt = Prompt(
-                    company_id=company_instance.company.id,
+                    company_id=company.id,
                     name=prompt_name,
-                    description=prompt_data['description'],
-                    order=prompt_data['order'],
+                    description=prompt_data.get('description'),
+                    order=prompt_data.get('order'),
                     category_id=category_obj.id,
                     active=prompt_data.get('active', True),
                     is_system_prompt=False,
@@ -83,7 +94,7 @@ class PromptService:
                 self.llm_query_repo.create_or_update_prompt(new_prompt)
 
             # 3. Cleanup: Delete prompts present in DB but not in Config
-            existing_prompts = self.llm_query_repo.get_prompts(company_instance.company)
+            existing_prompts = self.llm_query_repo.get_prompts(company)
             for p in existing_prompts:
                 if p.name not in defined_prompt_names:
                     # Using hard delete to keep consistent with previous "refresh" behavior
@@ -151,12 +162,9 @@ class PromptService:
                 raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME,
                                 f'missing system prompt file: {prompt_filename}')
         else:
-            template_dir = f'companies/{company.short_name}/prompts'
-
-            relative_prompt_path = os.path.join(template_dir, prompt_filename)
-            if not os.path.exists(relative_prompt_path):
+            if not self.asset_repo.exists(company.short_name, AssetType.PROMPT, prompt_filename):
                 raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME,
-                               f'missing prompt file: {relative_prompt_path}')
+                               f'missing prompt file: {prompt_filename} in prompts/')
 
         if custom_fields:
             for f in custom_fields:
@@ -188,33 +196,28 @@ class PromptService:
 
     def get_prompt_content(self, company: Company, prompt_name: str):
         try:
-            user_prompt_content = []
-            execution_dir = os.getcwd()
-
             # get the user prompt
             user_prompt = self.llm_query_repo.get_prompt_by_name(company, prompt_name)
             if not user_prompt:
                 raise IAToolkitException(IAToolkitException.ErrorType.DOCUMENT_NOT_FOUND,
                                    f"prompt not found '{prompt_name}' for company '{company.short_name}'")
 
-            prompt_file = f'companies/{company.short_name}/prompts/{user_prompt.filename}'
-            absolute_filepath = os.path.join(execution_dir, prompt_file)
-            if not os.path.exists(absolute_filepath):
-                raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
-                                   f"prompt file '{prompt_name}' does not exist: {absolute_filepath}")
-
             try:
-                with open(absolute_filepath, 'r', encoding='utf-8') as f:
-                    user_prompt_content = f.read()
+                user_prompt_content = self.asset_repo.read_text(
+                    company.short_name,
+                    AssetType.PROMPT,
+                    user_prompt.filename
+                )
+            except FileNotFoundError:
+                raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                                         f"prompt file '{user_prompt.filename}' does not exist for company '{company.short_name}'")
             except Exception as e:
                 raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
-                                   f"error while reading prompt: '{prompt_name}' in this pathname {absolute_filepath}: {e}")
+                                         f"error while reading prompt: '{prompt_name}': {e}")
 
             return user_prompt_content
 
         except IAToolkitException:
-            # Vuelve a lanzar las IAToolkitException que ya hemos manejado
-            # para que no sean capturadas por el siguiente bloque.
             raise
         except Exception as e:
             logging.exception(
@@ -260,7 +263,7 @@ class PromptService:
             # get all the prompts
             all_prompts = self.llm_query_repo.get_prompts(company)
 
-            # Agrupar prompts por categoría
+            # group by category
             prompts_by_category = defaultdict(list)
             for prompt in all_prompts:
                 if prompt.active:
@@ -268,14 +271,13 @@ class PromptService:
                         cat_key = (prompt.category.order, prompt.category.name)
                         prompts_by_category[cat_key].append(prompt)
 
-            # Ordenar los prompts dentro de cada categoría
+            # sort each category by order
             for cat_key in prompts_by_category:
                 prompts_by_category[cat_key].sort(key=lambda p: p.order)
 
-            # Crear la estructura de respuesta final, ordenada por la categoría
             categorized_prompts = []
 
-            # Ordenar las categorías por su 'order'
+            # sort categories by order
             sorted_categories = sorted(prompts_by_category.items(), key=lambda item: item[0][0])
 
             for (cat_order, cat_name), prompts in sorted_categories: