iatoolkit 2.48.0__tar.gz → 2.49.0__tar.gz

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

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

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

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

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

@@ -1078,6 +1078,9 @@ ui:
     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)"
@@ -1797,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.48.0 → iatoolkit-2.49.0}/src/iatoolkit/locales/es.yaml

@@ -1093,6 +1093,9 @@ ui:
     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)"
@@ -1814,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.48.0 → 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"
@@ -896,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.48.0 → 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.48.0 → 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.48.0 → 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.48.0 → 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.48.0 → iatoolkit-2.49.0/src/iatoolkit.egg-info}/PKG-INFO

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