iatoolkit 2.64.6__tar.gz → 2.65.1__tar.gz

{iatoolkit-2.64.6/src/iatoolkit.egg-info → iatoolkit-2.65.1}/PKG-INFO

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

{iatoolkit-2.64.6 → iatoolkit-2.65.1}/src/iatoolkit/__init__.py

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

{iatoolkit-2.64.6 → iatoolkit-2.65.1}/src/iatoolkit/locales/en.yaml

@@ -55,7 +55,6 @@ ui:
     tab_chats: "Live Chats"
     tab_agents: "Agents"
     tab_logs: "Access Logs"
-    tab_tools: "Tools Router"
     tab_apps: "Apps"
     search_placeholder: "Search user or text..."
     tool_router_config_title: "Router configuration"
@@ -81,6 +80,24 @@ ui:
       tab_overview: "Overview"
       tab_input: "Input / Context"
       tab_response: "Full Response"
+      tab_tools: "Tools"
+      routing_title: "Tool routing"
+      routing_none: "No routing: the run had every tool available."
+      routing_mode: "Mode / Reason"
+      routing_latency: "Selector latency"
+      routing_selection: "Selected / candidates"
+      routing_system_prompts: "System prompts selected"
+      routing_forced_tools: "Always-included system tools"
+      routing_ranked: "Ranked tools"
+      routing_metadata: "Router metadata"
+      tools_summary: "Execution summary"
+      tools_unique: "Unique tools"
+      tools_calls: "Total calls"
+      tools_time: "Tool time"
+      tools_avg: "Avg / call"
+      tools_coverage: "Coverage"
+      tools_coverage_hit: "Selected and executed"
+      tools_coverage_miss: "Selected but not executed"
       session_meta: "Session Metadata"
       user_id: "User Identifier"
       timestamp: "Timestamp"

{iatoolkit-2.64.6 → iatoolkit-2.65.1}/src/iatoolkit/locales/es.yaml

@@ -68,7 +68,6 @@ ui:
     tab_chats: "Chats en Vivo"
     tab_agents: "Agentes"
     tab_logs: "Logs de Acceso"
-    tab_tools: "Router de Herramientas"
     tab_apps: "Apps"
     search_placeholder: "Buscar usuario o texto..."
     tool_router_config_title: "Configuración del router"
@@ -94,6 +93,24 @@ ui:
       tab_overview: "Resumen"
       tab_input: "Entrada / Contexto"
       tab_response: "Respuesta Completa"
+      tab_tools: "Herramientas"
+      routing_title: "Routing de herramientas"
+      routing_none: "Sin routing: la ejecución tuvo todas las herramientas disponibles."
+      routing_mode: "Modo / Motivo"
+      routing_latency: "Latencia del selector"
+      routing_selection: "Seleccionadas / candidatas"
+      routing_system_prompts: "System prompts seleccionados"
+      routing_forced_tools: "Herramientas de sistema siempre incluidas"
+      routing_ranked: "Ranking de herramientas"
+      routing_metadata: "Metadatos del router"
+      tools_summary: "Resumen de ejecución"
+      tools_unique: "Herramientas distintas"
+      tools_calls: "Llamadas totales"
+      tools_time: "Tiempo en herramientas"
+      tools_avg: "Promedio / llamada"
+      tools_coverage: "Cobertura"
+      tools_coverage_hit: "Seleccionadas y ejecutadas"
+      tools_coverage_miss: "Seleccionadas y no ejecutadas"
       session_meta: "Metadatos de Sesión"
       user_id: "Identificador Usuario"
       timestamp: "Fecha/Hora"

{iatoolkit-2.64.6 → iatoolkit-2.65.1}/src/iatoolkit/services/memory_compiler_service.py

@@ -23,7 +23,7 @@ from iatoolkit.repositories.models import Company, MemoryCapture, MemoryCaptureS
 from iatoolkit.repositories.profile_repo import ProfileRepo
 from iatoolkit.services.memory_wiki_service import MemoryWikiService
 from iatoolkit.services.storage_service import StorageService
-from iatoolkit.services.system_agent_runner import SystemAgentRunner
+from iatoolkit.services.system_agent_runner import SystemAgentDisabled, SystemAgentRunner
 from iatoolkit.services.tenant_wiki_service import TenantWikiService
 
 
@@ -85,6 +85,7 @@ class MemoryCompilerService:
 
         compiled_count = 0
         processed_count = 0
+        waiting_count = 0
         with self._company_lock(company.id):
             # Keep draining: a capture saved while this run held the lock waited
             # for it instead of compiling concurrently, and must not be left behind.
@@ -92,15 +93,29 @@ class MemoryCompilerService:
                 pending_captures = self.memory_repo.get_pending_captures(company.id, limit=limit)
                 if not pending_captures:
                     break
+                batch_waiting = 0
                 for capture in pending_captures:
+                    if not SystemAgentRunner.is_enabled(self._agent_for(capture)):
+                        # Its agent is turned off by the platform: the capture stays
+                        # pending and is compiled when the agent is turned on again.
+                        batch_waiting += 1
+                        continue
                     processed_count += 1
-                    if self._compile_capture_safely(company, capture):
+                    compiled = self._compile_capture_safely(company, capture)
+                    if compiled is None:
+                        batch_waiting += 1
+                    elif compiled:
                         compiled_count += 1
+                waiting_count += batch_waiting
+                if batch_waiting == len(pending_captures):
+                    # Nothing in this batch could move; reading it again would only repeat that.
+                    break
 
         return {
             "status": "success",
             "compiled_count": compiled_count,
             "processed_count": processed_count,
+            "waiting_count": waiting_count,
             "pending_count": len(self.memory_repo.get_pending_captures(company.id, limit=limit)),
         }
 
@@ -136,7 +151,12 @@ class MemoryCompilerService:
         finally:
             connection.close()
 
-    def _compile_capture_safely(self, company: Company, capture: MemoryCapture) -> bool:
+    def _agent_for(self, capture: MemoryCapture) -> str:
+        is_correction = dict(capture.meta or {}).get("mode") == self.CORRECTION_MODE
+        return self.CORRECTION_AGENT if is_correction else self.COMPILER_AGENT
+
+    def _compile_capture_safely(self, company: Company, capture: MemoryCapture) -> bool | None:
+        """Whether the capture became a page; None when it stays pending (its agent was turned off)."""
         items = self.memory_repo.list_capture_items(capture.id)
         if not items:
             self._mark_capture_compiled(capture, items)
@@ -145,6 +165,10 @@ class MemoryCompilerService:
             for item in items:
                 self._enrich_item(company.short_name, item)
             return self._compile_single_capture(company, capture, items)
+        except SystemAgentDisabled:
+            # Turned off while this run was going: leave it pending, untouched.
+            self.memory_repo.rollback()
+            return None
         except Exception as exc:
             logging.exception("Memory compilation failed for capture %s: %s", capture.id, exc)
             self.memory_repo.rollback()
@@ -316,6 +340,8 @@ class MemoryCompilerService:
                 user_identifier=capture.user_identifier,
                 question=f"Apply memory correction {capture.id}",
             )
+        except SystemAgentDisabled:
+            raise
         except Exception as exc:
             logging.warning("Memory correction %s could not reach the model: %s", capture.id, exc)
             return None
@@ -406,6 +432,8 @@ class MemoryCompilerService:
                 question=f"Compile memory capture {capture.id}",
                 attachments=native_pdf_attachments,
             )
+        except SystemAgentDisabled:
+            raise
         except Exception as exc:
             logging.warning("Memory compiler LLM fallback activated for capture %s: %s", capture.id, exc)
             return None

{iatoolkit-2.64.6 → iatoolkit-2.65.1}/src/iatoolkit/services/memory_question_service.py

@@ -198,6 +198,9 @@ class MemoryQuestionService:
             self._advance(cursor, queries[-1].id if queries else None)
             return {"status": "success", "counts": counts}
 
+        if not SystemAgentRunner.is_enabled(self.REVIEW_AGENT):
+            # Turned off by the platform: the cursor stays, so the turns are reviewed once it is on again.
+            return {"status": "skipped", "reason": "the review agent is turned off", "counts": counts}
         if not self.system_agent_runner.resolve_model(
                 company.short_name, SystemAgentCatalog.get(self.REVIEW_AGENT)).model:
             return {"status": "error", "error_message": "the company has no model configured", "counts": counts}

{iatoolkit-2.64.6 → iatoolkit-2.65.1}/src/iatoolkit/services/system_agent_runner.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 import json
 import logging
 from dataclasses import dataclass
+from typing import Callable
 
 from injector import inject
 from jinja2 import StrictUndefined
@@ -23,14 +24,28 @@ class SystemAgentUnavailable(Exception):
     """The company has no model to run the agent with."""
 
 
+class SystemAgentDisabled(SystemAgentUnavailable):
+    """The platform turned the agent off: its work waits until it is turned on again."""
+
+
+@dataclass(frozen=True)
+class PlatformAgentSettings:
+    """What the platform operator set for an agent, for every tenant (BL-012, Fase 2)."""
+    default_model: str | None = None
+    enabled: bool = True
+
+
 @dataclass(frozen=True)
 class ResolvedModel:
     model: str | None
-    # Where it came from: "tenant" (company.yaml), "catalog" (the agent's default)
-    # or "company" (the company's default model).
+    # Where it came from: "tenant" (company.yaml), "platform" (the operator's
+    # default for the agent), "catalog" (the agent's default in its pack) or
+    # "company" (the company's default model).
     source: str | None
     # The tenant's choice when it could not be used (no longer enabled).
     ignored_choice: str | None = None
+    # The platform's model when this company does not have it enabled.
+    ignored_platform_model: str | None = None
 
 
 class SystemAgentRunner:
@@ -40,11 +55,16 @@ class SystemAgentRunner:
     output contract. Interpreting and repairing the answer stays with the caller.
 
     The model is resolved from the most specific to the most general: the one the
-    tenant picked (`system_agents.<key>.model` in company.yaml), the agent's
-    default in the catalog, the company's default model. A pick that is no
-    longer among the company's models falls through to the next level, and a
-    call that fails with a picked model is retried once with the company's
-    default, so a bad choice never stops the agent.
+    tenant picked (`system_agents.<key>.model` in company.yaml), the one the
+    platform set for the agent, the agent's default in the catalog, the
+    company's default model. A model the company does not have enabled is
+    skipped (the platform's too: a tenant is never charged for a model it does
+    not have), and a call that fails with a picked model is retried once with
+    the company's default, so a bad choice never stops the agent.
+
+    The platform's settings (default model, on/off) come from a provider the
+    deployment registers (`register_platform_settings_provider`); without one,
+    every agent is on and has no platform model.
 
     Deliberately light: it does not go through tasks or the agent runtime, so
     the services that use it gain no dependency beyond the model client.
@@ -52,9 +72,12 @@ class SystemAgentRunner:
 
     CONFIG_SECTION = "system_agents"
     SOURCE_TENANT = "tenant"
+    SOURCE_PLATFORM = "platform"
     SOURCE_CATALOG = "catalog"
     SOURCE_COMPANY = "company"
 
+    _platform_settings_provider: Callable[[str], PlatformAgentSettings | None] | None = None
+
     _template_env = ImmutableSandboxedEnvironment(
         undefined=StrictUndefined,
         trim_blocks=True,
@@ -69,6 +92,33 @@ class SystemAgentRunner:
         self.llm_client = llm_client
         self.configuration_service = configuration_service
 
+    # =====================================================================
+    # Platform settings
+    # =====================================================================
+
+    @classmethod
+    def register_platform_settings_provider(cls,
+                                            provider: Callable[[str], PlatformAgentSettings | None] | None) -> None:
+        """`provider(agent_key)` returns the platform's settings for an agent, or None for the defaults."""
+        cls._platform_settings_provider = provider
+
+    @classmethod
+    def platform_settings(cls, agent_key: str) -> PlatformAgentSettings:
+        provider = cls._platform_settings_provider
+        if provider is None:
+            return PlatformAgentSettings()
+        try:
+            settings = provider(agent_key)
+        except Exception as exc:
+            # The platform's store unreachable must not stop the tenants' agents.
+            logging.warning("Platform settings of system agent '%s' could not be read: %s", agent_key, exc)
+            return PlatformAgentSettings()
+        return settings if isinstance(settings, PlatformAgentSettings) else PlatformAgentSettings()
+
+    @classmethod
+    def is_enabled(cls, agent_key: str) -> bool:
+        return cls.platform_settings(agent_key).enabled
+
     # =====================================================================
     # Running
     # =====================================================================
@@ -83,11 +133,15 @@ class SystemAgentRunner:
             attachments: list | None = None) -> dict:
         """
         The model's response (as llmClient.invoke returns it). Raises
+        SystemAgentDisabled when the platform turned the agent off,
         SystemAgentUnavailable without a model, and whatever the model client
         raises when even the company's default model fails.
         """
         agent = SystemAgentCatalog.get(agent_key)
-        resolved = self.resolve_model(company.short_name, agent)
+        platform = self.platform_settings(agent.key)
+        if not platform.enabled:
+            raise SystemAgentDisabled(f"system agent '{agent.key}' is turned off by the platform")
+        resolved = self.resolve_model(company.short_name, agent, platform=platform)
         if not resolved.model:
             raise SystemAgentUnavailable(f"{company.short_name} has no model for system agent '{agent.key}'")
         prompt = self.render_prompt(agent, inputs)
@@ -135,11 +189,12 @@ class SystemAgentRunner:
     def resolve_model(self,
                       company_short_name: str,
                       agent: SystemAgent,
-                      llm_configuration: tuple | None = None) -> ResolvedModel:
+                      llm_configuration: tuple | None = None,
+                      platform: PlatformAgentSettings | None = None) -> ResolvedModel:
         """
-        `llm_configuration` is get_llm_configuration's (default, available) when
-        the caller already read it: resolving many agents then costs one read,
-        which in enterprise is a query to the model catalogue.
+        `llm_configuration` is get_llm_configuration's (default, available) and
+        `platform` the agent's platform settings, when the caller already read
+        them: resolving many agents then costs one read of each.
         """
         default_model, available = llm_configuration or self.configuration_service.get_llm_configuration(company_short_name)
         enabled = self._model_ids(available)
@@ -158,9 +213,16 @@ class SystemAgentRunner:
                 "System agent '%s' of %s: model '%s' is no longer enabled; using the next level.",
                 agent.key, company_short_name, chosen,
             )
+        platform = platform or self.platform_settings(agent.key)
+        ignored_platform = None
+        if platform.default_model:
+            if usable(platform.default_model):
+                return ResolvedModel(platform.default_model, self.SOURCE_PLATFORM, ignored)
+            ignored_platform = platform.default_model
         if usable(agent.default_model):
-            return ResolvedModel(agent.default_model, self.SOURCE_CATALOG, ignored)
-        return ResolvedModel(default_model or None, self.SOURCE_COMPANY if default_model else None, ignored)
+            return ResolvedModel(agent.default_model, self.SOURCE_CATALOG, ignored, ignored_platform)
+        return ResolvedModel(default_model or None, self.SOURCE_COMPANY if default_model else None,
+                             ignored, ignored_platform)
 
     def tenant_choice(self, company_short_name: str, agent_key: str) -> str | None:
         section = self._tenant_section(company_short_name)
@@ -243,7 +305,8 @@ class SystemAgentRunner:
         llm_configuration = llm_configuration or self.configuration_service.get_llm_configuration(company_short_name)
         result = []
         for agent in SystemAgentCatalog.list():
-            resolved = self.resolve_model(company_short_name, agent, llm_configuration)
+            platform = self.platform_settings(agent.key)
+            resolved = self.resolve_model(company_short_name, agent, llm_configuration, platform)
             result.append({
                 "key": agent.key,
                 "name": agent.name,
@@ -260,5 +323,8 @@ class SystemAgentRunner:
                 "effective_model": resolved.model,
                 "model_source": resolved.source,
                 "ignored_model": resolved.ignored_choice,
+                "platform_model": platform.default_model,
+                "ignored_platform_model": resolved.ignored_platform_model,
+                "enabled": platform.enabled,
             })
         return result

{iatoolkit-2.64.6 → iatoolkit-2.65.1/src/iatoolkit.egg-info}/PKG-INFO

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