iatoolkit 2.4.1__tar.gz → 2.5.1__tar.gz

{iatoolkit-2.4.1/src/iatoolkit.egg-info → iatoolkit-2.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iatoolkit
-Version: 2.4.1
+Version: 2.5.1
 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.1 → iatoolkit-2.5.1}/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.1 → iatoolkit-2.5.1}/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.1 → iatoolkit-2.5.1}/src/iatoolkit/__init__.py

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

{iatoolkit-2.4.1 → iatoolkit-2.5.1}/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.1 → iatoolkit-2.5.1}/src/iatoolkit/infra/llm_providers/anthropic_adapter.py

@@ -33,7 +33,8 @@ class AnthropicAdapter:
                         images: Optional[List[Dict]] = None,
                         attachments: Optional[List[Dict]] = None,
                         store: Optional[bool] = None,
-                        metadata: Optional[Dict[str, str]] = None) -> LLMResponse:
+                        metadata: Optional[Dict[str, str]] = None,
+                        telemetry_execution: Any = None) -> LLMResponse:
         """
         Calls Anthropic Messages API and maps the response to common LLMResponse.
 
@@ -76,6 +77,8 @@ class AnthropicAdapter:
                 if tool_choice_payload:
                     params["tool_choice"] = tool_choice_payload
 
+            self._record_telemetry_input(telemetry_execution, params)
+
             anthropic_response = self.client.messages.create(**params)
             return self._map_anthropic_response(anthropic_response, model)
 
@@ -87,6 +90,12 @@ class AnthropicAdapter:
                 error_message
             ) from e
 
+    @staticmethod
+    def _record_telemetry_input(telemetry_execution: Any, payload: Dict[str, Any]) -> None:
+        record_input = getattr(telemetry_execution, "record_input", None)
+        if callable(record_input):
+            record_input(payload)
+
     def _prepare_messages(self, input_items: List[Dict], images: List[Dict]) -> tuple[Optional[str], List[Dict]]:
         system_parts: List[str] = []
         messages: List[Dict] = []

{iatoolkit-2.4.1 → iatoolkit-2.5.1}/src/iatoolkit/infra/llm_providers/gemini_adapter.py

@@ -53,6 +53,7 @@ class GeminiAdapter:
                         attachments: Optional[List[Dict]] = None,
                         store: Optional[bool] = None,
                         metadata: Optional[Dict[str, str]] = None,
+                        telemetry_execution: Any = None,
                         ) -> LLMResponse:
         try:
             _ = store
@@ -105,6 +106,15 @@ class GeminiAdapter:
                 else:
                     raise
 
+            self._record_telemetry_input(
+                telemetry_execution,
+                {
+                    "model": model,
+                    "contents": contents,
+                    "config": dict(config_kwargs),
+                },
+            )
+
             # call the new SDK
             response = self.client.models.generate_content(
                 model=model,
@@ -144,6 +154,12 @@ class GeminiAdapter:
 
             raise IAToolkitException(IAToolkitException.ErrorType.LLM_ERROR, error_message)
 
+    @staticmethod
+    def _record_telemetry_input(telemetry_execution: Any, payload: Dict[str, Any]) -> None:
+        record_input = getattr(telemetry_execution, "record_input", None)
+        if callable(record_input):
+            record_input(payload)
+
     def _extract_system_and_filter_input(self, input_list: List[Dict]) -> tuple[Optional[str], List[Dict]]:
         """Extrae el mensaje de sistema para usarlo en system_instruction."""
         system_parts = []

{iatoolkit-2.4.1 → iatoolkit-2.5.1}/src/iatoolkit/infra/llm_providers/openai_adapter.py

@@ -4,10 +4,9 @@
 # IAToolkit is open source software.
 
 import logging
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from iatoolkit.infra.llm_response import LLMResponse, ToolCall, Usage
 from iatoolkit.common.exceptions import IAToolkitException
-from typing import List
 import mimetypes
 import re
 import base64
@@ -31,7 +30,8 @@ class OpenAIAdapter:
                         images: Optional[List[Dict]] = None,
                         attachments: Optional[List[Dict]] = None,
                         store: Optional[bool] = None,
-                        metadata: Optional[Dict[str, str]] = None) -> LLMResponse:
+                        metadata: Optional[Dict[str, str]] = None,
+                        telemetry_execution: Any = None) -> LLMResponse:
         """Llamada a la API de OpenAI y mapeo a estructura común"""
         try:
             # Handle multimodal input if images are present
@@ -64,6 +64,8 @@ class OpenAIAdapter:
             if tool_choice_payload is not None:
                 params['tool_choice'] = tool_choice_payload
 
+            self._record_telemetry_input(telemetry_execution, params)
+
             # Llamar a la API de OpenAI
             openai_response = self.client.responses.create(**params)
 
@@ -76,6 +78,12 @@ class OpenAIAdapter:
 
             raise IAToolkitException(IAToolkitException.ErrorType.LLM_ERROR, error_message)
 
+    @staticmethod
+    def _record_telemetry_input(telemetry_execution: Any, payload: Dict[str, Any]) -> None:
+        record_input = getattr(telemetry_execution, "record_input", None)
+        if callable(record_input):
+            record_input(payload)
+
     @staticmethod
     def _map_tool_choice(tool_choice: str, tools_payload: List[Dict]) -> Optional[Dict | str]:
         if tool_choice in ("", None, "auto"):

{iatoolkit-2.4.1 → iatoolkit-2.5.1}/src/iatoolkit/infra/llm_providers/openai_compatible_chat_adapter.py

@@ -48,6 +48,7 @@ class OpenAICompatibleChatAdapter:
         text = kwargs.get("text") or {}
         reasoning = kwargs.get("reasoning")
         metadata = kwargs.get("metadata")
+        telemetry_execution = kwargs.get("telemetry_execution")
 
         try:
             messages: List[Dict[str, Any]] = []
@@ -111,6 +112,7 @@ class OpenAICompatibleChatAdapter:
                 call_kwargs["parallel_tool_calls"] = bool(kwargs.get("parallel_tool_calls"))
 
             self._extend_call_kwargs(call_kwargs, kwargs)
+            self._record_telemetry_input(telemetry_execution, call_kwargs)
 
             logging.debug(
                 "[%sAdapter] Calling chat.completions API with %s messages.",
@@ -130,6 +132,12 @@ class OpenAICompatibleChatAdapter:
                 f"{self.provider_label} error: {ex}"
             ) from ex
 
+    @staticmethod
+    def _record_telemetry_input(telemetry_execution: Any, payload: Dict[str, Any]) -> None:
+        record_input = getattr(telemetry_execution, "record_input", None)
+        if callable(record_input):
+            record_input(payload)
+
     def _extend_call_kwargs(self, call_kwargs: Dict[str, Any], kwargs: Dict[str, Any]) -> None:
         _ = call_kwargs
         _ = kwargs

{iatoolkit-2.4.1 → iatoolkit-2.5.1}/src/iatoolkit/infra/llm_proxy.py

@@ -17,6 +17,7 @@ from iatoolkit.infra.llm_response import LLMResponse
 from iatoolkit.common.model_registry import ModelRegistry
 from iatoolkit.common.interfaces.secret_provider import SecretProvider
 from iatoolkit.common.secret_resolver import resolve_secret
+from iatoolkit.services.telemetry_service import NoopTelemetryService
 
 from openai import OpenAI, Timeout         # For OpenAI and xAI (OpenAI-compatible)
 
@@ -53,6 +54,7 @@ class LLMProxy:
         configuration_service: ConfigurationService,
         model_registry: ModelRegistry,
         secret_provider: SecretProvider,
+        telemetry_service=None,
     ):
         """
         Init a new instance of the proxy. It can be a base factory or a working instance with configured clients.
@@ -62,10 +64,23 @@ class LLMProxy:
         self.configuration_service = configuration_service
         self.model_registry = model_registry
         self.secret_provider = secret_provider
+        self._telemetry_service = telemetry_service
 
         # adapter cache by (provider, api_key, base_url)
         self.adapters: Dict[Tuple[Any, ...], Any] = {}
 
+    @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
+
     # -------------------------------------------------------------------------
     # Public API
     # -------------------------------------------------------------------------
@@ -81,6 +96,9 @@ class LLMProxy:
                 "company_short_name is required in kwargs to resolve LLM credentials."
             )
 
+        telemetry_request = kwargs.pop("telemetry_request", None)
+        telemetry_execution = kwargs.pop("telemetry_execution", None)
+
         # Determine the provider based on the model name
         provider = self._resolve_provider_for_company_model(
             company_short_name=company_short_name,
@@ -92,6 +110,7 @@ class LLMProxy:
         adapter = self._get_or_create_adapter(
             provider=provider,
             company_short_name=company_short_name,
+            telemetry_request=telemetry_request,
         )
 
         request_kwargs = self._apply_provider_request_overrides(
@@ -104,6 +123,8 @@ class LLMProxy:
             model_config=model_config,
             request_kwargs=request_kwargs,
         )
+        if telemetry_execution is not None:
+            request_kwargs["telemetry_execution"] = telemetry_execution
 
         # Delegate to the adapter (OpenAI, Gemini, DeepSeek, xAI, Anthropic, etc.)
         return adapter.create_response(model=model, input=input, **request_kwargs)
@@ -146,7 +167,12 @@ class LLMProxy:
     # Adapter management
     # -------------------------------------------------------------------------
 
-    def _get_or_create_adapter(self, provider: str, company_short_name: str) -> Any:
+    def _get_or_create_adapter(
+        self,
+        provider: str,
+        company_short_name: str,
+        telemetry_request: Dict[str, Any] | None = None,
+    ) -> Any:
         """
         Return an adapter instance for the given provider.
         If none exists yet, create it using a cached or new low-level client.
@@ -158,6 +184,24 @@ class LLMProxy:
         connect_timeout_seconds = client_config["connect_timeout_seconds"]
         read_timeout_seconds = client_config["read_timeout_seconds"]
         max_retries = client_config["max_retries"]
+        client = self._get_or_create_client(
+            provider,
+            api_key,
+            base_url=base_url,
+            default_headers=default_headers,
+            connect_timeout_seconds=connect_timeout_seconds,
+            read_timeout_seconds=read_timeout_seconds,
+            max_retries=max_retries,
+        )
+
+        wrapped_client = self.telemetry_service.wrap_client_for_request(
+            llm_provider=provider,
+            client=client,
+            request=telemetry_request,
+        )
+        if wrapped_client is not client:
+            return self._build_adapter(provider, wrapped_client)
+
         adapter_cache_key = (
             provider,
             api_key or "",
@@ -168,42 +212,31 @@ class LLMProxy:
             max_retries,
         )
 
-        # If already created for this provider+key, just return it
         if adapter_cache_key in self.adapters and self.adapters[adapter_cache_key] is not None:
             return self.adapters[adapter_cache_key]
 
-        # Otherwise, create low-level client from configuration
-        client = self._get_or_create_client(
-            provider,
-            api_key,
-            base_url=base_url,
-            default_headers=default_headers,
-            connect_timeout_seconds=connect_timeout_seconds,
-            read_timeout_seconds=read_timeout_seconds,
-            max_retries=max_retries,
-        )
+        adapter = self._build_adapter(provider, client)
+        self.adapters[adapter_cache_key] = adapter
+        return adapter
 
-        # Wrap client with the correct adapter
+    def _build_adapter(self, provider: str, client: Any) -> Any:
         if provider == self.PROVIDER_OPENAI:
-            adapter = OpenAIAdapter(client)
-        elif provider == self.PROVIDER_GEMINI:
-            adapter = GeminiAdapter(client)
-        elif provider == self.PROVIDER_DEEPSEEK:
-            adapter = DeepseekAdapter(client)
-        elif provider == self.PROVIDER_OPENAI_COMPATIBLE:
-            adapter = OpenAICompatibleChatAdapter(client, provider_label="OpenAI-compatible")
-        elif provider == self.PROVIDER_OPENROUTER:
-            adapter = OpenRouterAdapter(client)
-        elif provider == self.PROVIDER_ANTHROPIC:
-            adapter = AnthropicAdapter(client)
-        else:
-            raise IAToolkitException(
-                IAToolkitException.ErrorType.MODEL,
-                f"Provider not supported in _get_or_create_adapter: {provider}"
-            )
+            return OpenAIAdapter(client)
+        if provider == self.PROVIDER_GEMINI:
+            return GeminiAdapter(client)
+        if provider == self.PROVIDER_DEEPSEEK:
+            return DeepseekAdapter(client)
+        if provider == self.PROVIDER_OPENAI_COMPATIBLE:
+            return OpenAICompatibleChatAdapter(client, provider_label="OpenAI-compatible")
+        if provider == self.PROVIDER_OPENROUTER:
+            return OpenRouterAdapter(client)
+        if provider == self.PROVIDER_ANTHROPIC:
+            return AnthropicAdapter(client)
 
-        self.adapters[adapter_cache_key] = adapter
-        return adapter
+        raise IAToolkitException(
+            IAToolkitException.ErrorType.MODEL,
+            f"Provider not supported in _get_or_create_adapter: {provider}"
+        )
 
     def _apply_provider_request_overrides(
         self,

{iatoolkit-2.4.1 → iatoolkit-2.5.1}/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"

{iatoolkit-2.4.1 → iatoolkit-2.5.1}/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"

{iatoolkit-2.4.1 → iatoolkit-2.5.1}/src/iatoolkit/services/configuration_service.py

@@ -521,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"):
@@ -678,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
@@ -724,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):
@@ -1110,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.1 → iatoolkit-2.5.1}/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()
@@ -138,6 +155,8 @@ class llmClient:
                     attachments=active_attachments,
                     store=store,
                     metadata=request_metadata,
+                    telemetry_request=telemetry_request,
+                    telemetry_execution=telemetry_execution,
                 )
                 stats = self.get_stats(response)
 
@@ -246,6 +265,8 @@ class llmClient:
                     attachments=active_attachments,
                     store=store,
                     metadata=request_metadata,
+                    telemetry_request=telemetry_request,
+                    telemetry_execution=telemetry_execution,
                 )
                 stats_fcall = self.add_stats(stats_fcall, self.get_stats(response))
 
@@ -285,6 +306,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 +349,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 +376,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.1 → iatoolkit-2.5.1}/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: