iatoolkit 2.73.8__tar.gz → 2.74.1__tar.gz

{iatoolkit-2.73.8/src/iatoolkit.egg-info → iatoolkit-2.74.1}/PKG-INFO

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

{iatoolkit-2.73.8 → iatoolkit-2.74.1}/src/iatoolkit/__init__.py

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

iatoolkit-2.74.1/src/iatoolkit/common/interfaces/history_compaction_trigger.py

@@ -0,0 +1,21 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+
+class HistoryCompactionTrigger(ABC):
+    """Asks for a conversation history to be compacted in the background (BL-009).
+
+    The core has no task queue, so its default does nothing and a history is
+    compacted in line, on the turn that would no longer fit. A deployment with
+    workers (enterprise) binds one that queues the work instead.
+    """
+
+    @abstractmethod
+    def trigger(self, company_short_name: str, user_identifier: str, model: str) -> bool:
+        """Queues the compaction. True when something was queued or already was."""

{iatoolkit-2.73.8 → iatoolkit-2.74.1}/src/iatoolkit/common/model_registry.py

@@ -15,17 +15,9 @@ from injector import inject, singleton
 from typing import Literal
 
 
-HistoryType = Literal["server_side", "client_side"]
 ProviderType = Literal["openai", "gemini", "deepseek", "xai", "anthropic", "openrouter", "openai_compatible", "unknown"]
 
 
-@dataclass(frozen=True)
-class ModelMetadata:
-    """Static metadata for a logical family of models."""
-    provider: ProviderType
-    history_type: HistoryType
-
-
 #: Providers a model can actually be served by: the ones `LLMProxy._build_adapter`
 #: knows how to build. Deliberately narrower than `ProviderType`, which also
 #: contains `xai` — `normalize_provider` accepts it and a client is built for it,
@@ -118,7 +110,6 @@ class ModelRegistry:
 
     Responsibilities:
     - Map a model name to its provider (openai, gemini, deepseek, etc.).
-    - Decide which history strategy to use for a model (server_side / client_side).
     - Provide convenience helpers (is_openai, is_gemini, is_deepseek, etc.).
     """
 
@@ -174,30 +165,66 @@ class ModelRegistry:
             return candidate  # type: ignore[return-value]
         return self.get_provider(model or "")
 
-    def get_capabilities(self, model: str, provider: str | None = None) -> dict:
+    @staticmethod
+    def catalog_capabilities(model_config: dict | None) -> dict | None:
+        """The capabilities the model catalogue holds for a model, or None when unknown.
+
+        Written by `models-sync` from OpenRouter (BL-009, Fase F) and carried in
+        the model's configuration. Empty, or a company.yaml model outside the
+        catalogue, means unknown: the provider's rules decide.
+        """
+        capabilities = (model_config or {}).get("capabilities") if isinstance(model_config, dict) else None
+        if not isinstance(capabilities, dict):
+            return None
+        if not capabilities.get("supported_parameters") and not capabilities.get("input_modalities"):
+            return None
+        return capabilities
+
+    @staticmethod
+    def _declares(capabilities: dict | None, *parameters: str) -> bool | None:
+        """Whether the model declares any of `parameters`; None when nothing is known."""
+        if not capabilities:
+            return None
+        declared = {str(value).strip().lower() for value in capabilities.get("supported_parameters") or []}
+        if not declared:
+            return None
+        return any(parameter in declared for parameter in parameters)
+
+    def get_capabilities(self, model: str, provider: str | None = None, capabilities: dict | None = None) -> dict:
+        """What the request may carry for this model.
+
+        Two halves, both required: what the provider's adapter knows how to send,
+        and what the model accepts. The second comes from the model catalogue
+        (`capabilities`) when it is known; without it, the provider decides alone.
+        The catalogue only ever narrows: a parameter the adapter cannot send is
+        never offered because the model would accept it.
+        """
         normalized_provider = self.normalize_provider(provider=provider, model=model)
         # `openai_compatible` is absent on purpose. Its adapter targets any server
         # that speaks chat.completions — llama.cpp, vLLM, a private gateway — and
         # forwards no reasoning field, because one the server does not know earns a
         # 400. Claiming the capability here made the tenant's Models page offer a
         # reasoning control whose value went nowhere.
-        supports_reasoning_effort = normalized_provider in {
+        adapter_sends_reasoning = normalized_provider in {
             "openai",
             "xai",
             "openrouter",
             "deepseek",
         }
-        supports_text_verbosity = normalized_provider in {"openai", "xai", "openrouter"}
-        supports_store = normalized_provider in {"openai", "xai"}
+        adapter_sends_verbosity = normalized_provider in {"openai", "xai", "openrouter"}
+
+        model_reasons = self._declares(capabilities, "reasoning", "reasoning_effort")
+        model_takes_verbosity = self._declares(capabilities, "verbosity")
+        supports_reasoning_effort = adapter_sends_reasoning and model_reasons is not False
+        supports_text_verbosity = adapter_sends_verbosity and model_takes_verbosity is not False
 
         return {
             "provider": normalized_provider,
-            "history_type": self.get_history_type(model),
             "supports_reasoning_effort": supports_reasoning_effort,
             "allowed_reasoning_efforts": list(self._reasoning_effort_options) if supports_reasoning_effort else [],
             "supports_text_verbosity": supports_text_verbosity,
             "allowed_text_verbosity": list(self._text_verbosity_options) if supports_text_verbosity else [],
-            "supports_store": supports_store,
+            "capabilities_source": "catalog" if model_reasons is not None else "provider",
         }
 
     def get_request_defaults(self, model: str) -> dict:
@@ -246,22 +273,6 @@ class ModelRegistry:
             "reasoning": merged_reasoning,
         }
 
-    def get_history_type(self, model: str) -> HistoryType:
-        """
-        Returns the history strategy for a given model.
-
-        Current rules:
-        - openai/xai: server_side (API manages conversation state via ids)
-        - gemini/deepseek/anthropic/unknown: client_side (we manage full message history)
-        """
-        provider = self.get_provider(model)
-
-        if provider in ("openai", "xai"):
-            return "server_side"
-
-        # Default for gemini, deepseek, anthropic and any unknown provider
-        return "client_side"
-
     # ------------------------------------------------------------------
     # Convenience helpers (used during migration)
     # ------------------------------------------------------------------

iatoolkit-2.74.1/src/iatoolkit/config/system_agents/history_compaction.prompt

@@ -0,0 +1,24 @@
+You compact the older part of a conversation between a person and a company's AI assistant. The conversation is too long for the model's context, so the turns below will be replaced by your summary; the most recent turns stay as they are. The assistant will continue the conversation from your summary alone, so anything you leave out is lost.
+
+Write the summary in the language of the conversation, as Markdown, with these sections (omit a section only when there is nothing for it):
+
+- **Objective**: what the person is trying to achieve, and how it evolved.
+- **Decisions**: what was agreed, chosen or ruled out, and why when it was said.
+- **Data obtained**: the concrete facts the assistant found or computed with its tools — figures, dates, names, identifiers, table names, SQL that worked, document titles, URLs. Keep exact values; never round or paraphrase a number.
+- **Pending**: questions still open and what the person asked for that is not done yet.
+- **Preferences**: how the person wants to be answered (format, language, level of detail, things to avoid).
+
+Rules:
+
+- Keep facts, drop chatter. Do not repeat the same fact twice.
+- Attribute statements correctly: what the person said is not what the assistant concluded.
+- Do not add information that is not in the turns or in the previous summary.
+- When a previous summary is given, merge it with the new turns into one summary: keep what is still true, update what changed, and drop what was superseded.
+
+Return the summary in `summary`.
+
+PREVIOUS SUMMARY:
+{{ previous_summary or "(none)" }}
+
+TURNS TO COMPACT:
+{{ transcript }}

{iatoolkit-2.73.8 → iatoolkit-2.74.1}/src/iatoolkit/config/system_agents_pack.yaml

@@ -312,3 +312,25 @@ agents:
       additionalProperties: false
     inputs: [source, captured_on, wiki_schema, page_index, candidate_pages]
     default_model: null
+
+  - key: history_compaction
+    name: Compactación del historial
+    name_en: History compaction
+    description: >-
+      (Chat) Resume la parte antigua de una conversación larga cuando se acerca al límite de contexto del
+      modelo, para que la conversación siga sin perder lo importante.
+    description_en: >-
+      (Chat) Summarizes the older part of a long conversation when it nears the model's context limit,
+      so the conversation can go on without losing what matters.
+    module: chat
+    prompt: history_compaction.prompt
+    output_schema:
+      type: object
+      properties:
+        summary:
+          type: string
+      required: [summary]
+      additionalProperties: false
+    inputs: [previous_summary, transcript]
+    default_model: null
+

{iatoolkit-2.73.8 → iatoolkit-2.74.1}/src/iatoolkit/core.py

@@ -408,6 +408,8 @@ class IAToolkit:
         from iatoolkit.repositories.env_secret_provider import EnvSecretProvider
         from iatoolkit.common.interfaces.memory_compilation_trigger import MemoryCompilationTrigger
         from iatoolkit.services.noop_memory_compilation_trigger import NoopMemoryCompilationTrigger
+        from iatoolkit.common.interfaces.history_compaction_trigger import HistoryCompactionTrigger
+        from iatoolkit.services.noop_history_compaction_trigger import NoopHistoryCompactionTrigger
         from iatoolkit.services.memory_lookup_policy_service import MemoryLookupPolicyService
 
         binder.bind(ApiKeyRepo, to=ApiKeyRepo)
@@ -430,6 +432,8 @@ class IAToolkit:
             binder.bind(SecretProvider, to=EnvSecretProvider)
         if not is_bound(self._injector, MemoryCompilationTrigger):
             binder.bind(MemoryCompilationTrigger, to=NoopMemoryCompilationTrigger)
+        if not is_bound(self._injector, HistoryCompactionTrigger):
+            binder.bind(HistoryCompactionTrigger, to=NoopHistoryCompactionTrigger)
         binder.bind(MemoryLookupPolicyService, to=MemoryLookupPolicyService)
 
     def _bind_services(self, binder: Binder):

{iatoolkit-2.73.8 → iatoolkit-2.74.1}/src/iatoolkit/infra/llm_providers/anthropic_adapter.py

@@ -24,7 +24,6 @@ class AnthropicAdapter:
     def create_response(self,
                         model: str,
                         input: List[Dict],
-                        previous_response_id: Optional[str] = None,
                         context_history: Optional[List[Dict]] = None,
                         tools: Optional[List[Dict]] = None,
                         text: Optional[Dict] = None,
@@ -39,10 +38,9 @@ class AnthropicAdapter:
         Calls Anthropic Messages API and maps the response to common LLMResponse.
 
         Notes:
-        - Anthropic is integrated as client-side history, so previous_response_id is ignored.
+        - Anthropic receives the whole client-side history on every call.
         - reasoning is currently not sent as a provider-specific parameter.
         """
-        _ = previous_response_id
         _ = reasoning
         _ = attachments
         _ = store

{iatoolkit-2.73.8 → iatoolkit-2.74.1}/src/iatoolkit/infra/llm_providers/gemini_adapter.py

@@ -43,7 +43,6 @@ class GeminiAdapter:
     def create_response(self,
                         model: str,
                         input: List[Dict],
-                        previous_response_id: Optional[str] = None,
                         context_history: Optional[List[Dict]] = None,
                         tools: Optional[List[Dict]] = None,
                         text: Optional[Dict] = None,

{iatoolkit-2.73.8 → iatoolkit-2.74.1}/src/iatoolkit/infra/llm_providers/openai_adapter.py

@@ -18,10 +18,15 @@ class OpenAIAdapter:
     def __init__(self, openai_client):
         self.client = openai_client
 
+    #: Reasoning models whose reasoning can travel between calls as encrypted
+    #: items, for a model the catalogue does not describe: a model without
+    #: reasoning answers the `include` with a 400. When the catalogue knows the
+    #: model, the proxy says so (`carries_reasoning`) and this list is not read.
+    _ENCRYPTED_REASONING_MODEL_PREFIXES = ("gpt-5", "o1", "o3", "o4")
+
     def create_response(self,
                         model: str,
                         input: List[Dict],
-                        previous_response_id: Optional[str] = None,
                         context_history: Optional[List[Dict]] = None,
                         tools: Optional[List[Dict]] = None,
                         text: Optional[Dict] = None,
@@ -31,12 +36,19 @@ class OpenAIAdapter:
                         attachments: Optional[List[Dict]] = None,
                         store: Optional[bool] = None,
                         metadata: Optional[Dict[str, str]] = None,
-                        telemetry_execution: Any = None) -> LLMResponse:
-        """Llamada a la API de OpenAI y mapeo a estructura común"""
+                        telemetry_execution: Any = None,
+                        carries_reasoning: Optional[bool] = None) -> LLMResponse:
+        """Llamada a la API de OpenAI y mapeo a estructura común.
+
+        IAToolkit owns the history (BL-009): every call carries the whole
+        conversation and nothing is kept at OpenAI. `store` is always False,
+        whatever a prompt or company.yaml still declares; it is accepted only so
+        configurations that set it keep loading.
+        """
+        _ = store
         try:
             input = self._normalize_input_items(
                 input_items=input,
-                previous_response_id=previous_response_id,
                 context_history=context_history,
             )
 
@@ -50,16 +62,18 @@ class OpenAIAdapter:
                 'input': input
             }
 
-            if previous_response_id:
-                params['previous_response_id'] = previous_response_id
+            # Nothing stays at OpenAI: the next call sends the history again.
+            params['store'] = False
+            if self._carries_encrypted_reasoning(model, carries_reasoning):
+                # Without a stored response the model would lose its reasoning
+                # between tool rounds; it comes back encrypted and is sent again.
+                params['include'] = ["reasoning.encrypted_content"]
             if tools:
                 params['tools'] = tools
             if text:
                 params['text'] = text
             if reasoning:
                 params['reasoning'] = reasoning
-            if store is not None:
-                params['store'] = store
             if metadata:
                 params['metadata'] = metadata
             tool_choice_payload = self._map_tool_choice(tool_choice, tools or [])
@@ -80,36 +94,36 @@ class OpenAIAdapter:
 
             raise IAToolkitException(IAToolkitException.ErrorType.LLM_ERROR, error_message)
 
+    @classmethod
+    def _carries_encrypted_reasoning(cls, model: str, carries_reasoning: Optional[bool] = None) -> bool:
+        if carries_reasoning is not None:
+            return carries_reasoning
+        name = str(model or "").strip().lower()
+        if "-chat" in name:
+            return False  # gpt-5-chat-latest and the like do not reason
+        return name.startswith(cls._ENCRYPTED_REASONING_MODEL_PREFIXES)
+
     def _normalize_input_items(
         self,
         input_items: Optional[List[Dict]],
-        previous_response_id: Optional[str] = None,
         context_history: Optional[List[Dict]] = None,
     ) -> List[Dict[str, Any]]:
         """
         Normalize our internal history format to the subset accepted by Responses API.
 
+        The client-side history comes first, then the items of the current call.
+
         Important cases:
         - Assistant messages with `tool_calls` must become top-level `function_call` items.
+        - An assistant message's encrypted reasoning items go back in front of its
+          own message and calls, the order OpenAI produced them in.
         - `function_call_output` items must not include internal-only fields such as `status`.
-        - Without `previous_response_id`, include client-side `context_history` before
-          the current turn so OpenAI can run from locally managed history if needed.
-        - When continuing from a prior response with `previous_response_id`, tool follow-ups
-          should only append the `function_call_output` items because the previous response
-          already contains the originating user/assistant turns on OpenAI's side.
         """
         combined_input: List[Dict[str, Any]] = []
-        if not previous_response_id:
-            combined_input.extend(context_history or [])
+        combined_input.extend(context_history or [])
         combined_input.extend(input_items or [])
 
-        has_function_outputs = any(
-            isinstance(item, dict) and item.get("type") == "function_call_output"
-            for item in combined_input
-        )
-
         normalized_items: List[Dict[str, Any]] = []
-        function_output_items: List[Dict[str, Any]] = []
 
         for item in combined_input:
             if not isinstance(item, dict):
@@ -121,13 +135,17 @@ class OpenAIAdapter:
                 if not call_id:
                     continue
 
-                normalized_output = {
+                normalized_items.append({
                     "type": "function_call_output",
                     "call_id": call_id,
                     "output": item.get("output", ""),
-                }
-                normalized_items.append(normalized_output)
-                function_output_items.append(normalized_output)
+                })
+                continue
+
+            if item_type == "reasoning":
+                reasoning_item = self._normalize_reasoning_item(item)
+                if reasoning_item:
+                    normalized_items.append(reasoning_item)
                 continue
 
             if item_type == "function_call":
@@ -139,6 +157,8 @@ class OpenAIAdapter:
                 role = "assistant"
 
             content = item.get("content")
+            if role == "assistant":
+                normalized_items.extend(self._reasoning_items_from(item.get("reasoning_details")))
             tool_calls = self._normalize_tool_call_items(item.get("tool_calls"))
             if tool_calls:
                 if role == "assistant" and content not in (None, "", []):
@@ -155,22 +175,41 @@ class OpenAIAdapter:
                     "content": content,
                 })
 
-        if previous_response_id and has_function_outputs and function_output_items:
-            # Only the outputs answering the previous response's calls. The tool loop
-            # keeps every round's outputs in its input (client-side providers need
-            # them), and they come last; earlier rounds are already in the chain
-            # `previous_response_id` points to. Sending them all again repeated every
-            # tool result in each following round, so the context grew quadratically
-            # and long tool loops hit context_length_exceeded.
-            latest_round: List[Dict[str, Any]] = []
-            for item in reversed(normalized_items):
-                if item.get("type") != "function_call_output":
-                    break
-                latest_round.append(item)
-            return list(reversed(latest_round)) or function_output_items
-
         return normalized_items
 
+    @classmethod
+    def _reasoning_items_from(cls, reasoning_details: Any) -> List[Dict[str, Any]]:
+        """The OpenAI reasoning items stored with an assistant message, ready to resend.
+
+        `reasoning_details` is shared with other adapters (OpenRouter writes
+        `reasoning.text` blocks there); only items of type `reasoning` carrying
+        encrypted content are OpenAI's and make sense to send back.
+        """
+        if not isinstance(reasoning_details, list):
+            return []
+        items = []
+        for detail in reasoning_details:
+            item = cls._normalize_reasoning_item(detail)
+            if item:
+                items.append(item)
+        return items
+
+    @staticmethod
+    def _normalize_reasoning_item(detail: Any) -> Optional[Dict[str, Any]]:
+        if not isinstance(detail, dict) or detail.get("type") != "reasoning":
+            return None
+        encrypted = detail.get("encrypted_content")
+        if not encrypted:
+            return None
+        item = {
+            "type": "reasoning",
+            "summary": detail.get("summary") if isinstance(detail.get("summary"), list) else [],
+            "encrypted_content": encrypted,
+        }
+        if detail.get("id"):
+            item["id"] = detail["id"]
+        return item
+
     @staticmethod
     def _normalize_tool_call_items(tool_calls: Any) -> List[Dict[str, Any]]:
         normalized_tool_calls: List[Dict[str, Any]] = []
@@ -408,9 +447,32 @@ class OpenAIAdapter:
             output=tool_calls,
             usage=usage,
             reasoning_content=reasoning_str,
+            reasoning_details=self._extract_encrypted_reasoning_items(openai_response) or None,
             content_parts=content_parts
         )
 
+    @staticmethod
+    def _extract_encrypted_reasoning_items(openai_response) -> List[Dict[str, Any]]:
+        """The response's reasoning items that can be sent back on the next call."""
+        items: List[Dict[str, Any]] = []
+        for item in getattr(openai_response, "output", None) or []:
+            if getattr(item, "type", None) != "reasoning":
+                continue
+            encrypted = getattr(item, "encrypted_content", None)
+            if not encrypted:
+                continue
+            summary = []
+            for part in getattr(item, "summary", None) or []:
+                text = getattr(part, "text", None)
+                if text:
+                    summary.append({"type": "summary_text", "text": str(text)})
+            reasoning_item = {"type": "reasoning", "summary": summary, "encrypted_content": encrypted}
+            item_id = getattr(item, "id", None)
+            if item_id:
+                reasoning_item["id"] = item_id
+            items.append(reasoning_item)
+        return items
+
     def _extract_reasoning_content(self, openai_response) -> List[str]:
         """
         Extract reasoning summaries (preferred) or reasoning content fragments from Responses API output.

{iatoolkit-2.73.8 → iatoolkit-2.74.1}/src/iatoolkit/infra/llm_proxy.py

@@ -160,6 +160,12 @@ class LLMProxy:
             provider=provider,
             request_kwargs=request_kwargs,
         )
+        request_kwargs = self._apply_model_capabilities(
+            model=model,
+            provider=provider,
+            model_config=model_config,
+            request_kwargs=request_kwargs,
+        )
         if telemetry_execution is not None:
             request_kwargs["telemetry_execution"] = telemetry_execution
 
@@ -451,6 +457,42 @@ class LLMProxy:
         effective_kwargs["reasoning"] = merged_reasoning
         return effective_kwargs
 
+    def _apply_model_capabilities(
+        self,
+        model: str,
+        provider: str,
+        model_config: Dict[str, Any] | None,
+        request_kwargs: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """Drops the parameters the model itself does not accept (BL-009, Fase F).
+
+        The steps before this one decide by provider: every OpenAI model gets a
+        reasoning effort and a verbosity, which a model that does not reason
+        (gpt-4.1, gpt-5-chat) refuses. When the catalogue knows the model, its
+        `supported_parameters` have the last word. When it does not, nothing
+        changes: the provider's rules stay as they were.
+        """
+        catalog_capabilities = ModelRegistry.catalog_capabilities(model_config)
+        if catalog_capabilities is None:
+            return request_kwargs
+
+        capabilities = self.model_registry.get_capabilities(
+            model, provider=provider, capabilities=catalog_capabilities
+        )
+        effective_kwargs = dict(request_kwargs or {})
+        if not capabilities.get("supports_reasoning_effort"):
+            effective_kwargs.pop("reasoning", None)
+            effective_kwargs.pop("reasoning_effort", None)
+        if not capabilities.get("supports_text_verbosity"):
+            text = effective_kwargs.get("text")
+            if isinstance(text, dict) and "verbosity" in text:
+                effective_kwargs["text"] = {key: value for key, value in text.items() if key != "verbosity"}
+        if provider == self.PROVIDER_OPENAI:
+            # Whether the model's reasoning can travel between calls: the adapter
+            # asks for it only then, instead of guessing from the model's name.
+            effective_kwargs["carries_reasoning"] = bool(capabilities.get("supports_reasoning_effort"))
+        return effective_kwargs
+
     # -------------------------------------------------------------------------
     # Client cache
     # -------------------------------------------------------------------------

{iatoolkit-2.73.8 → iatoolkit-2.74.1}/src/iatoolkit/locales/en.yaml

@@ -2784,7 +2784,6 @@ ui:
   tooltips:
     history: "History of my queries"
     memory: "Company memory"
-    reload_context: "Force Context Reload"
     feedback: "Your feedback is very important"
     usage_guide: "Usage Guide"
     onboarding: "How to ask better questions"
@@ -2897,7 +2896,6 @@ errors:
     file_validation_error: "Error validating file"
     user_not_authorized: "user is not authorized for this company"
     account_not_verified: "Your account has not been verified. Please check your email."
-    missing_response_id: "Can not found 'previous_response_id' for '{company_short_name}/{user_identifier}'. Reinit context"
     context_rebuild_failed: "Company context rebuild failed."
     cannot_read_excel: "Cannot read Excel file"
     cannot_read_csv: "Cannot read CSV file"
@@ -2951,7 +2949,6 @@ js_messages:
   feedback_sent_error: "Could not send feedback, please try again."
   feedback_rating_error: "Please rate the assistant using the stars."
   feedback_comment_error: "Please write your comment before sending."
-  context_reloaded: "Context has been reloaded."
   error_loading_history: "An error occurred while loading the history."
   request_aborted: "The response generation has been stopped."
   processing_error: "An error occurred while processing the request."
@@ -2959,7 +2956,6 @@ js_messages:
   network_error: "A network error occurred. Please try again in a few moments."
   unknown_server_error: "Unknown server error."
   loading: "Loading..."
-  reload_init: "init reloading context in background..."
   no_history_found: "No query history found."
   prompts_available: "Available prompts"
   example: "Example:"

{iatoolkit-2.73.8 → iatoolkit-2.74.1}/src/iatoolkit/locales/es.yaml

@@ -2800,7 +2800,6 @@ ui:
   tooltips:
     history: "Historial con mis consultas"
     memory: "Memoria de la empresa"
-    reload_context: "Forzar Recarga de Contexto"
     feedback: "Tu feedback es muy importante"
     usage_guide: "Guía de Uso"
     onboarding: "Cómo preguntar mejor"
@@ -2916,7 +2915,6 @@ errors:
     file_validation_error : "Error validando archivo"
     user_not_authorized: "Usuario no esta autorizado para esta empresa"
     account_not_verified: "Tu cuenta no ha sido verificada. Por favor, revisa tu correo."
-    missing_response_id: "No se encontró 'previous_response_id' para '{company_short_name}/{user_identifier}'. Reinicia el contexto."
     context_rebuild_failed: "No se pudo reconstruir el contexto de la empresa."
     cannot_read_excel: "No se pudo leer el archivo excel"
     cannot_read_csv: "No se pudo leer el archivo CSV"
@@ -2970,7 +2968,6 @@ js_messages:
   feedback_sent_error: "No se pudo enviar el feedback, por favor intente nuevamente."
   feedback_rating_error: "Por favor, califica al asistente con las estrellas."
   feedback_comment_error: "Por favor, escribe tu comentario antes de enviar."
-  context_reloaded: "El contexto ha sido recargado."
   error_loading_history: "Ocurrió un error al cargar el historial."
   request_aborted: "La generación de la respuesta ha sido detenida."
   processing_error: "Ocurrió un error al procesar la solicitud."
@@ -2978,7 +2975,6 @@ js_messages:
   network_error: "Ocurrió un error de red. Por favor, inténtalo de nuevo en unos momentos."
   unknown_server_error: "Error desconocido del servidor."
   loading: "Cargando..."
-  reload_init: "Iniciando recarga de contexto en segundo plano..."
   no_history_found: "No existe historial de consultas."
   prompts_available: "Prompts disponibles"
   example: "Ejemplo:"

{iatoolkit-2.73.8 → iatoolkit-2.74.1}/src/iatoolkit/repositories/llm_query_repo.py

@@ -35,17 +35,31 @@ class LLMQueryRepo:
         self.session.commit()
         return query
 
-    @staticmethod
-    def not_context_init():
-        """Filter for rows that are a conversation turn, not a context initialization."""
+    #: iat_queries.prompt_name of the platform's own model calls (system agents,
+    #: see system_agent_catalog.PROMPT_NAME_PREFIX). Restated here because the
+    #: catalog sits above the repositories.
+    SYSTEM_AGENT_PROMPT_PREFIX = "system_agent:"
+
+    @classmethod
+    def conversation_turns_only(cls):
+        """Filter for rows a person asked: not a context initialization, not a system agent run.
+
+        A system agent's execution is billed like any other call, but it is the
+        platform's own work (a memory compilation, a history compaction): shown in
+        a user's history or replayed as a turn, it would read as a question they
+        never asked.
+        """
         request_source = LLMQuery.stats["request_source"].as_string()
-        return or_(request_source.is_(None), request_source != CONTEXT_INIT_REQUEST_SOURCE)
+        return and_(
+            or_(request_source.is_(None), request_source != CONTEXT_INIT_REQUEST_SOURCE),
+            or_(LLMQuery.prompt_name.is_(None), ~LLMQuery.prompt_name.startswith(cls.SYSTEM_AGENT_PROMPT_PREFIX)),
+        )
 
     # get user query history
     def get_history(self, company: Company, user_identifier: str, limit: int = 100) -> list[LLMQuery]:
         return self.session.query(LLMQuery).filter(
             LLMQuery.user_identifier == user_identifier,
-            self.not_context_init(),
+            self.conversation_turns_only(),
         ).filter_by(company_id=company.id).order_by(LLMQuery.created_at.desc()).limit(limit).all()