iatoolkit 0.95.4__tar.gz → 0.108.1__tar.gz

{iatoolkit-0.95.4/src/iatoolkit.egg-info → iatoolkit-0.108.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iatoolkit
-Version: 0.95.4
+Version: 0.108.1
 Summary: IAToolkit
 Author: Fernando Libedinsky
 License-Expression: MIT
@@ -14,7 +14,6 @@ Requires-Dist: botocore==1.36.22
 Requires-Dist: build==1.2.2.post1
 Requires-Dist: click==8.1.8
 Requires-Dist: cryptography==44.0.3
-Requires-Dist: deepseek==1.0.0
 Requires-Dist: Flask==3.1.0
 Requires-Dist: Flask-Bcrypt==1.0.1
 Requires-Dist: flask-cors==6.0.0

{iatoolkit-0.95.4 → iatoolkit-0.108.1}/requirements.txt

@@ -4,7 +4,6 @@ botocore==1.36.22
 build==1.2.2.post1
 click==8.1.8
 cryptography==44.0.3
-deepseek==1.0.0
 Flask==3.1.0
 Flask-Bcrypt==1.0.1
 flask-cors==6.0.0

{iatoolkit-0.95.4 → iatoolkit-0.108.1}/src/iatoolkit/__init__.py

@@ -3,7 +3,7 @@
 #
 # IAToolkit is open source software.
 
-__version__ = "0.95.4"
+__version__ = "0.108.1"
 
 # Expose main classes and functions at the top level of the package
 
@@ -24,6 +24,7 @@ from iatoolkit.infra.call_service import CallServiceClient
 from iatoolkit.services.profile_service import ProfileService
 from iatoolkit.services.mail_service import MailService
 from iatoolkit.repositories.models import Base as OrmModel
+from iatoolkit.base_company import BaseCompany
 
 __all__ = [
     'IAToolkit',
@@ -40,5 +41,6 @@ __all__ = [
     'CallServiceClient',
     'ProfileService',
     'MailService',
-    'OrmModel'
+    'OrmModel',
+    'BaseCompany',
 ]

iatoolkit-0.108.1/src/iatoolkit/base_company.py

@@ -0,0 +1,21 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+# companies/base_company.py
+from abc import ABC, abstractmethod
+
+class BaseCompany(ABC):
+
+    @abstractmethod
+    # execute the specific action configured in the intent table
+    def handle_request(self, tag: str, params: dict) -> dict:
+        raise NotImplementedError("La subclase debe implementar el método handle_request()")
+
+    @abstractmethod
+    def register_cli_commands(self, app):
+        pass
+
+    def unsupported_operation(self, tag):
+        raise NotImplementedError(f"La operación '{tag}' no está soportada por esta empresa.")

{iatoolkit-0.95.4 → iatoolkit-0.108.1}/src/iatoolkit/cli_commands.py

@@ -14,12 +14,13 @@ def register_core_commands(app):
 
     @app.cli.command("api-key")
     @click.argument("company_short_name")
-    def api_key(company_short_name: str):
+    @click.argument("key_name")
+    def api_key(company_short_name: str, key_name: str):
         """⚙️ Genera una nueva API key para una compañía ya registrada."""
         try:
             profile_service = IAToolkit.get_instance().get_injector().get(ProfileService)
             click.echo(f"🔑 Generating API-KEY for company: '{company_short_name}'...")
-            result = profile_service.new_api_key(company_short_name)
+            result = profile_service.new_api_key(company_short_name, key_name)
 
             if 'error' in result:
                 click.echo(f"❌ Error: {result['error']}")

iatoolkit-0.108.1/src/iatoolkit/common/interfaces/asset_storage.py

@@ -0,0 +1,34 @@
+from enum import Enum
+from typing import List
+import abc
+
+
+class AssetType(Enum):
+    CONFIG = "config"
+    PROMPT = "prompts"
+    SCHEMA = "schema"
+    CONTEXT = "context"
+
+
+class AssetRepository(abc.ABC):
+    @abc.abstractmethod
+    def exists(self, company_short_name: str, asset_type: AssetType, filename: str) -> bool:
+        pass
+
+    @abc.abstractmethod
+    def read_text(self, company_short_name: str, asset_type: AssetType, filename: str) -> str:
+        pass
+
+    @abc.abstractmethod
+    def list_files(self, company_short_name: str, asset_type: AssetType, extension: str = None) -> List[str]:
+        pass
+
+    @abc.abstractmethod
+    def write_text(self, company_short_name: str, asset_type: AssetType, filename: str, content: str) -> None:
+        """Creates or updates a text asset."""
+        pass
+
+    @abc.abstractmethod
+    def delete(self, company_short_name: str, asset_type: AssetType, filename: str) -> None:
+        """Deletes an asset if it exists."""
+        pass

iatoolkit-0.108.1/src/iatoolkit/common/interfaces/database_provider.py

@@ -0,0 +1,38 @@
+import abc
+from typing import Any, List, Dict, Union
+
+class DatabaseProvider(abc.ABC):
+    """
+    Abstract interface for interacting with a database source.
+    Handles both metadata introspection and query execution.
+    """
+
+    # --- Schema Methods ---
+    @abc.abstractmethod
+    def get_all_table_names(self) -> List[str]:
+        pass
+
+    @abc.abstractmethod
+    def get_table_description(self,
+                              table_name: str,
+                              schema_object_name: str | None = None,
+                              exclude_columns: List[str] | None = None) -> str:
+        pass
+
+    # --- Execution Methods ---
+    @abc.abstractmethod
+    def execute_query(self, query: str, commit: bool = False) -> Union[List[Dict[str, Any]], Dict[str, int]]:
+        """
+        Executes a query and returns:
+         - A list of dicts for SELECT (rows).
+         - A dict {'rowcount': N} for INSERT/UPDATE/DELETE.
+        """
+        pass
+
+    @abc.abstractmethod
+    def commit(self) -> None:
+        pass
+
+    @abc.abstractmethod
+    def rollback(self) -> None:
+        pass

{iatoolkit-0.95.4 → iatoolkit-0.108.1}/src/iatoolkit/common/model_registry.py

@@ -42,7 +42,7 @@ class ModelRegistry:
         # Hardcoded rules for now; can be extended or loaded from config later.
         # The order of patterns matters: first match wins.
         self._provider_patterns: dict[ProviderType, tuple[str, ...]] = {
-            "openai": ("gpt", "gpt-5"),
+            "openai": ("gpt", "gpt-5", "gpt-5-mini", "gpt-5.1"),
             "gemini": ("gemini", "gemini-3"),
             "deepseek": ("deepseek",),
             "xai": ("grok", "grok-1", "grok-beta"),
@@ -72,6 +72,57 @@ class ModelRegistry:
 
         return "unknown"
 
+    def get_request_defaults(self, model: str) -> dict:
+        """
+        Return per-model request defaults to keep model-specific policy centralized.
+
+        Notes:
+        - This should only include keys that are supported by the target provider.
+        - Callers should merge these defaults with user-provided params (do not mutate inputs).
+        """
+        model_lower = (model or "").lower()
+        provider = self.get_provider(model_lower)
+
+        # Conservative defaults: do not send provider-specific knobs unless we know they are supported.
+        defaults = {"text": {}, "reasoning": {}}
+
+        # OpenAI/xAI (OpenAI-compatible) support 'text.verbosity' and 'reasoning.effort' in our current integration.
+        if provider in ("openai", "xai"):
+            defaults["text"] = {"verbosity": "low"}
+
+            # Fine-grained per-model tuning.
+            if model_lower in ("gpt-5", "gpt-5-mini"):
+                defaults["reasoning"] = {"effort": "minimal"}
+            elif model_lower == "gpt-5.1":
+                defaults["reasoning"] = {"effort": "low", "summary": "auto"}
+
+        # Gemini/DeepSeek/unknown: keep defaults empty to avoid sending unsupported parameters.
+        return defaults
+
+    def resolve_request_params(self, model: str, text: dict | None = None, reasoning: dict | None = None) -> dict:
+        """
+        Resolve provider/model defaults and merge them with caller-provided overrides.
+
+        Rules:
+        - Defaults come from get_request_defaults(model).
+        - Caller overrides win over defaults.
+        - Input dictionaries are never mutated.
+        """
+        defaults = self.get_request_defaults(model)
+
+        merged_text: dict = {}
+        merged_text.update(defaults.get("text") or {})
+        merged_text.update(text or {})
+
+        merged_reasoning: dict = {}
+        merged_reasoning.update(defaults.get("reasoning") or {})
+        merged_reasoning.update(reasoning or {})
+
+        return {
+            "text": merged_text,
+            "reasoning": merged_reasoning,
+        }
+
     def get_history_type(self, model: str) -> HistoryType:
         """
         Returns the history strategy for a given model.

{iatoolkit-0.95.4 → iatoolkit-0.108.1}/src/iatoolkit/common/routes.py

@@ -24,10 +24,13 @@ def register_views(app):
     from iatoolkit.views.profile_api_view import UserLanguageApiView
     from iatoolkit.views.embedding_api_view import EmbeddingApiView
     from iatoolkit.views.login_view import LoginView, FinalizeContextView
+    from iatoolkit.views.load_company_configuration_api_view import LoadCompanyConfigurationApiView
     from iatoolkit.views.logout_api_view import LogoutApiView
     from iatoolkit.views.home_view import HomeView
+    from iatoolkit.views.chat_view import ChatView
     from iatoolkit.views.static_page_view import StaticPageView
     from iatoolkit.views.root_redirect_view import RootRedirectView
+    from iatoolkit.views.users_api_view import UsersApiView
 
     # assign root '/' to our new redirect logic
     app.add_url_rule('/home', view_func=RootRedirectView.as_view('root_redirect'))
@@ -38,6 +41,10 @@ def register_views(app):
     # login for the iatoolkit integrated frontend
     app.add_url_rule('/<company_short_name>/login', view_func=LoginView.as_view('login'))
 
+    # Chat Route (Direct Access)
+    app.add_url_rule('/<company_short_name>/chat',
+                     view_func=ChatView.as_view('chat'))
+
     # this endpoint is called when onboarding_shell finish the context load
     app.add_url_rule(
         '/<company_short_name>/finalize',
@@ -68,6 +75,10 @@ def register_views(app):
     app.add_url_rule('/<company_short_name>/verify/<token>', view_func=VerifyAccountView.as_view('verify_account'))
     app.add_url_rule('/<company_short_name>/forgot-password', view_func=ForgotPasswordView.as_view('forgot_password'))
     app.add_url_rule('/<company_short_name>/change-password/<token>', view_func=ChangePasswordView.as_view('change_password'))
+    app.add_url_rule(
+        '/<string:company_short_name>/api/company-users',
+        view_func=UsersApiView.as_view('company-users')
+    )
 
     # main chat query, used by the JS in the browser (with credentials)
     # can be used also for executing iatoolkit prompts
@@ -88,6 +99,10 @@ def register_views(app):
     app.add_url_rule('/<company_short_name>/api/embedding',
                      view_func=EmbeddingApiView.as_view('embedding_api'))
 
+    # company configuration
+    app.add_url_rule('/<company_short_name>/api/load_configuration',
+                     view_func=LoadCompanyConfigurationApiView.as_view('load-configuration'))
+
     # static pages
     # url: /pages/foundation o /pages/implementation_plan
     static_view = StaticPageView.as_view('static_pages')

{iatoolkit-0.95.4 → iatoolkit-0.108.1}/src/iatoolkit/common/util.py

@@ -157,6 +157,17 @@ class Utility:
             schema = yaml.safe_load(f)
         return schema
 
+    def load_yaml_from_string(self, yaml_content: str) -> dict:
+        """
+        Parses a YAML string into a dictionary securely.
+        """
+        try:
+            yaml_content = yaml_content.replace('\t', '  ')
+            return yaml.safe_load(yaml_content) or {}
+        except yaml.YAMLError as e:
+            logging.error(f"Error parsing YAML string: {e}")
+            return {}
+
     def generate_context_for_schema(self, entity_name: str, schema_file: str = None, schema: dict = {}) -> str:
         if not schema_file and not schema:
             raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,

{iatoolkit-0.95.4 → iatoolkit-0.108.1}/src/iatoolkit/company_registry.py

@@ -6,6 +6,7 @@
 from typing import Dict, Type, Any, Optional
 from .base_company import BaseCompany
 import logging
+from injector import inject
 
 
 class CompanyRegistry:
@@ -14,6 +15,7 @@ class CompanyRegistry:
     Allow the client to register companies and instantiate them with dependency injection.
     """
 
+    @inject
     def __init__(self):
         self._company_classes: Dict[str, Type[BaseCompany]] = {}
         self._company_instances: Dict[str, BaseCompany] = {}
@@ -85,6 +87,9 @@ def get_company_registry() -> CompanyRegistry:
     """Get the global company registry instance."""
     return _company_registry
 
+def get_registered_companies() -> Dict[str, Type[BaseCompany]]:
+    return _company_registry.get_registered_companies()
+
 
 def set_company_registry(registry: CompanyRegistry) -> None:
     """

{iatoolkit-0.95.4 → iatoolkit-0.108.1}/src/iatoolkit/core.py

@@ -9,20 +9,26 @@ from flask_injector import FlaskInjector
 from flask_bcrypt import Bcrypt
 from flask_cors import CORS
 from iatoolkit.common.exceptions import IAToolkitException
-from typing import Optional, Dict, Any
 from iatoolkit.repositories.database_manager import DatabaseManager
+from iatoolkit.common.interfaces.asset_storage import AssetRepository
+from iatoolkit.company_registry import get_registered_companies
 from werkzeug.middleware.proxy_fix import ProxyFix
 from injector import Binder, Injector, singleton
+from typing import Optional, Dict, Any
 from urllib.parse import urlparse
 import redis
 import logging
 import os
 
 from iatoolkit import __version__ as IATOOLKIT_VERSION
+from iatoolkit.services.configuration_service import ConfigurationService
 
 # global variable for the unique instance of IAToolkit
 _iatoolkit_instance: Optional['IAToolkit'] = None
 
+def is_bound(injector: Injector, cls) -> bool:
+    return cls in injector.binder._bindings
+
 class IAToolkit:
     """
     IAToolkit main class
@@ -49,8 +55,8 @@ class IAToolkit:
         self.config = config or {}
         self.app = None
         self.db_manager = None
-        self._injector = None
-        self.version = IATOOLKIT_VERSION    # default version
+        self._injector = Injector()         # init empty injector
+        self.version = IATOOLKIT_VERSION
         self.license = "Community Edition"
 
     @classmethod
@@ -61,7 +67,7 @@ class IAToolkit:
             _iatoolkit_instance = cls()
         return _iatoolkit_instance
 
-    def create_iatoolkit(self):
+    def create_iatoolkit(self, start: bool = True):
         """
             Creates, configures, and returns the Flask application instance.
             this is the main entry point for the application factory.
@@ -77,8 +83,8 @@ class IAToolkit:
         # Step 2: Set up the core components that DI depends on
         self._setup_database()
 
-        # Step 3: Create the Injector and configure all dependencies in one place
-        self._injector = Injector(self._configure_core_dependencies)
+        # Step 3: Configure dependencies using the existing injector
+        self._configure_core_dependencies(self._injector)
 
         # Step 4: Register routes using the fully configured injector
         self._register_routes()
@@ -98,6 +104,7 @@ class IAToolkit:
 
         # Step 8: Finalize setup within the application context
         self._setup_redis_sessions()
+
         self._setup_cors()
         self._setup_additional_services()
         self._setup_cli_commands()
@@ -107,11 +114,21 @@ class IAToolkit:
         # Step 9: define the download_dir
         self._setup_download_dir()
 
+        # register data source
+        if start:
+            self.register_data_sources()
+
         logging.info(f"🎉 IAToolkit {self.license} version {self.version} correctly initialized.")
         self._initialized = True
 
         return self.app
 
+    def register_data_sources(self):
+        # load the company configurations
+        configuration_service = self._injector.get(ConfigurationService)
+        for company in get_registered_companies():
+            configuration_service.register_data_sources(company)
+
     def _get_config_value(self, key: str, default=None):
         # get a value from the config dict or the environment variable
         return self.config.get(key, os.getenv(key, default))
@@ -181,11 +198,11 @@ class IAToolkit:
             os.environ["TOKENIZERS_PARALLELISM"] = "false"
 
     def _setup_database(self):
-        database_uri = self._get_config_value('DATABASE_URI')
+        database_uri = self._get_config_value('DATABASE_URI') or self._get_config_value('DATABASE_URL')
         if not database_uri:
             raise IAToolkitException(
                 IAToolkitException.ErrorType.CONFIG_ERROR,
-                "DATABASE_URI is requires (config dict or env. variable)"
+                "DATABASE_URI is required (config dict or env. variable)"
             )
 
         self.db_manager = DatabaseManager(database_url=database_uri, schema='iatoolkit')
@@ -240,8 +257,9 @@ class IAToolkit:
         extra_origins = []
         all_company_instances = get_company_registry().get_all_company_instances()
         for company_name, company_instance in all_company_instances.items():
-            cors_origin = company_instance.company.parameters.get('cors_origin', [])
-            extra_origins += cors_origin
+            if company_instance.company:
+                cors_origin = company_instance.company.parameters.get('cors_origin', [])
+                extra_origins += cors_origin
 
         all_origins = default_origins + extra_origins
 
@@ -256,8 +274,11 @@ class IAToolkit:
 
         logging.info(f"✅ CORS configured for: {all_origins}")
 
-    def _configure_core_dependencies(self, binder: Binder):
+    def _configure_core_dependencies(self, injector: Injector):
         """⚙️ Configures all system dependencies."""
+
+        # get the binder from injector
+        binder = injector.binder
         try:
             # Core dependencies
             binder.bind(Flask, to=self.app)
@@ -282,12 +303,17 @@ class IAToolkit:
         from iatoolkit.repositories.profile_repo import ProfileRepo
         from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
         from iatoolkit.repositories.vs_repo import VSRepo
+        from iatoolkit.repositories.filesystem_asset_repository import FileSystemAssetRepository
 
         binder.bind(DocumentRepo, to=DocumentRepo)
         binder.bind(ProfileRepo, to=ProfileRepo)
         binder.bind(LLMQueryRepo, to=LLMQueryRepo)
         binder.bind(VSRepo, to=VSRepo)
 
+        # this class can be setup befor by iatoolkit enterprise
+        if not is_bound(self._injector, AssetRepository):
+            binder.bind(AssetRepository, to=FileSystemAssetRepository)
+
     def _bind_services(self, binder: Binder):
         from iatoolkit.services.query_service import QueryService
         from iatoolkit.services.benchmark_service import BenchmarkService
@@ -308,7 +334,7 @@ class IAToolkit:
         from iatoolkit.services.tool_service import ToolService
         from iatoolkit.services.llm_client_service import llmClient
         from iatoolkit.services.auth_service import AuthService
-
+        from iatoolkit.services.sql_service import SqlService
 
         binder.bind(QueryService, to=QueryService)
         binder.bind(BenchmarkService, to=BenchmarkService)
@@ -329,6 +355,7 @@ class IAToolkit:
         binder.bind(ToolService, to=ToolService)
         binder.bind(llmClient, to=llmClient)
         binder.bind(AuthService, to=AuthService)
+        binder.bind(SqlService, to=SqlService)
 
     def _bind_infrastructure(self, binder: Binder):
         from iatoolkit.infra.llm_proxy import LLMProxy
@@ -405,11 +432,13 @@ class IAToolkit:
                 'app_name': 'IAToolkit',
                 'user_identifier': SessionManager.get('user_identifier'),
                 'company_short_name': SessionManager.get('company_short_name'),
+                'user_role': user_profile.get('user_role'),
                 'user_is_local': user_profile.get('user_is_local'),
                 'user_email': user_profile.get('user_email'),
                 'iatoolkit_base_url': request.url_root,
                 'flashed_messages': get_flashed_messages(with_categories=True),
-                't': translate_for_template
+                't': translate_for_template,
+                'google_analytics_id': self._get_config_value('GOOGLE_ANALYTICS_ID', ''),
             }
 
     def _get_default_static_folder(self) -> str:
@@ -473,6 +502,7 @@ class IAToolkit:
         logging.info(f"✅ download dir created in: {download_dir}")
 
 
+
 def current_iatoolkit() -> IAToolkit:
     return IAToolkit.get_instance()
 

{iatoolkit-0.95.4 → iatoolkit-0.108.1}/src/iatoolkit/infra/llm_providers/deepseek_adapter.py

@@ -9,7 +9,7 @@ from typing import Dict, List, Optional, Any
 
 from iatoolkit.infra.llm_response import LLMResponse, ToolCall, Usage
 from iatoolkit.common.exceptions import IAToolkitException
-
+import json
 
 class DeepseekAdapter:
     """
@@ -85,6 +85,7 @@ class DeepseekAdapter:
             if tool_choice:
                 call_kwargs["tool_choice"] = tool_choice
 
+            logging.debug(f"[DeepseekAdapter] Calling DeepSeek chat.completions API...: {json.dumps(messages, indent=2)}")
             response = self.client.chat.completions.create(**call_kwargs)
 
             return self._map_deepseek_chat_response(response)
@@ -127,7 +128,7 @@ class DeepseekAdapter:
 
                 messages.append(
                     {
-                        "role": "assistant",
+                        "role": "user",
                         "content": f"Tool result:\n{output}",
                     }
                 )
@@ -141,10 +142,6 @@ class DeepseekAdapter:
                 logging.warning(f"[DeepseekAdapter] Skipping tool-role message: {item}")
                 continue
 
-            # Map internal 'model' role to 'assistant'
-            if role == "model":
-                role = "assistant"
-
             if not role:
                 logging.warning(f"[DeepseekAdapter] Skipping message without role: {item}")
                 continue
@@ -230,13 +227,19 @@ class DeepseekAdapter:
             total_tokens=getattr(getattr(response, "usage", None), "total_tokens", 0) or 0,
         )
 
+        # Capture reasoning content (specific to deepseek-reasoner)
+        reasoning_content = getattr(message, "reasoning_content", "") or ""
+
+        # If the model produced tool calls, fills this list
         tool_calls_out: List[ToolCall] = []
-        status = "completed"
-        output_text = ""
 
-        # If the model produced tool calls:
         tool_calls = getattr(message, "tool_calls", None) or []
-        if tool_calls:
+        if not tool_calls:
+            # No tool calls: standard assistant message
+            output_text = getattr(message, "content", "") or ""
+            status = "completed"
+
+        else:
             logging.debug(f"[DeepSeek] RAW tool_calls: {tool_calls}")
 
             for tc in tool_calls:
@@ -264,11 +267,6 @@ class DeepseekAdapter:
             status = "tool_calls"
             output_text = ""  # caller will inspect tool_calls in .output
 
-        else:
-            # No tool calls: standard assistant message
-            output_text = getattr(message, "content", "") or ""
-            status = "completed"
-
         return LLMResponse(
             id=getattr(response, "id", "deepseek-unknown"),
             model=getattr(response, "model", "deepseek-unknown"),
@@ -276,4 +274,5 @@ class DeepseekAdapter:
             output_text=output_text,
             output=tool_calls_out,
             usage=usage,
+            reasoning_content=reasoning_content
         )

{iatoolkit-0.95.4 → iatoolkit-0.108.1}/src/iatoolkit/infra/llm_providers/openai_adapter.py

@@ -7,7 +7,8 @@ import logging
 from typing import Dict, List, Optional
 from iatoolkit.infra.llm_response import LLMResponse, ToolCall, Usage
 from iatoolkit.common.exceptions import IAToolkitException
-
+import html
+from typing import List
 
 class OpenAIAdapter:
     """Adaptador para la API de OpenAI"""
@@ -76,11 +77,48 @@ class OpenAIAdapter:
             total_tokens=openai_response.usage.total_tokens if openai_response.usage else 0
         )
 
+        # Reasoning content extracted from Responses output items (type="reasoning")
+        reasoning_list = self._extract_reasoning_content(openai_response)
+        reasoning_str = "\n".join(reasoning_list)
+
         return LLMResponse(
             id=openai_response.id,
             model=openai_response.model,
             status=openai_response.status,
             output_text=getattr(openai_response, 'output_text', ''),
             output=tool_calls,
-            usage=usage
-        )
+            usage=usage,
+            reasoning_content=reasoning_str
+        )
+
+    def _extract_reasoning_content(self, openai_response) -> List[str]:
+        """
+        Extract reasoning summaries (preferred) or reasoning content fragments from Responses API output.
+
+        Format required by caller:
+          1. reason is ...
+          2. reason is ...
+        """
+        reasons: List[str] = []
+
+        output_items = getattr(openai_response, "output", None) or []
+        for item in output_items:
+            if getattr(item, "type", None) != "reasoning":
+                continue
+
+            # 1) Preferred: reasoning summaries (requires reasoning={"summary":"auto"} or similar)
+            summary = getattr(item, "summary", None) or []
+            for s in summary:
+                text = getattr(s, "text", None)
+                if text:
+                    reasons.append(str(text).strip())
+
+            # 2) Fallback: some responses may carry reasoning content in "content"
+            # (e.g., content parts like {"type":"reasoning_text","text":"..."}).
+            content = getattr(item, "content", None) or []
+            for c in content:
+                text = getattr(c, "text", None)
+                if text:
+                    reasons.append(str(text).strip())
+
+        return reasons

{iatoolkit-0.95.4 → iatoolkit-0.108.1}/src/iatoolkit/infra/llm_response.py

@@ -32,9 +32,14 @@ class LLMResponse:
     output_text: str
     output: List[ToolCall]  # lista de tool calls
     usage: Usage
+    reasoning_content: str = None # campo opcional para Chain of Thought
+
 
     def __post_init__(self):
         """Asegura que output sea una lista"""
         if self.output is None:
             self.output = []
 
+        if self.reasoning_content is None:
+            self.reasoning_content = ""
+