iatoolkit 2.47.2__tar.gz → 2.49.0__tar.gz

{iatoolkit-2.47.2/src/iatoolkit.egg-info → iatoolkit-2.49.0}/PKG-INFO

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

{iatoolkit-2.47.2 → iatoolkit-2.49.0}/src/iatoolkit/__init__.py

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

{iatoolkit-2.47.2 → iatoolkit-2.49.0}/src/iatoolkit/locales/en.yaml

@@ -1038,6 +1038,92 @@ ui:
     status_auth_redirect: "Auth redirect"
     unknown_client: "unknown client"
 
+  scheduled_jobs:
+    title: "Scheduled jobs"
+    schedules: "Schedules"
+    runs: "History"
+    schedules_title: "Scheduled executions"
+    runs_title: "Run history"
+    loading: "Loading..."
+    show_disabled: "Show disabled"
+    new_schedule: "New schedule"
+    edit_schedule: "Edit schedule"
+    search_placeholder: "Search schedules or targets"
+    refresh: "Refresh"
+    name: "Name"
+    schedule: "Schedule"
+    next_run: "Next run"
+    last_result: "Last result"
+    enabled: "Enabled"
+    disabled: "Disabled"
+    actions: "Actions"
+    all_schedules: "All schedules"
+    status: "Status"
+    all_statuses: "All statuses"
+    default_view: "Default view"
+    run: "Run"
+    scheduled_for: "Scheduled for"
+    duration: "Duration"
+    detail: "Detail"
+    identity: "Identity"
+    target: "Target"
+    target_type: "What to run"
+    target_type_tool: "Tool"
+    target_type_native_job: "Native job"
+    target_type_pipeline: "Pipeline"
+    timing: "Timing"
+    cron_expression: "Cron expression"
+    cron_help_format: "Format: minute, hour, day of month, month, day of week."
+    cron_every_10_minutes: "every 10 min"
+    cron_daily_at_3: "daily at 03:00"
+    cron_weekdays_at_9: "weekdays at 09:00"
+    timezone: "Timezone"
+    parameters: "Parameters"
+    arguments_help: "Sent to the target on every run."
+    arguments_help_pipeline: 'Pipeline filters: {"filters": {...}}'
+    execution: "Execution"
+    queue: "Queue"
+    timeout_seconds: "Timeout (seconds)"
+    max_retries: "Retries"
+    arguments_json: "Arguments (JSON)"
+    policies: "Policies"
+    misfire_policy: "After downtime"
+    policy_skip: "Skip"
+    policy_run_once: "Run once"
+    policy_catch_up: "Catch up"
+    grace_seconds: "Grace (seconds)"
+    max_catch_up: "Catch-up limit"
+    overlap_policy: "When a previous run is active"
+    overlap_skip: "Skip new run"
+    overlap_allow: "Allow overlap"
+    delete_title: "Delete schedule?"
+    delete_message: "The schedule and its run history will be permanently deleted."
+    summary: "{active} active of {total}"
+    empty: "No schedules found."
+    run_now: "Run now"
+    view_runs: "View runs"
+    runs_summary: "{count} recent runs"
+    runs_empty: "No runs found."
+    attempt: "Attempt {count}"
+    select_tool: "Select a tool"
+    select_native_job: "Select a native job"
+    select_pipeline: "Select a pipeline"
+    invalid_arguments_json: "Arguments must be a valid JSON object."
+    request_failed: "Request failed"
+    saved: "Schedule saved."
+    enabled_success: "Schedule enabled."
+    disabled_success: "Schedule disabled."
+    run_queued: "Run queued."
+    deleted: "Schedule deleted."
+    status_never: "Never run"
+    status_pending: "Pending"
+    status_queued: "Queued"
+    status_running: "Running"
+    status_retrying: "Retrying"
+    status_succeeded: "Succeeded"
+    status_failed: "Failed"
+    status_skipped: "Skipped"
+
   pipelines:
     source_root_label: "Root (prefix)"
     source_root_placeholder: "companies/<company_short_name>/..."
@@ -1714,6 +1800,13 @@ ui:
     queue_tier_default: "Default"
     queue_tier_low: "Low priority"
     queue_tier_help: "Low priority agents run only after the normal agents queue is empty."
+    runtime_provider_label: "Provider"
+    runtime_provider_query_service: "Default (uses LLM query)"
+    runtime_provider_openai_agents: "OpenAI Agents"
+    runtime_config_label: "Runtime config"
+    runtime_config_help: "Choose the runtime and, when needed, pass OpenAI Agents harness attributes. The tenant MCP is attached automatically."
+    runtime_config_json_label: "Config JSON"
+    runtime_config_json_help: "Optional JSON for runtime details such as environment, instructions, web_search, multi_agent or MCP connection attributes like mcp.service_token_id/service_token_name. MCP tool exposure is managed in the MCP admin."
     active_label: "Active"
     output_type_label: "Output Type"
     output_type_free_text: "Free text"

{iatoolkit-2.47.2 → iatoolkit-2.49.0}/src/iatoolkit/locales/es.yaml

@@ -1053,6 +1053,92 @@ ui:
     unknown_client: "cliente desconocido"
 
 
+  scheduled_jobs:
+    title: "Jobs programados"
+    schedules: "Programaciones"
+    runs: "Historial"
+    schedules_title: "Ejecuciones programadas"
+    runs_title: "Historial de ejecuciones"
+    loading: "Cargando..."
+    show_disabled: "Mostrar deshabilitados"
+    new_schedule: "Nueva programación"
+    edit_schedule: "Editar programación"
+    search_placeholder: "Buscar programaciones o destinos"
+    refresh: "Actualizar"
+    name: "Nombre"
+    schedule: "Programación"
+    next_run: "Próxima ejecución"
+    last_result: "Último resultado"
+    enabled: "Habilitada"
+    disabled: "Deshabilitada"
+    actions: "Acciones"
+    all_schedules: "Todas las programaciones"
+    status: "Estado"
+    all_statuses: "Todos los estados"
+    default_view: "Vista por defecto"
+    run: "Ejecución"
+    scheduled_for: "Programada para"
+    duration: "Duración"
+    detail: "Detalle"
+    identity: "Identidad"
+    target: "Destino"
+    target_type: "Qué ejecutar"
+    target_type_tool: "Tool"
+    target_type_native_job: "Job nativo"
+    target_type_pipeline: "Pipeline"
+    timing: "Horario"
+    cron_expression: "Expresión cron"
+    cron_help_format: "Formato: minuto, hora, día del mes, mes, día de la semana."
+    cron_every_10_minutes: "cada 10 min"
+    cron_daily_at_3: "diariamente a las 03:00"
+    cron_weekdays_at_9: "lunes a viernes a las 09:00"
+    timezone: "Zona horaria"
+    parameters: "Parámetros"
+    arguments_help: "Se envía al destino en cada ejecución."
+    arguments_help_pipeline: 'Filtros del pipeline: {"filters": {...}}'
+    execution: "Ejecución"
+    queue: "Cola"
+    timeout_seconds: "Timeout (segundos)"
+    max_retries: "Reintentos"
+    arguments_json: "Argumentos (JSON)"
+    policies: "Políticas"
+    misfire_policy: "Después de una interrupción"
+    policy_skip: "Omitir"
+    policy_run_once: "Ejecutar una vez"
+    policy_catch_up: "Recuperar pendientes"
+    grace_seconds: "Tolerancia (segundos)"
+    max_catch_up: "Límite de recuperación"
+    overlap_policy: "Cuando una ejecución anterior sigue activa"
+    overlap_skip: "Omitir nueva ejecución"
+    overlap_allow: "Permitir solapamiento"
+    delete_title: "¿Eliminar programación?"
+    delete_message: "La programación y su historial de ejecuciones se eliminarán permanentemente."
+    summary: "{active} activas de {total}"
+    empty: "No se encontraron programaciones."
+    run_now: "Ejecutar ahora"
+    view_runs: "Ver ejecuciones"
+    runs_summary: "{count} ejecuciones recientes"
+    runs_empty: "No se encontraron ejecuciones."
+    attempt: "Intento {count}"
+    select_tool: "Selecciona una tool"
+    select_native_job: "Selecciona un job nativo"
+    select_pipeline: "Selecciona un pipeline"
+    invalid_arguments_json: "Los argumentos deben ser un objeto JSON válido."
+    request_failed: "La solicitud falló"
+    saved: "Programación guardada."
+    enabled_success: "Programación habilitada."
+    disabled_success: "Programación deshabilitada."
+    run_queued: "Ejecución encolada."
+    deleted: "Programación eliminada."
+    status_never: "Nunca ejecutada"
+    status_pending: "Pendiente"
+    status_queued: "En cola"
+    status_running: "Ejecutando"
+    status_retrying: "Reintentando"
+    status_succeeded: "Exitosa"
+    status_failed: "Fallida"
+    status_skipped: "Omitida"
+
   pipelines:
     source_root_label: "Raiz (prefijo)"
     source_root_placeholder: "companies/<company_short_name>/..."
@@ -1731,6 +1817,13 @@ ui:
     queue_tier_default: "Por defecto"
     queue_tier_low: "Baja prioridad"
     queue_tier_help: "Los agentes de baja prioridad solo se ejecutan cuando la cola normal de agentes está vacía."
+    runtime_provider_label: "Provider"
+    runtime_provider_query_service: "Default (usa LLM query)"
+    runtime_provider_openai_agents: "OpenAI Agents"
+    runtime_config_label: "Configuración runtime"
+    runtime_config_help: "Elige el runtime y, cuando haga falta, pasa atributos del arnés de OpenAI Agents. El MCP del tenant se adjunta automáticamente."
+    runtime_config_json_label: "JSON de configuración"
+    runtime_config_json_help: "JSON opcional para detalles runtime como environment, instructions, web_search, multi_agent o atributos de conexión MCP como mcp.service_token_id/service_token_name. La exposición de tools se administra en el MCP admin."
     active_label: "Activo"
     output_type_label: "Tipo de Salida"
     output_type_free_text: "Texto libre"

{iatoolkit-2.47.2 → iatoolkit-2.49.0}/src/iatoolkit/repositories/models.py

@@ -45,6 +45,11 @@ class PromptAgentRole(str, enum.Enum):
     OPERATIONS = "operations"
 
 
+class PromptRuntimeProvider(str, enum.Enum):
+    QUERY_SERVICE = "query_service"
+    OPENAI_AGENTS = "openai_agents"
+
+
 class PromptResourceType(str, enum.Enum):
     SQL_SOURCE = "sql_source"
     RAG_COLLECTION = "rag_collection"
@@ -358,6 +363,7 @@ class Tool(Base):
 
     # source of the definition (Source of Truth)
     SOURCE_SYSTEM = 'SYSTEM'
+    SOURCE_EXTENSION = 'EXTENSION'  # registered by an installed runtime extension
     SOURCE_YAML = 'YAML'         # defined in company.yaml
     SOURCE_USER = 'USER'         # defined via GUI/API
     SOURCE_PACK = 'PACK'         # materialized by enterprise control-plane
@@ -895,6 +901,29 @@ class Prompt(Base):
     def context_policy(self, value: dict | None):
         self._set_runtime_policy_value("context", dict(value or {}))
 
+    @property
+    def runtime_provider(self) -> str:
+        provider = str((self.runtime_policy or {}).get("runtime_provider") or "").strip().lower()
+        if provider in {item.value for item in PromptRuntimeProvider}:
+            return provider
+        return PromptRuntimeProvider.QUERY_SERVICE.value
+
+    @runtime_provider.setter
+    def runtime_provider(self, value: str | None):
+        provider = str(value or "").strip().lower()
+        if provider not in {item.value for item in PromptRuntimeProvider}:
+            provider = PromptRuntimeProvider.QUERY_SERVICE.value
+        self._set_runtime_policy_value("runtime_provider", provider)
+
+    @property
+    def runtime_config(self) -> dict:
+        runtime_config = (self.runtime_policy or {}).get("runtime_config")
+        return dict(runtime_config or {}) if isinstance(runtime_config, dict) else {}
+
+    @runtime_config.setter
+    def runtime_config(self, value: dict | None):
+        self._set_runtime_policy_value("runtime_config", dict(value or {}))
+
 
 class PromptResourceBinding(Base):
     __tablename__ = "iat_prompt_resource_bindings"

{iatoolkit-2.47.2 → iatoolkit-2.49.0}/src/iatoolkit/services/configuration_service.py

@@ -492,6 +492,13 @@ class ConfigurationService:
         if not config.get("name"):
             add_error("General", "Missing required key: 'name'")
 
+        mcp_config = config.get("mcp")
+        if mcp_config is not None:
+            if not isinstance(mcp_config, dict):
+                add_error("mcp", "Must be a dictionary.")
+            else:
+                self._validate_mcp_url_config(mcp_config, add_error)
+
         # 2. LLM section
         if not isinstance(config.get("llm"), dict):
             add_error("llm", "Missing or invalid 'llm' section.")
@@ -784,6 +791,7 @@ class ConfigurationService:
             "operations",
         }
         allowed_queue_tiers = {"default", "low"}
+        allowed_runtime_providers = {"query_service", "openai_agents"}
         allowed_output_schema_modes = {"best_effort", "strict"}
         allowed_output_response_modes = {"chat_compatible", "structured_only"}
         allowed_attachment_modes = {"extracted_only", "native_only", "native_plus_extracted"}
@@ -837,6 +845,20 @@ class ConfigurationService:
                 )
                 continue
 
+            runtime_provider = str(runtime_policy.get("runtime_provider", "") or "").strip().lower()
+            if runtime_provider and runtime_provider not in allowed_runtime_providers:
+                add_error(
+                    f"prompts[{i}].runtime_policy.runtime_provider",
+                    "Unsupported runtime_policy.runtime_provider "
+                    f"'{runtime_provider}'. Must be one of: {sorted(allowed_runtime_providers)}.",
+                )
+                continue
+
+            runtime_config = runtime_policy.get("runtime_config")
+            if runtime_config is not None and not isinstance(runtime_config, dict):
+                add_error(f"prompts[{i}].runtime_policy.runtime_config", "Must be a dictionary.")
+                continue
+
             if prompt_cat and prompt_cat not in category_set:
                 add_error(f"prompts[{i}]", f"Category '{prompt_cat}' is not defined in 'prompt_categories'.")
 
@@ -1238,6 +1260,21 @@ class ConfigurationService:
 
         return errors
 
+    @staticmethod
+    def _validate_mcp_url_config(mcp_config: dict, add_error) -> None:
+        for key in ("server_url", "public_server_url", "public_url", "public_base_url", "base_url", "public_base"):
+            if key not in mcp_config or mcp_config.get(key) in (None, ""):
+                continue
+            raw_url = str(mcp_config.get(key) or "").strip()
+            if not raw_url:
+                continue
+            if any(ch.isspace() for ch in raw_url):
+                add_error(f"mcp.{key}", "Whitespace is not allowed.")
+                continue
+            parsed = urlparse(raw_url)
+            if parsed.scheme != "https" or not parsed.netloc:
+                add_error(f"mcp.{key}", "URL must be absolute HTTPS.")
+
 
     def _set_nested_value(self, data: dict, key: str, value):
         """

{iatoolkit-2.47.2 → iatoolkit-2.49.0}/src/iatoolkit/services/mcp_token_service.py

@@ -4,6 +4,8 @@ import hashlib
 import os
 import secrets
 from datetime import datetime, timedelta
+from typing import Any
+from urllib.parse import quote, urlparse
 
 from injector import inject
 from sqlalchemy.exc import IntegrityError
@@ -12,6 +14,7 @@ from iatoolkit.common.util import Utility
 from iatoolkit.repositories.mcp_token_repo import McpTokenRepo
 from iatoolkit.repositories.models import McpToken
 from iatoolkit.repositories.profile_repo import ProfileRepo
+from iatoolkit.services.configuration_service import ConfigurationService
 from iatoolkit.services.i18n_service import I18nService
 
 
@@ -28,11 +31,13 @@ class McpTokenService:
         profile_repo: ProfileRepo,
         token_repo: McpTokenRepo,
         utility: Utility,
+        configuration_service: ConfigurationService | None = None,
     ):
         self.i18n_service = i18n_service
         self.profile_repo = profile_repo
         self.token_repo = token_repo
         self.utility = utility
+        self.configuration_service = configuration_service
 
     def list_user_tokens(self, company_short_name: str, user_identifier: str) -> dict:
         company, error = self._get_company(company_short_name)
@@ -136,7 +141,7 @@ class McpTokenService:
             return {"error": self.i18n_service.t("errors.auth.mcp_pat_token_unavailable"), "status_code": 409}
 
         raw_token = self.utility.decrypt_key(token.token_encrypted)
-        mcp_server_url = self.build_mcp_server_url(company_short_name)
+        mcp_server_url = self.resolve_mcp_server_url(company_short_name)
         payload = self._token_to_dict(token)
         payload["token"] = raw_token
         payload["mcp_server_url"] = mcp_server_url
@@ -172,6 +177,48 @@ class McpTokenService:
             "token_id": token.id,
         }
 
+    def resolve_mcp_server_url(self, company_short_name: str) -> str:
+        configured_url = self._configured_mcp_server_url(company_short_name)
+        if configured_url:
+            return configured_url
+        return self.build_mcp_server_url(company_short_name)
+
+    def _configured_mcp_server_url(self, company_short_name: str) -> str | None:
+        if self.configuration_service is None:
+            return None
+        try:
+            mcp_config = self.configuration_service.get_configuration(company_short_name, "mcp") or {}
+        except Exception:
+            return None
+        if not isinstance(mcp_config, dict):
+            return None
+        raw_url = (
+            mcp_config.get("server_url")
+            or mcp_config.get("public_server_url")
+            or mcp_config.get("public_url")
+        )
+        if not raw_url:
+            raw_base_url = (
+                mcp_config.get("public_base_url")
+                or mcp_config.get("base_url")
+                or mcp_config.get("public_base")
+            )
+            if raw_base_url:
+                raw_url = f"{str(raw_base_url).rstrip('/')}/{quote(str(company_short_name or '').strip(), safe='')}/mcp"
+        return self._normalize_mcp_server_url(raw_url, company_short_name=company_short_name)
+
+    @staticmethod
+    def _normalize_mcp_server_url(raw_url: Any, *, company_short_name: str) -> str | None:
+        url = str(raw_url or "").strip()
+        if not url:
+            return None
+        if any(ch.isspace() for ch in url):
+            raise ValueError(f"Invalid MCP server_url for tenant '{company_short_name}': whitespace is not allowed.")
+        parsed = urlparse(url)
+        if parsed.scheme != "https" or not parsed.netloc:
+            raise ValueError(f"Invalid MCP server_url for tenant '{company_short_name}': URL must be absolute HTTPS.")
+        return url.rstrip("/")
+
     @staticmethod
     def build_mcp_server_url(company_short_name: str) -> str:
         public_base_url = str(
@@ -180,7 +227,8 @@ class McpTokenService:
             or "https://mcp.iatoolkit.com"
         ).strip()
         public_base_url = public_base_url.rstrip("/")
-        return f"{public_base_url}/{company_short_name}/mcp/"
+        tenant = quote(str(company_short_name or "").strip(), safe="")
+        return f"{public_base_url}/{tenant}/mcp"
 
     @staticmethod
     def build_mcp_connection_snippet(

{iatoolkit-2.47.2 → iatoolkit-2.49.0}/src/iatoolkit/services/prompt_service.py

@@ -15,6 +15,7 @@ from collections import defaultdict
 from iatoolkit.repositories.models import (
     Prompt,
     PromptAgentRole,
+    PromptRuntimeProvider,
     PromptCategory,
     Company,
 )
@@ -51,6 +52,8 @@ class PromptService:
     TOOL_POLICY_MODE_EXPLICIT = "explicit"
     QUEUE_TIER_DEFAULT = "default"
     QUEUE_TIER_LOW = "low"
+    RUNTIME_PROVIDER_QUERY_SERVICE = PromptRuntimeProvider.QUERY_SERVICE.value
+    RUNTIME_PROVIDER_OPENAI_AGENTS = PromptRuntimeProvider.OPENAI_AGENTS.value
     EXECUTION_MODE_CONVERSATIONAL = "conversational"
     EXECUTION_MODE_AGENTIC = "agentic"
     AGENT_ROLE_WORKSPACE_CHAT = PromptAgentRole.WORKSPACE_CHAT.value
@@ -250,11 +253,27 @@ class PromptService:
             return candidate
         return cls.QUEUE_TIER_DEFAULT
 
+    @classmethod
+    def normalize_runtime_provider_value(cls, runtime_provider: str | None) -> str:
+        candidate = str(runtime_provider or cls.RUNTIME_PROVIDER_QUERY_SERVICE).strip().lower()
+        if candidate in {
+            cls.RUNTIME_PROVIDER_QUERY_SERVICE,
+            cls.RUNTIME_PROVIDER_OPENAI_AGENTS,
+        }:
+            return candidate
+        return cls.RUNTIME_PROVIDER_QUERY_SERVICE
+
+    @classmethod
+    def normalize_runtime_config(cls, runtime_config: dict | None) -> dict:
+        return dict(runtime_config or {}) if isinstance(runtime_config, dict) else {}
+
     @classmethod
     def normalize_runtime_policy(cls, runtime_policy: dict | None) -> dict:
         policy = runtime_policy if isinstance(runtime_policy, dict) else {}
         role = cls.normalize_agent_role_value(policy.get("role"))
         queue_tier = cls.normalize_queue_tier_value(policy.get("queue_tier"))
+        runtime_provider = cls.normalize_runtime_provider_value(policy.get("runtime_provider"))
+        runtime_config = cls.normalize_runtime_config(policy.get("runtime_config"))
         raw_context = policy.get("context")
         context = cls.normalize_context_policy(
             raw_context if isinstance(raw_context, dict) else None,
@@ -265,6 +284,8 @@ class PromptService:
             "role": role,
             "queue_tier": queue_tier,
             "context": context,
+            "runtime_provider": runtime_provider,
+            "runtime_config": runtime_config,
         }
 
     @classmethod
@@ -279,6 +300,17 @@ class PromptService:
     def get_runtime_policy_context(cls, runtime_policy: dict | None) -> dict:
         return cls.normalize_runtime_policy(runtime_policy).get("context", cls.default_context_policy_for_agent_role(None))
 
+    @classmethod
+    def get_runtime_policy_provider(cls, runtime_policy: dict | None) -> str:
+        return cls.normalize_runtime_policy(runtime_policy).get(
+            "runtime_provider",
+            cls.RUNTIME_PROVIDER_QUERY_SERVICE,
+        )
+
+    @classmethod
+    def get_runtime_policy_config(cls, runtime_policy: dict | None) -> dict:
+        return cls.normalize_runtime_policy(runtime_policy).get("runtime_config", {})
+
     def _normalize_output_schema_mode(self, output_schema_mode: str | None) -> str:
         candidate = str(output_schema_mode or self.OUTPUT_SCHEMA_MODE_BEST_EFFORT).strip().lower()
         allowed = {
@@ -689,6 +721,8 @@ class PromptService:
                         'llm_request_options': dict(getattr(p, 'llm_request_options', None) or {}),
                         'tool_policy': dict(getattr(p, 'tool_policy', None) or {}),
                         'context_policy': runtime_policy["context"],
+                        'runtime_provider': runtime_policy["runtime_provider"],
+                        'runtime_config': runtime_policy["runtime_config"],
                     })
 
                 categorized_prompts.append({
@@ -809,6 +843,16 @@ class PromptService:
                 "role": role_value,
                 "queue_tier": queue_tier_value,
                 "context": context_value,
+                "runtime_provider": data.get(
+                    "runtime_provider",
+                    getattr(existing_prompt, "runtime_provider", existing_runtime_policy["runtime_provider"])
+                    if existing_prompt is not None else existing_runtime_policy["runtime_provider"],
+                ),
+                "runtime_config": data.get(
+                    "runtime_config",
+                    getattr(existing_prompt, "runtime_config", existing_runtime_policy["runtime_config"])
+                    if existing_prompt is not None else existing_runtime_policy["runtime_config"],
+                ),
             })
         agent_role = runtime_policy["role"]
         force_free_text_output = (

{iatoolkit-2.47.2 → iatoolkit-2.49.0}/src/iatoolkit/services/tool_service.py

@@ -983,6 +983,8 @@ class ToolService:
         desired_names.discard("")
 
         for name, tool in existing_by_name.items():
+            if tool.source == Tool.SOURCE_EXTENSION:
+                continue
             if name not in desired_names and bool(tool.is_active):
                 return True
 
@@ -1042,6 +1044,8 @@ class ToolService:
             desired_names.discard("")
             deactivated_tools = 0
             for name, tool in existing_by_name.items():
+                if tool.source == Tool.SOURCE_EXTENSION:
+                    continue
                 if name in desired_names or not bool(tool.is_active):
                     continue
                 tool.is_active = False

{iatoolkit-2.47.2 → iatoolkit-2.49.0}/src/iatoolkit/views/prompt_api_view.py

@@ -57,6 +57,8 @@ class PromptApiView(MethodView):
                 meta["execution_mode"] = PromptService.execution_mode_for_agent_role(agent_role)
                 meta["queue_tier"] = runtime_policy["queue_tier"]
                 meta["context_policy"] = runtime_policy["context"]
+                meta["runtime_provider"] = runtime_policy["runtime_provider"]
+                meta["runtime_config"] = runtime_policy["runtime_config"]
 
                 return jsonify({
                     "meta": meta,

{iatoolkit-2.47.2 → iatoolkit-2.49.0/src/iatoolkit.egg-info}/PKG-INFO

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