iatoolkit 2.5.0__tar.gz → 2.5.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iatoolkit
-Version: 2.5.0
+Version: 2.5.1
 Summary: IAToolkit
 Author: Fernando Libedinsky
 License-Expression: MIT

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

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

{iatoolkit-2.5.0 → 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.5.0 → 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.5.0 → 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.5.0 → 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.5.0 → 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.5.0 → iatoolkit-2.5.1}/src/iatoolkit/services/llm_client_service.py

@@ -155,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)
 
@@ -263,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))
 

{iatoolkit-2.5.0 → iatoolkit-2.5.1}/src/iatoolkit/services/telemetry_service.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import copy
 from dataclasses import dataclass, field
 from typing import Any
 
@@ -26,8 +27,25 @@ class TelemetryExecution:
     metadata: dict[str, Any] = field(default_factory=dict)
     trace_id: str | None = None
     trace_url: str | None = None
+    _input_payloads: list[Any] = field(default_factory=list)
     _finalized: bool = False
 
+    def record_input(self, payload: Any) -> None:
+        if payload is None or self._finalized:
+            return
+
+        try:
+            self._input_payloads.append(copy.deepcopy(payload))
+        except Exception:
+            self._input_payloads.append(payload)
+
+    def build_input_payload(self) -> Any | None:
+        if not self._input_payloads:
+            return None
+        if len(self._input_payloads) == 1:
+            return self._input_payloads[0]
+        return {"requests": list(self._input_payloads)}
+
     def finalize(
         self,
         *,
@@ -56,6 +74,9 @@ class TelemetryExecution:
                 metadata["metrics"] = dict(metrics)
 
             event: dict[str, Any] = {}
+            input_payload = self.build_input_payload()
+            if input_payload is not None:
+                event["input"] = input_payload
             if metadata:
                 event["metadata"] = metadata
             if answer_preview:
@@ -105,6 +126,15 @@ class NoopTelemetryService:
     def start_execution(self, request: dict[str, Any] | None) -> TelemetryExecution:
         return TelemetryExecution()
 
+    def wrap_client_for_request(
+        self,
+        *,
+        llm_provider: str,
+        client: Any,
+        request: dict[str, Any] | None,
+    ) -> Any:
+        return client
+
 
 class BraintrustTelemetryBridge:
     _instrumented = False
@@ -156,6 +186,16 @@ class BraintrustTelemetryBridge:
             metadata=metadata,
         )
 
+    def wrap_client(self, *, llm_provider: str, client: Any) -> Any:
+        self._ensure_runtime()
+
+        provider_name = str(llm_provider or "").strip().lower()
+        if provider_name in {"openai", "xai", "deepseek", "openai_compatible", "openrouter"}:
+            return self._braintrust.wrap_openai(client)
+        if provider_name == "anthropic":
+            return self._braintrust.wrap_anthropic(client)
+        return client
+
     def _ensure_runtime(self) -> None:
         if self._braintrust is not None and self._instrumented:
             return
@@ -416,3 +456,29 @@ class TelemetryService:
                 runtime_error=str(exc),
                 metadata=dict(request.get("metadata") or {}),
             )
+
+    def wrap_client_for_request(
+        self,
+        *,
+        llm_provider: str,
+        client: Any,
+        request: dict[str, Any] | None,
+    ) -> Any:
+        if client is None:
+            return None
+        if not isinstance(request, dict) or not request.get("enabled"):
+            return client
+
+        provider_name = str(request.get("provider") or "").strip().lower()
+        if provider_name != self.PROVIDER_BRAINTRUST:
+            return client
+
+        try:
+            return self._braintrust_bridge.wrap_client(llm_provider=llm_provider, client=client)
+        except Exception as exc:
+            logging.warning(
+                "Telemetry client wrapping unavailable for provider '%s': %s",
+                llm_provider,
+                exc,
+            )
+            return client

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iatoolkit
-Version: 2.5.0
+Version: 2.5.1
 Summary: IAToolkit
 Author: Fernando Libedinsky
 License-Expression: MIT