iatoolkit 2.4.0__tar.gz → 2.5.0__tar.gz

{iatoolkit-2.4.0/src/iatoolkit.egg-info → iatoolkit-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iatoolkit
-Version: 2.4.0
+Version: 2.5.0
 Summary: IAToolkit
 Author: Fernando Libedinsky
 License-Expression: MIT
@@ -12,6 +12,7 @@ Requires-Dist: bcrypt==4.2.1
 Requires-Dist: anthropic>=0.83.0
 Requires-Dist: boto3==1.36.22
 Requires-Dist: botocore==1.36.22
+Requires-Dist: braintrust>=0.17.0
 Requires-Dist: build==1.2.2.post1
 Requires-Dist: click==8.1.8
 Requires-Dist: cryptography==44.0.3

{iatoolkit-2.4.0 → iatoolkit-2.5.0}/pyproject.toml

@@ -29,4 +29,4 @@ version = { attr = "iatoolkit.__version__" }
 dependencies = { file = ["requirements.txt"] }
 
 [tool.setuptools.package-data]
-iatoolkit = ["system_prompts/*.prompt", "templates/**/*", "static/**/*", "locales/*.yaml", "config/*.yaml"]
+iatoolkit = ["templates/**/*", "static/**/*", "locales/*.yaml", "config/*.yaml", "config/system_prompts/*.prompt"]

{iatoolkit-2.4.0 → iatoolkit-2.5.0}/requirements.txt

@@ -2,6 +2,7 @@ bcrypt==4.2.1
 anthropic>=0.83.0
 boto3==1.36.22
 botocore==1.36.22
+braintrust>=0.17.0
 build==1.2.2.post1
 click==8.1.8
 cryptography==44.0.3

{iatoolkit-2.4.0 → iatoolkit-2.5.0}/src/iatoolkit/__init__.py

@@ -3,7 +3,7 @@
 #
 # IAToolkit is open source software.
 
-__version__ = "2.4.0"
+__version__ = "2.5.0"
 
 # Expose main classes and functions at the top level of the package
 

{iatoolkit-2.4.0/src/iatoolkit → iatoolkit-2.5.0/src/iatoolkit/config}/system_prompts/html_structures.prompt

@@ -1,7 +1,7 @@
 ### HTML estructurado
 
 #### Tablas
-- Usa como base `table table-striped table-hover`.
+- Usa como base `table table-striped table-hover` de Bootstrap como mínimo.
 - Si una columna contiene RUT, fecha, id certificado o valores similares, usa
   clase `nowrap` en el `<th>` y en el `<td>` correspondiente cuando aplique.
 - Si una columna debe ir centrada o alineada a la derecha, agrega

{iatoolkit-2.4.0 → iatoolkit-2.5.0}/src/iatoolkit/config/system_prompts_pack.yaml

@@ -71,7 +71,6 @@ prompts:
     include:
       execution_modes:
         - chat
-        - agent
   - key: file_download_output
     filename: file_download_output.prompt
     section: output_contract

{iatoolkit-2.4.0 → iatoolkit-2.5.0}/src/iatoolkit/core.py

@@ -402,6 +402,7 @@ class IAToolkit:
         from iatoolkit.services.i18n_service import I18nService
         from iatoolkit.services.language_service import LanguageService
         from iatoolkit.services.configuration_service import ConfigurationService
+        from iatoolkit.services.telemetry_service import TelemetryService
         from iatoolkit.services.embedding_service import EmbeddingService
         from iatoolkit.services.history_manager_service import HistoryManagerService
         from iatoolkit.services.tool_service import ToolService
@@ -443,6 +444,7 @@ class IAToolkit:
         binder.bind(I18nService, to=I18nService)
         binder.bind(LanguageService, to=LanguageService)
         binder.bind(ConfigurationService, to=ConfigurationService)
+        binder.bind(TelemetryService, to=TelemetryService)
         binder.bind(EmbeddingService, to=EmbeddingService)
         binder.bind(HistoryManagerService, to=HistoryManagerService)
         binder.bind(ToolService, to=ToolService)

{iatoolkit-2.4.0 → iatoolkit-2.5.0}/src/iatoolkit/infra/llm_proxy.py

@@ -86,6 +86,7 @@ class LLMProxy:
             company_short_name=company_short_name,
             model=model,
         )
+        model_config = self.configuration_service.get_llm_model_config(company_short_name, model) or {}
         provider_config = self.configuration_service.get_llm_provider_config(company_short_name, provider) or {}
 
         adapter = self._get_or_create_adapter(
@@ -98,6 +99,11 @@ class LLMProxy:
             provider_config=provider_config,
             request_kwargs=kwargs,
         )
+        request_kwargs = self._apply_model_request_overrides(
+            provider=provider,
+            model_config=model_config,
+            request_kwargs=request_kwargs,
+        )
 
         # Delegate to the adapter (OpenAI, Gemini, DeepSeek, xAI, Anthropic, etc.)
         return adapter.create_response(model=model, input=input, **request_kwargs)
@@ -218,6 +224,35 @@ class LLMProxy:
 
         return effective_kwargs
 
+    def _apply_model_request_overrides(
+        self,
+        provider: str,
+        model_config: Dict[str, Any],
+        request_kwargs: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        effective_kwargs = dict(request_kwargs or {})
+
+        if provider != self.PROVIDER_OPENROUTER or not isinstance(model_config, dict):
+            return effective_kwargs
+
+        model_runtime_config = model_config.get("config")
+        if not isinstance(model_runtime_config, dict):
+            return effective_kwargs
+
+        openrouter_provider = model_runtime_config.get("routing")
+        if not isinstance(openrouter_provider, dict) or not openrouter_provider:
+            return effective_kwargs
+
+        existing_provider = effective_kwargs.get("provider")
+        if isinstance(existing_provider, dict):
+            merged_provider = dict(openrouter_provider)
+            merged_provider.update(existing_provider)
+            effective_kwargs["provider"] = merged_provider
+        elif existing_provider is None:
+            effective_kwargs["provider"] = dict(openrouter_provider)
+
+        return effective_kwargs
+
     # -------------------------------------------------------------------------
     # Client cache
     # -------------------------------------------------------------------------

{iatoolkit-2.4.0 → iatoolkit-2.5.0}/src/iatoolkit/locales/en.yaml

@@ -69,6 +69,11 @@ ui:
       primary_input: "Primary Input"
       prompt_args: "Prompt Arguments (Client Data)"
       llm_output: "LLM Output (Raw JSON)"
+      telemetry_label: "Telemetry"
+      telemetry_open_trace: "Open Trace"
+      telemetry_not_recorded: "Not recorded"
+      telemetry_disabled: "Disabled"
+      telemetry_unknown_provider: "unknown provider"
 
   login_widget:
     title: "Sign In"
@@ -1041,6 +1046,8 @@ ui:
     store_response_default: "Provider default"
     store_response_true: "Yes"
     store_response_false: "No"
+    telemetry_enabled_label: "LLM Telemetry"
+    telemetry_enabled_help: "Send this agent's LLM runs to the company telemetry backend when telemetry is enabled in company configuration."
     tools_title: "Tool Selection"
     tools_mode_label: "Tools Mode"
     tools_mode_inherit: "Automatic"
@@ -1286,6 +1293,9 @@ ui:
     status_failed: "Failed"
     created_at: "Created"
     date_range: "Date range"
+    metadata_field: "Metadata field"
+    metadata_value: "Metadata value"
+    select_metadata_field: "Select a field"
     delete_confirmation: "Delete File?"
     delete_message: "This action cannot be undone. The file will be permanently removed."
     delete_button: "Delete"

{iatoolkit-2.4.0 → iatoolkit-2.5.0}/src/iatoolkit/locales/es.yaml

@@ -70,6 +70,11 @@ ui:
       primary_input: "Entrada Principal"
       prompt_args: "Argumentos del Prompt (Client Data)"
       llm_output: "Salida LLM (JSON Crudo)"
+      telemetry_label: "Telemetría"
+      telemetry_open_trace: "Abrir traza"
+      telemetry_not_recorded: "No registrada"
+      telemetry_disabled: "Deshabilitada"
+      telemetry_unknown_provider: "provider desconocido"
 
 
   login_widget:
@@ -1044,6 +1049,8 @@ ui:
     store_response_default: "Por defecto del provider"
     store_response_true: "Sí"
     store_response_false: "No"
+    telemetry_enabled_label: "Telemetría LLM"
+    telemetry_enabled_help: "Envía las ejecuciones LLM de este agente al backend de telemetría de la empresa cuando la telemetría esté habilitada en la configuración de la compañía."
     tools_title: "Selección de Tools"
     tools_mode_label: "Modo de Tools"
     tools_mode_inherit: "Automático"
@@ -1290,6 +1297,9 @@ ui:
     status_failed: "Fallido"
     created_at: "Creado"
     date_range: "Rango de fechas"
+    metadata_field: "Campo metadata"
+    metadata_value: "Valor metadata"
+    select_metadata_field: "Selecciona un campo"
     delete_confirmation: "¿Eliminar archivo?"
     delete_message: "Esta acción no se puede deshacer. El archivo se eliminará permanentemente."
     delete_button: "Eliminar"

{iatoolkit-2.4.0 → iatoolkit-2.5.0}/src/iatoolkit/services/configuration_service.py

@@ -52,6 +52,49 @@ class ConfigurationService:
             return {}
         return {"id": model_id}
 
+    @staticmethod
+    def _validate_openrouter_provider_preferences(add_error, section: str, provider_cfg) -> None:
+        if not isinstance(provider_cfg, dict):
+            add_error(section, "Must be a dictionary.")
+            return
+
+        for list_key in ("order", "only", "ignore"):
+            if list_key not in provider_cfg:
+                continue
+            raw_value = provider_cfg.get(list_key)
+            if not isinstance(raw_value, list) or any(not isinstance(item, str) or not item.strip() for item in raw_value):
+                add_error(f"{section}.{list_key}", "Must be a list of non-empty strings.")
+
+        for bool_key in ("allow_fallbacks", "require_parameters", "zdr"):
+            if bool_key in provider_cfg and not isinstance(provider_cfg.get(bool_key), bool):
+                add_error(f"{section}.{bool_key}", "Must be a boolean.")
+
+        if "data_collection" in provider_cfg:
+            data_collection = str(provider_cfg.get("data_collection") or "").strip().lower()
+            if data_collection not in {"allow", "deny"}:
+                add_error(f"{section}.data_collection", "Must be 'allow' or 'deny'.")
+
+        if "sort" in provider_cfg:
+            sort_value = provider_cfg.get("sort")
+            if isinstance(sort_value, str):
+                if sort_value.strip().lower() not in {"price", "throughput", "latency"}:
+                    add_error(
+                        f"{section}.sort",
+                        "Must be one of: ['latency', 'price', 'throughput'], or a dictionary."
+                    )
+            elif isinstance(sort_value, dict):
+                sort_by = str(sort_value.get("by") or "").strip().lower()
+                if sort_by and sort_by not in {"price", "throughput", "latency"}:
+                    add_error(f"{section}.sort.by", "Must be one of: ['latency', 'price', 'throughput'].")
+                partition = sort_value.get("partition")
+                if partition is not None and str(partition).strip().lower() not in {"provider", "model", "none"}:
+                    add_error(f"{section}.sort.partition", "Must be one of: ['model', 'none', 'provider'].")
+            else:
+                add_error(
+                    f"{section}.sort",
+                    "Must be one of: ['latency', 'price', 'throughput'], or a dictionary."
+                )
+
     def load_configuration(self, company_short_name: str):
         """
         Main entry point for configuring a company instance.
@@ -365,15 +408,43 @@ class ConfigurationService:
             for index, model_entry in enumerate(llm_available_models):
                 normalized_model = self._normalize_model_entry(model_entry)
                 provider = str(normalized_model.get("provider") or "").strip().lower()
+                model_specific_config = normalized_model.get("config")
                 if provider and provider not in supported_llm_providers:
                     add_error(
                         f"llm.available_models[{index}].provider",
                         f"Unsupported provider '{provider}'. Must be one of: {sorted(supported_llm_providers)}."
                     )
+                if model_specific_config is not None and not isinstance(model_specific_config, dict):
+                    add_error(f"llm.available_models[{index}].config", "Must be a dictionary.")
                 if provider == "openai_compatible":
                     openai_compatible_in_use = True
                 if provider == "openrouter":
                     openrouter_in_use = True
+                    if isinstance(model_specific_config, dict):
+                        if "routing" in model_specific_config:
+                            self._validate_openrouter_provider_preferences(
+                                add_error,
+                                f"llm.available_models[{index}].config.routing",
+                                model_specific_config.get("routing"),
+                            )
+                        if "openrouter_provider" in model_specific_config:
+                            add_error(
+                                f"llm.available_models[{index}].config.openrouter_provider",
+                                "Unsupported key. Use 'config.routing' instead.",
+                            )
+                elif isinstance(model_specific_config, dict) and (
+                    "routing" in model_specific_config or "openrouter_provider" in model_specific_config
+                ):
+                    if "routing" in model_specific_config:
+                        add_error(
+                            f"llm.available_models[{index}].config.routing",
+                            "Only supported when the model provider is 'openrouter'.",
+                        )
+                    if "openrouter_provider" in model_specific_config:
+                        add_error(
+                            f"llm.available_models[{index}].config.openrouter_provider",
+                            "Unsupported key. Use 'config.routing' instead.",
+                        )
 
             providers_cfg = config.get("llm", {}).get("providers")
             if providers_cfg is not None and not isinstance(providers_cfg, dict):
@@ -450,6 +521,56 @@ class ConfigurationService:
                     if raw_x_title is not None and (not isinstance(raw_x_title, str) or not raw_x_title.strip()):
                         add_error("llm.openrouter.x_title", "Must be a non-empty string.")
 
+            telemetry_cfg = config.get("llm", {}).get("telemetry")
+            if telemetry_cfg is not None:
+                if not isinstance(telemetry_cfg, dict):
+                    add_error("llm.telemetry", "Must be a dictionary.")
+                else:
+                    telemetry_enabled = telemetry_cfg.get("enabled", False)
+                    if not isinstance(telemetry_enabled, bool):
+                        add_error("llm.telemetry.enabled", "Must be a boolean.")
+
+                    telemetry_provider = telemetry_cfg.get("provider")
+                    normalized_telemetry_provider = ""
+                    if telemetry_provider is not None:
+                        if not isinstance(telemetry_provider, str) or not telemetry_provider.strip():
+                            add_error("llm.telemetry.provider", "Must be a non-empty string.")
+                        else:
+                            normalized_telemetry_provider = telemetry_provider.strip().lower()
+                            if normalized_telemetry_provider not in {"braintrust"}:
+                                add_error(
+                                    "llm.telemetry.provider",
+                                    "Unsupported provider. Must be 'braintrust'.",
+                                )
+                    elif telemetry_enabled:
+                        add_error("llm.telemetry.provider", "Missing required key: 'provider'.")
+
+                    if normalized_telemetry_provider == "braintrust":
+                        braintrust_cfg = telemetry_cfg.get("braintrust")
+                        if not isinstance(braintrust_cfg, dict):
+                            add_error("llm.telemetry.braintrust", "Must be a dictionary.")
+                        else:
+                            if telemetry_enabled:
+                                project = braintrust_cfg.get("project")
+                                if not isinstance(project, str) or not project.strip():
+                                    add_error("llm.telemetry.braintrust.project", "Must be a non-empty string.")
+
+                                api_key = braintrust_cfg.get("api_key")
+                                if not isinstance(api_key, str) or not api_key.strip():
+                                    add_error("llm.telemetry.braintrust.api_key", "Must be a non-empty string.")
+
+                            api_url = braintrust_cfg.get("api_url")
+                            if api_url is not None:
+                                if not isinstance(api_url, str) or not api_url.strip():
+                                    add_error("llm.telemetry.braintrust.api_url", "Must be a non-empty string.")
+                                else:
+                                    parsed = urlparse(api_url.strip())
+                                    if parsed.scheme.lower() not in {"http", "https"} or not parsed.netloc:
+                                        add_error(
+                                            "llm.telemetry.braintrust.api_url",
+                                            "Must be an absolute HTTP or HTTPS URL.",
+                                        )
+
         # 3. Embedding Provider
         if isinstance(config.get("embedding_provider"), dict):
             if not config.get("embedding_provider", {}).get("provider"):
@@ -607,6 +728,7 @@ class ConfigurationService:
                         "text_verbosity",
                         "prompt_version",
                         "prompt_variant",
+                        "telemetry_enabled",
                     }
                     unknown_option_keys = sorted(
                         key for key in llm_request_options.keys() if key not in allowed_option_keys
@@ -653,6 +775,15 @@ class ConfigurationService:
                                 "Must be a non-empty string.",
                             )
 
+                    if "telemetry_enabled" in llm_request_options and not isinstance(
+                        llm_request_options.get("telemetry_enabled"),
+                        bool,
+                    ):
+                        add_error(
+                            f"prompts[{i}].llm_request_options.telemetry_enabled",
+                            "Must be a boolean.",
+                        )
+
             tool_policy = prompt.get("tool_policy")
             if tool_policy is not None:
                 if not isinstance(tool_policy, dict):
@@ -752,6 +883,49 @@ class ConfigurationService:
                 if not isinstance(docling_config, dict):
                     add_error("knowledge_base.docling", "Must be a dictionary.")
 
+            metadata_search_fields = kb_config.get("metadata_search_fields")
+            if metadata_search_fields is not None:
+                if not isinstance(metadata_search_fields, list):
+                    add_error("knowledge_base.metadata_search_fields", "Must be a list.")
+                else:
+                    for i, item in enumerate(metadata_search_fields):
+                        if isinstance(item, str):
+                            if not item.strip():
+                                add_error(
+                                    f"knowledge_base.metadata_search_fields[{i}]",
+                                    "Metadata field name cannot be empty."
+                                )
+                        elif isinstance(item, dict):
+                            key = item.get("key")
+                            if not isinstance(key, str) or not key.strip():
+                                add_error(
+                                    f"knowledge_base.metadata_search_fields[{i}].key",
+                                    "Missing required key: 'key' (non-empty string)."
+                                )
+                            label = item.get("label")
+                            if label is not None and (not isinstance(label, str) or not label.strip()):
+                                add_error(
+                                    f"knowledge_base.metadata_search_fields[{i}].label",
+                                    "Must be a non-empty string if provided."
+                                )
+                            match = item.get("match")
+                            if match is not None:
+                                if not isinstance(match, str):
+                                    add_error(
+                                        f"knowledge_base.metadata_search_fields[{i}].match",
+                                        "Must be a string if provided."
+                                    )
+                                elif match.strip().lower() not in {"exact", "contains"}:
+                                    add_error(
+                                        f"knowledge_base.metadata_search_fields[{i}].match",
+                                        "Must be one of: ['contains', 'exact']."
+                                    )
+                        else:
+                            add_error(
+                                f"knowledge_base.metadata_search_fields[{i}]",
+                                "Each metadata search field must be a string or an object with keys like {key, label, match}."
+                            )
+
             prod_connector = kb_config.get("connectors", {}).get("production", {})
             if prod_connector.get("type") == "s3":
                 for key in ["bucket", "prefix"]:
@@ -996,6 +1170,12 @@ class ConfigurationService:
         provider_cfg = providers_cfg.get(candidate)
         return dict(provider_cfg) if isinstance(provider_cfg, dict) else {}
 
+    def get_llm_telemetry_config(self, company_short_name: str) -> dict:
+        self._ensure_config_loaded(company_short_name)
+        llm_config = self._loaded_configs[company_short_name].get("llm") or {}
+        telemetry_cfg = llm_config.get("telemetry")
+        return dict(telemetry_cfg) if isinstance(telemetry_cfg, dict) else {}
+
 
     def _load_and_merge_configs(self, company_short_name: str) -> dict:
         """

{iatoolkit-2.4.0 → iatoolkit-2.5.0}/src/iatoolkit/services/knowledge_base_service.py

@@ -14,7 +14,7 @@ from iatoolkit.services.storage_service import StorageService
 from iatoolkit.services.parsers.parsing_service import ParsingService
 from langchain_text_splitters import RecursiveCharacterTextSplitter
 from iatoolkit.services.visual_kb_service import VisualKnowledgeBaseService
-from sqlalchemy import desc
+from sqlalchemy import desc, func
 from typing import Any
 import json
 from iatoolkit.common.exceptions import IAToolkitException
@@ -564,6 +564,9 @@ class KnowledgeBaseService:
                        filename_keyword: Optional[str] = None,
                        from_date: Optional[datetime] = None,
                        to_date: Optional[datetime] = None,
+                       metadata_key: Optional[str] = None,
+                       metadata_value: Optional[str] = None,
+                       metadata_match_mode: Optional[str] = None,
                        limit: int = 100,
                        offset: int = 0) -> List[Document]:
         """
@@ -577,6 +580,9 @@ class KnowledgeBaseService:
             filename_keyword: Optional substring to search in filename.
             from_date: Optional start date filter (created_at).
             to_date: Optional end date filter (created_at).
+            metadata_key: Optional top-level metadata field name inside Document.meta.
+            metadata_value: Optional metadata field value to filter by.
+            metadata_match_mode: Optional metadata match mode: 'exact' or 'contains'.
             limit: Pagination limit.
             offset: Pagination offset.
 
@@ -613,6 +619,16 @@ class KnowledgeBaseService:
         if to_date:
             query = query.filter(Document.created_at <= to_date)
 
+        normalized_metadata_key = str(metadata_key or "").strip()
+        normalized_metadata_value = str(metadata_value or "").strip().lower()
+        normalized_match_mode = str(metadata_match_mode or "contains").strip().lower()
+        if normalized_metadata_key and normalized_metadata_value:
+            meta_value_expr = func.lower(func.coalesce(Document.meta[normalized_metadata_key].as_string(), ""))
+            if normalized_match_mode == "exact":
+                query = query.filter(meta_value_expr == normalized_metadata_value)
+            else:
+                query = query.filter(meta_value_expr.like(f"%{normalized_metadata_value}%"))
+
         # Apply sorting (newest first) and pagination
         query = query.order_by(desc(Document.created_at))
         query = query.limit(limit).offset(offset)

{iatoolkit-2.4.0 → iatoolkit-2.5.0}/src/iatoolkit/services/llm_client_service.py

@@ -23,6 +23,7 @@ from typing import Dict, Optional, List, Any
 from iatoolkit.services.dispatcher_service import Dispatcher
 from iatoolkit.services.storage_service import StorageService
 from iatoolkit.services.structured_output_service import StructuredOutputService
+from iatoolkit.services.telemetry_service import NoopTelemetryService
 
 CONTEXT_ERROR_MESSAGE = 'Tu consulta supera el límite de contexto, utiliza el boton de recarga de contexto.'
 
@@ -36,7 +37,8 @@ class llmClient:
                  llm_proxy: LLMProxy,
                  model_registry: ModelRegistry,
                  storage_service: StorageService,
-                 util: Utility
+                 util: Utility,
+                 telemetry_service=None,
                  ):
         self.llmquery_repo = llmquery_repo
         self.llm_proxy = llm_proxy
@@ -44,6 +46,7 @@ class llmClient:
         self.storage_service = storage_service
         self.util = util
         self._dispatcher = None # Cache for the lazy-loaded dispatcher
+        self._telemetry_service = telemetry_service
 
         # Lazy init to avoid network/bootstrap failures during app startup.
         self.encoding = None
@@ -62,6 +65,18 @@ class llmClient:
             self._dispatcher = current_iatoolkit().get_injector().get(Dispatcher)
         return self._dispatcher
 
+    @property
+    def telemetry_service(self):
+        if self._telemetry_service is None:
+            try:
+                from iatoolkit import current_iatoolkit
+                from iatoolkit.services.telemetry_service import TelemetryService
+
+                self._telemetry_service = current_iatoolkit().get_injector().get(TelemetryService)
+            except Exception:
+                self._telemetry_service = NoopTelemetryService()
+        return self._telemetry_service
+
 
     def invoke(self,
                company: Company,
@@ -81,6 +96,7 @@ class llmClient:
                task_id: Optional[int] = None,
                execution_metadata: Optional[Dict[str, Any]] = None,
                request_metadata: Optional[Dict[str, str]] = None,
+               telemetry_request: Optional[Dict[str, Any]] = None,
                response_contract: Optional[Dict[str, Any]] = None
                ) -> dict:
 
@@ -102,6 +118,7 @@ class llmClient:
         )
         text_payload = request_params["text"]
         reasoning_payload = request_params["reasoning"]
+        telemetry_execution = self.telemetry_service.start_execution(telemetry_request)
 
         try:
             start_time = time.time()
@@ -285,6 +302,22 @@ class llmClient:
                              answer_time=stats['response_time']
                              )
             self.llmquery_repo.add_query(query)
+            telemetry_execution.finalize(
+                query_id=query.id,
+                success=decoded_response.get('status', False),
+                answer_preview=decoded_response.get('answer', ''),
+                metrics={
+                    "total_tokens": combined_stats.get("total_tokens"),
+                    "response_time": combined_stats.get("response_time"),
+                    "sql_retry_count": combined_stats.get("sql_retry_count"),
+                },
+            )
+            telemetry_stats = telemetry_execution.build_stats()
+            if telemetry_stats:
+                query.stats = dict(query.stats or {})
+                query.stats["telemetry"] = telemetry_stats
+                self.llmquery_repo.commit()
+                combined_stats = dict(query.stats or {})
             logging.info(f"finish llm call in {int(time.time() - start_time)} secs..")
             if function_calls:
                 logging.info(f"time within the function calls {f_call_time:.1f} secs.")
@@ -312,9 +345,17 @@ class llmClient:
         except SQLAlchemyError as db_error:
             # rollback
             self.llmquery_repo.session.rollback()
+            telemetry_execution.finalize(
+                success=False,
+                error_message=str(db_error),
+            )
             logging.error(f"Error de base de datos: {str(db_error)}")
             raise db_error
         except OperationalError as e:
+            telemetry_execution.finalize(
+                success=False,
+                error_message=str(e),
+            )
             logging.error(f"Operational error: {str(e)}")
             raise e
         except Exception as e:
@@ -331,6 +372,15 @@ class llmClient:
                              function_calls=f_calls,
                              )
             self.llmquery_repo.add_query(query)
+            telemetry_execution.finalize(
+                query_id=query.id,
+                success=False,
+                error_message=error_message,
+            )
+            telemetry_stats = telemetry_execution.build_stats()
+            if telemetry_stats:
+                query.stats = {"telemetry": telemetry_stats}
+                self.llmquery_repo.commit()
 
             # in case of context error
             if "context_length_exceeded" in str(e):

{iatoolkit-2.4.0 → iatoolkit-2.5.0}/src/iatoolkit/services/prompt_service.py

@@ -345,6 +345,7 @@ class PromptService:
             "text_verbosity",
             "prompt_version",
             "prompt_variant",
+            "telemetry_enabled",
         }
         unknown_keys = sorted(
             key for key in llm_request_options.keys() if key not in allowed_keys
@@ -422,6 +423,15 @@ class PromptService:
                 )
             normalized_options["prompt_variant"] = candidate_prompt_variant
 
+        raw_telemetry_enabled = llm_request_options.get("telemetry_enabled")
+        if raw_telemetry_enabled is not None:
+            if not isinstance(raw_telemetry_enabled, bool):
+                raise IAToolkitException(
+                    IAToolkitException.ErrorType.INVALID_PARAMETER,
+                    "llm_request_options.telemetry_enabled must be a boolean.",
+                )
+            normalized_options["telemetry_enabled"] = raw_telemetry_enabled
+
         return normalized_options
 
     def get_prompts(self, company_short_name: str, include_all: bool = False) -> dict: