iatoolkit 2.32.0__tar.gz → 2.32.1__tar.gz

{iatoolkit-2.32.0/src/iatoolkit.egg-info → iatoolkit-2.32.1}/PKG-INFO

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

{iatoolkit-2.32.0 → iatoolkit-2.32.1}/src/iatoolkit/__init__.py

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

{iatoolkit-2.32.0 → iatoolkit-2.32.1}/src/iatoolkit/repositories/llm_query_repo.py

@@ -10,7 +10,6 @@ from iatoolkit.repositories.models import (
     Prompt,
     PromptAgentRole,
     PromptCategory,
-    PromptExecutionMode,
 )
 from injector import inject
 from iatoolkit.repositories.database_manager import DatabaseManager
@@ -147,16 +146,34 @@ class LLMQueryRepo:
             return self.session.query(Prompt).filter(
                 Prompt.company_id == company.id,
             ).all()
-        else:
-            # Only active prompts explicitly exposed in chat for end users.
-            return self.session.query(Prompt).filter(
-                Prompt.company_id == company.id,
-                Prompt.active.is_(True),
-                Prompt.agent_role.in_([
-                    PromptAgentRole.WORKSPACE_CHAT.value,
-                    PromptAgentRole.WORKSPACE_AGENT.value,
-                ]),
-            ).all()
+
+        # Only active prompts explicitly exposed in chat for end users.
+        prompts = self.session.query(Prompt).filter(
+            Prompt.company_id == company.id,
+            Prompt.active.is_(True),
+        ).all()
+        return [
+            prompt for prompt in prompts
+            if self._get_prompt_runtime_role(prompt) in {
+                PromptAgentRole.WORKSPACE_CHAT.value,
+                PromptAgentRole.WORKSPACE_AGENT.value,
+            }
+        ]
+
+    @staticmethod
+    def _get_prompt_runtime_role(prompt: Prompt) -> str:
+        runtime_policy = getattr(prompt, "runtime_policy", None)
+        if not isinstance(runtime_policy, dict):
+            runtime_policy = {}
+        role = str(runtime_policy.get("role") or "").strip().lower()
+        if role in {
+            PromptAgentRole.WORKSPACE_CHAT.value,
+            PromptAgentRole.WORKSPACE_AGENT.value,
+            PromptAgentRole.CHANNELS.value,
+            PromptAgentRole.OPERATIONS.value,
+        }:
+            return role
+        return PromptAgentRole.WORKSPACE_CHAT.value
 
     def create_or_update_prompt(self, new_prompt: Prompt):
         prompt = self.session.query(Prompt).filter_by(company_id=new_prompt.company_id,
@@ -167,16 +184,6 @@ class LLMQueryRepo:
             prompt.order = new_prompt.order
             if new_prompt.active is not None:
                 prompt.active = new_prompt.active
-            prompt.agent_role = (
-                getattr(new_prompt, "agent_role", None)
-                or prompt.agent_role
-                or PromptAgentRole.WORKSPACE_CHAT.value
-            )
-            prompt.execution_mode = (
-                PromptExecutionMode.CONVERSATIONAL.value
-                if prompt.agent_role == PromptAgentRole.WORKSPACE_CHAT.value
-                else PromptExecutionMode.AGENTIC.value
-            )
             prompt.filename = new_prompt.filename
             prompt.custom_fields = new_prompt.custom_fields
             prompt.output_schema = new_prompt.output_schema
@@ -191,21 +198,15 @@ class LLMQueryRepo:
             )
             prompt.attachment_fallback = new_prompt.attachment_fallback or prompt.attachment_fallback or "extract"
             prompt.llm_model = new_prompt.llm_model
-            prompt.queue_tier = getattr(new_prompt, "queue_tier", None) or prompt.queue_tier or "default"
             prompt.llm_request_options = dict(new_prompt.llm_request_options or {})
             prompt.tool_policy = dict(new_prompt.tool_policy or {})
-            prompt.context_policy = dict(getattr(new_prompt, "context_policy", None) or {})
+            prompt.runtime_policy = (
+                dict(getattr(new_prompt, "runtime_policy", None) or {})
+                or dict(getattr(prompt, "runtime_policy", None) or {})
+            )
         else:
             if new_prompt.active is None:
                 new_prompt.active = True
-            if not new_prompt.agent_role:
-                new_prompt.agent_role = PromptAgentRole.WORKSPACE_CHAT.value
-            if not new_prompt.execution_mode:
-                new_prompt.execution_mode = (
-                    PromptExecutionMode.CONVERSATIONAL.value
-                    if new_prompt.agent_role == PromptAgentRole.WORKSPACE_CHAT.value
-                    else PromptExecutionMode.AGENTIC.value
-                )
             if not new_prompt.output_schema_mode:
                 new_prompt.output_schema_mode = "best_effort"
             if not new_prompt.output_response_mode:
@@ -216,14 +217,12 @@ class LLMQueryRepo:
                 new_prompt.attachment_parser_provider = "basic"
             if not new_prompt.attachment_fallback:
                 new_prompt.attachment_fallback = "extract"
-            if not getattr(new_prompt, "queue_tier", None):
-                new_prompt.queue_tier = "default"
             if new_prompt.llm_request_options is None:
                 new_prompt.llm_request_options = {}
             if new_prompt.tool_policy is None:
                 new_prompt.tool_policy = {}
-            if getattr(new_prompt, "context_policy", None) is None:
-                new_prompt.context_policy = {}
+            if getattr(new_prompt, "runtime_policy", None) is None:
+                new_prompt.runtime_policy = {}
             self.session.add(new_prompt)
             prompt = new_prompt
 

{iatoolkit-2.32.0 → iatoolkit-2.32.1}/src/iatoolkit/repositories/models.py

@@ -724,8 +724,6 @@ class Prompt(Base):
     description = Column(String, nullable=False)
     filename = Column(String, nullable=False)
     active = Column(Boolean, default=True)
-    agent_role = Column(String, default=PromptAgentRole.WORKSPACE_CHAT.value, nullable=False)
-    execution_mode = Column(String, default=PromptExecutionMode.CONVERSATIONAL.value, nullable=False)
     order = Column(Integer, nullable=True, default=0)
     category_id = Column(Integer, ForeignKey(f'{ORM_SCHEMA}.iat_prompt_categories.id', ondelete='SET NULL'), nullable=True)
     custom_fields = Column(JSON, nullable=False, default=[])
@@ -737,10 +735,9 @@ class Prompt(Base):
     attachment_parser_provider = Column(String, nullable=False, default="basic")
     attachment_fallback = Column(String, nullable=False, default="extract")
     llm_model = Column(String, nullable=True, default=None)
-    queue_tier = Column(String, nullable=False, default="default")
     llm_request_options = Column(JSON_NATIVE, nullable=False, default=dict)
     tool_policy = Column(JSON_NATIVE, nullable=False, default=dict)
-    context_policy = Column(JSON_NATIVE, nullable=False, default=dict)
+    runtime_policy = Column(JSON_NATIVE, nullable=False, default=dict)
     created_at = Column(DateTime, default=datetime.now)
 
     def to_dict(self):
@@ -755,6 +752,59 @@ class Prompt(Base):
         order_by="PromptResourceBinding.binding_order",
     )
 
+    def _runtime_policy_dict(self) -> dict:
+        return dict(self.runtime_policy or {})
+
+    def _set_runtime_policy_value(self, key: str, value):
+        policy = self._runtime_policy_dict()
+        policy["version"] = 1
+        policy[key] = value
+        self.runtime_policy = policy
+
+    @property
+    def agent_role(self) -> str:
+        role = str((self.runtime_policy or {}).get("role") or "").strip().lower()
+        if role in {item.value for item in PromptAgentRole}:
+            return role
+        return PromptAgentRole.WORKSPACE_CHAT.value
+
+    @agent_role.setter
+    def agent_role(self, value: str | None):
+        role = str(value or "").strip().lower()
+        if role not in {item.value for item in PromptAgentRole}:
+            role = PromptAgentRole.WORKSPACE_CHAT.value
+        self._set_runtime_policy_value("role", role)
+
+    @property
+    def execution_mode(self) -> str:
+        if self.agent_role == PromptAgentRole.WORKSPACE_CHAT.value:
+            return PromptExecutionMode.CONVERSATIONAL.value
+        return PromptExecutionMode.AGENTIC.value
+
+    @execution_mode.setter
+    def execution_mode(self, value: str | None):
+        # execution_mode is derived from runtime_policy.role and is intentionally not persisted.
+        return
+
+    @property
+    def queue_tier(self) -> str:
+        tier = str((self.runtime_policy or {}).get("queue_tier") or "default").strip().lower()
+        return "low" if tier == "low" else "default"
+
+    @queue_tier.setter
+    def queue_tier(self, value: str | None):
+        tier = str(value or "default").strip().lower()
+        self._set_runtime_policy_value("queue_tier", "low" if tier == "low" else "default")
+
+    @property
+    def context_policy(self) -> dict:
+        context = (self.runtime_policy or {}).get("context")
+        return dict(context or {}) if isinstance(context, dict) else {}
+
+    @context_policy.setter
+    def context_policy(self, value: dict | None):
+        self._set_runtime_policy_value("context", dict(value or {}))
+
 
 class PromptResourceBinding(Base):
     __tablename__ = "iat_prompt_resource_bindings"

{iatoolkit-2.32.0 → iatoolkit-2.32.1}/src/iatoolkit/services/configuration_service.py

@@ -777,13 +777,13 @@ class ConfigurationService:
         prompt_list, categories_config = self._get_prompt_config(config)
 
         category_set = set(categories_config)
-        allowed_execution_modes = {"conversational", "agentic"}
         allowed_agent_roles = {
             "workspace_chat",
             "workspace_agent",
             "channels",
             "operations",
         }
+        allowed_queue_tiers = {"default", "low"}
         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"}
@@ -816,19 +816,24 @@ class ConfigurationService:
                     add_error(f"prompts[{i}]", "Missing required key: 'description'")
 
             prompt_cat = prompt.get("category")
-            execution_mode = str(prompt.get("execution_mode", "") or "").strip().lower()
-            if execution_mode and execution_mode not in allowed_execution_modes:
+            runtime_policy = prompt.get("runtime_policy") or {}
+            if not isinstance(runtime_policy, dict):
+                add_error(f"prompts[{i}].runtime_policy", "Must be a dictionary.")
+                continue
+
+            agent_role = str(runtime_policy.get("role", "") or "").strip().lower()
+            if agent_role and agent_role not in allowed_agent_roles:
                 add_error(
-                    f"prompts[{i}]",
-                    f"Unsupported execution_mode '{execution_mode}'. Must be one of: {sorted(allowed_execution_modes)}."
+                    f"prompts[{i}].runtime_policy.role",
+                    f"Unsupported runtime_policy.role '{agent_role}'. Must be one of: {sorted(allowed_agent_roles)}.",
                 )
                 continue
 
-            agent_role = str(prompt.get("agent_role", "") or "").strip().lower()
-            if agent_role and agent_role not in allowed_agent_roles:
+            queue_tier = str(runtime_policy.get("queue_tier", "") or "").strip().lower()
+            if queue_tier and queue_tier not in allowed_queue_tiers:
                 add_error(
-                    f"prompts[{i}].agent_role",
-                    f"Unsupported agent_role '{agent_role}'. Must be one of: {sorted(allowed_agent_roles)}.",
+                    f"prompts[{i}].runtime_policy.queue_tier",
+                    f"Unsupported runtime_policy.queue_tier '{queue_tier}'. Must be one of: {sorted(allowed_queue_tiers)}.",
                 )
                 continue
 

{iatoolkit-2.32.0 → iatoolkit-2.32.1}/src/iatoolkit/services/context_builder_service.py

@@ -129,15 +129,17 @@ class ContextBuilderService:
             except Exception:
                 schema = None
 
-        raw_execution_mode = str(getattr(prompt_obj, "execution_mode", "") or "").strip().lower()
-        execution_mode = raw_execution_mode if raw_execution_mode in {"conversational", "agentic"} else "conversational"
-        raw_agent_role = str(getattr(prompt_obj, "agent_role", "") or "").strip().lower()
-        agent_role = (
-            raw_agent_role
-            if raw_agent_role in {"workspace_chat", "workspace_agent", "channels", "operations"}
-            else "workspace_chat"
-        )
-        execution_mode = "conversational" if agent_role == "workspace_chat" else "agentic"
+        raw_runtime_policy = getattr(prompt_obj, "runtime_policy", None)
+        if isinstance(raw_runtime_policy, dict):
+            runtime_policy = PromptService.normalize_runtime_policy(raw_runtime_policy)
+        else:
+            runtime_policy = PromptService.normalize_runtime_policy({
+                "role": getattr(prompt_obj, "agent_role", None),
+                "queue_tier": getattr(prompt_obj, "queue_tier", None),
+                "context": getattr(prompt_obj, "context_policy", None),
+            })
+        agent_role = runtime_policy["role"]
+        execution_mode = PromptService.execution_mode_for_agent_role(agent_role)
 
         resource_bindings: list[dict] = []
         for binding in getattr(prompt_obj, "resource_bindings", []) or []:
@@ -163,10 +165,8 @@ class ContextBuilderService:
             "prompt_name": prompt_obj.name,
             "agent_role": agent_role,
             "execution_mode": execution_mode,
-            "context_policy": self.prompt_service.normalize_context_policy(
-                getattr(prompt_obj, "context_policy", None),
-                agent_role,
-            ),
+            "runtime_policy": runtime_policy,
+            "context_policy": runtime_policy["context"],
             "schema": schema,
             "schema_yaml": prompt_obj.output_schema_yaml,
             "schema_mode": prompt_obj.output_schema_mode or "best_effort",

{iatoolkit-2.32.0 → iatoolkit-2.32.1}/src/iatoolkit/services/prompt_service.py

@@ -17,7 +17,6 @@ from iatoolkit.repositories.models import (
     PromptAgentRole,
     PromptCategory,
     Company,
-    PromptExecutionMode,
 )
 from iatoolkit.common.exceptions import IAToolkitException
 from iatoolkit.services.system_prompt_catalog import build_system_prompt_payload
@@ -49,8 +48,8 @@ class PromptService:
     TOOL_POLICY_MODE_EXPLICIT = "explicit"
     QUEUE_TIER_DEFAULT = "default"
     QUEUE_TIER_LOW = "low"
-    EXECUTION_MODE_CONVERSATIONAL = PromptExecutionMode.CONVERSATIONAL.value
-    EXECUTION_MODE_AGENTIC = PromptExecutionMode.AGENTIC.value
+    EXECUTION_MODE_CONVERSATIONAL = "conversational"
+    EXECUTION_MODE_AGENTIC = "agentic"
     AGENT_ROLE_WORKSPACE_CHAT = PromptAgentRole.WORKSPACE_CHAT.value
     AGENT_ROLE_WORKSPACE_AGENT = PromptAgentRole.WORKSPACE_AGENT.value
     AGENT_ROLE_CHANNELS = PromptAgentRole.CHANNELS.value
@@ -182,6 +181,54 @@ class PromptService:
                 blocks[key] = bool(raw_blocks.get(key))
         return {"company_context_blocks": blocks}
 
+    @classmethod
+    def normalize_agent_role_value(cls, agent_role: str | None) -> str:
+        candidate = str(agent_role or "").strip().lower()
+        if candidate in {
+            cls.AGENT_ROLE_WORKSPACE_CHAT,
+            cls.AGENT_ROLE_WORKSPACE_AGENT,
+            cls.AGENT_ROLE_CHANNELS,
+            cls.AGENT_ROLE_OPERATIONS,
+        }:
+            return candidate
+        return cls.AGENT_ROLE_WORKSPACE_CHAT
+
+    @classmethod
+    def normalize_queue_tier_value(cls, queue_tier: str | None) -> str:
+        candidate = str(queue_tier or cls.QUEUE_TIER_DEFAULT).strip().lower()
+        if candidate in {cls.QUEUE_TIER_DEFAULT, cls.QUEUE_TIER_LOW}:
+            return candidate
+        return cls.QUEUE_TIER_DEFAULT
+
+    @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"))
+        raw_context = policy.get("context")
+        context = cls.normalize_context_policy(
+            raw_context if isinstance(raw_context, dict) else None,
+            role,
+        )
+        return {
+            "version": 1,
+            "role": role,
+            "queue_tier": queue_tier,
+            "context": context,
+        }
+
+    @classmethod
+    def get_runtime_policy_role(cls, runtime_policy: dict | None) -> str:
+        return cls.normalize_runtime_policy(runtime_policy).get("role", cls.AGENT_ROLE_WORKSPACE_CHAT)
+
+    @classmethod
+    def get_runtime_policy_queue_tier(cls, runtime_policy: dict | None) -> str:
+        return cls.normalize_runtime_policy(runtime_policy).get("queue_tier", cls.QUEUE_TIER_DEFAULT)
+
+    @classmethod
+    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))
+
     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 = {
@@ -544,7 +591,9 @@ class PromptService:
                 all_prompts = [
                     prompt for prompt in all_prompts
                     if bool(getattr(prompt, 'active', True))
-                    and self.is_workspace_chat_role(getattr(prompt, 'agent_role', None))
+                    and self.is_workspace_chat_role(
+                        self.get_runtime_policy_role(getattr(prompt, 'runtime_policy', None))
+                    )
                 ]
 
             # group by category
@@ -567,43 +616,35 @@ class PromptService:
             sorted_categories = sorted(prompts_by_category.items(), key=lambda item: item[0][0])
 
             for (cat_order, cat_name), prompts in sorted_categories:
+                prompt_items = []
+                for p in prompts:
+                    runtime_policy = self.normalize_runtime_policy(getattr(p, 'runtime_policy', None))
+                    agent_role = runtime_policy["role"]
+                    prompt_items.append({
+                        'prompt': p.name,
+                        'description': p.description,
+                        'category': p.category.name if p.category else None,
+                        'agent_role': agent_role,
+                        'execution_mode': self.execution_mode_for_agent_role(agent_role),
+                        'active': p.active,
+                        'custom_fields': p.custom_fields,
+                        'order': p.order,
+                        'output_schema_mode': p.output_schema_mode,
+                        'output_response_mode': p.output_response_mode,
+                        'attachment_mode': p.attachment_mode,
+                        'attachment_parser_provider': getattr(p, 'attachment_parser_provider', None),
+                        'attachment_fallback': p.attachment_fallback,
+                        'llm_model': getattr(p, 'llm_model', None),
+                        'queue_tier': runtime_policy["queue_tier"],
+                        '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"],
+                    })
+
                 categorized_prompts.append({
                     'category_name': cat_name,
                     'category_order': cat_order,
-                    'prompts': [
-                        {
-                            'prompt': p.name,
-                            'description': p.description,
-                            'category': p.category.name if p.category else None,
-                            'agent_role': self._normalize_agent_role(
-                                getattr(p, 'agent_role', None)
-                            ),
-                            'execution_mode': (
-                                str(getattr(p, 'execution_mode', None) or self.EXECUTION_MODE_CONVERSATIONAL)
-                                .strip()
-                                .lower()
-                            ),
-                            'active': p.active,
-                            'custom_fields': p.custom_fields,
-                            'order': p.order,
-                            'output_schema_mode': p.output_schema_mode,
-                            'output_response_mode': p.output_response_mode,
-                            'attachment_mode': p.attachment_mode,
-                            'attachment_parser_provider': getattr(p, 'attachment_parser_provider', None),
-                            'attachment_fallback': p.attachment_fallback,
-                            'llm_model': getattr(p, 'llm_model', None),
-                            'queue_tier': self._normalize_queue_tier(
-                                getattr(p, 'queue_tier', None)
-                            ),
-                            'llm_request_options': dict(getattr(p, 'llm_request_options', None) or {}),
-                            'tool_policy': dict(getattr(p, 'tool_policy', None) or {}),
-                            'context_policy': self.normalize_context_policy(
-                                getattr(p, 'context_policy', None),
-                                getattr(p, 'agent_role', None),
-                            ),
-                        }
-                        for p in prompts
-                    ]
+                    'prompts': prompt_items
                 })
 
             return {'message': categorized_prompts}
@@ -686,10 +727,43 @@ class PromptService:
         tool_policy = self._normalize_tool_policy(data.get("tool_policy"))
 
         # 2. update the prompt in the database
-        raw_agent_role = data.get('agent_role')
-        agent_role = self._normalize_agent_role(raw_agent_role)
-        execution_mode = self.execution_mode_for_agent_role(agent_role)
-        force_free_text_output = raw_agent_role is not None and self.should_force_free_text_output(agent_role)
+        raw_runtime_policy = data.get("runtime_policy")
+        runtime_policy_explicit = isinstance(raw_runtime_policy, dict)
+        if runtime_policy_explicit:
+            runtime_policy = self.normalize_runtime_policy(raw_runtime_policy)
+        else:
+            existing_runtime_policy = self.normalize_runtime_policy(
+                getattr(existing_prompt, "runtime_policy", None)
+                if existing_prompt is not None else None
+            )
+            role_value = data.get(
+                "agent_role",
+                getattr(existing_prompt, "agent_role", existing_runtime_policy["role"])
+                if existing_prompt is not None else existing_runtime_policy["role"],
+            )
+            queue_tier_value = data.get(
+                "queue_tier",
+                getattr(existing_prompt, "queue_tier", existing_runtime_policy["queue_tier"])
+                if existing_prompt is not None else existing_runtime_policy["queue_tier"],
+            )
+            if "context_policy" in data:
+                context_value = data.get("context_policy")
+            elif "agent_role" in data:
+                context_value = None
+            else:
+                context_value = (
+                    getattr(existing_prompt, "context_policy", existing_runtime_policy["context"])
+                    if existing_prompt is not None else existing_runtime_policy["context"]
+                )
+            runtime_policy = self.normalize_runtime_policy({
+                "role": role_value,
+                "queue_tier": queue_tier_value,
+                "context": context_value,
+            })
+        agent_role = runtime_policy["role"]
+        force_free_text_output = (
+            runtime_policy_explicit or "agent_role" in data
+        ) and self.should_force_free_text_output(agent_role)
 
         new_prompt = Prompt(
             company_id=company.id,
@@ -698,8 +772,6 @@ class PromptService:
             order=data.get('order', 1),
             category_id=category_id,
             active=data.get('active', True),
-            agent_role=agent_role,
-            execution_mode=execution_mode,
             filename=f"{prompt_name.lower().replace(' ', '_')}.prompt",
             custom_fields=data.get('custom_fields', []),
             output_schema=None if force_free_text_output else output_schema,
@@ -724,17 +796,9 @@ class PromptService:
                 data.get("attachment_fallback", company_default_policy["attachment_fallback"])
             ),
             llm_model=self._normalize_llm_model(company_short_name, data.get("llm_model")),
-            queue_tier=self._normalize_queue_tier(
-                data.get("queue_tier")
-                if "queue_tier" in data
-                else getattr(existing_prompt, "queue_tier", None)
-            ),
             llm_request_options=llm_request_options,
             tool_policy=tool_policy,
-            context_policy=self.normalize_context_policy(
-                data.get("context_policy"),
-                agent_role,
-            ),
+            runtime_policy=runtime_policy,
         )
         self.llm_query_repo.create_or_update_prompt(new_prompt)
 
@@ -966,9 +1030,9 @@ class PromptService:
                 filename = f"{prompt_name}.prompt"
                 normalized_schema = StructuredOutputService.normalize_schema(prompt_data.get("output_schema"))
 
-                raw_agent_role = prompt_data.get('agent_role')
-                agent_role = self._normalize_agent_role(raw_agent_role)
-                force_free_text_output = raw_agent_role is not None and self.should_force_free_text_output(agent_role)
+                runtime_policy = self.normalize_runtime_policy(prompt_data.get("runtime_policy"))
+                agent_role = runtime_policy["role"]
+                force_free_text_output = self.should_force_free_text_output(agent_role)
                 new_prompt = Prompt(
                     company_id=company.id,
                     name=prompt_name,
@@ -976,8 +1040,6 @@ class PromptService:
                     order=prompt_data.get('order'),
                     category_id=category_obj.id if category_obj else None,
                     active=prompt_data.get('active', True),
-                    agent_role=agent_role,
-                    execution_mode=self.execution_mode_for_agent_role(agent_role),
                     filename=filename,
                     custom_fields=prompt_data.get('custom_fields', []),
                     output_schema=None if force_free_text_output else normalized_schema,
@@ -1006,15 +1068,11 @@ class PromptService:
                         prompt_data.get("attachment_fallback", company_default_policy["attachment_fallback"])
                     ),
                     llm_model=self._normalize_llm_model(company_short_name, prompt_data.get("llm_model")),
-                    queue_tier=self._normalize_queue_tier(prompt_data.get("queue_tier")),
                     llm_request_options=self._normalize_llm_request_options(
                         self._extract_llm_request_options_payload(prompt_data)
                     ),
                     tool_policy=self._normalize_tool_policy(prompt_data.get("tool_policy")),
-                    context_policy=self.normalize_context_policy(
-                        prompt_data.get("context_policy"),
-                        agent_role,
-                    ),
+                    runtime_policy=runtime_policy,
                 )
 
                 self.llm_query_repo.create_or_update_prompt(new_prompt)

{iatoolkit-2.32.0 → iatoolkit-2.32.1}/src/iatoolkit/services/query_service.py

@@ -273,26 +273,22 @@ class QueryService:
             contract["attachment_mode"] = (
                 str(raw_attachment_mode).strip().lower() if raw_attachment_mode is not None else None
             )
-            raw_execution_mode = contract.get("execution_mode")
-            normalized_execution_mode = (
-                str(raw_execution_mode).strip().lower()
-                if raw_execution_mode is not None else "conversational"
-            )
-            if normalized_execution_mode not in {"conversational", "agentic"}:
-                normalized_execution_mode = "conversational"
-            contract["execution_mode"] = normalized_execution_mode
-            raw_agent_role = contract.get("agent_role")
-            normalized_agent_role = (
-                str(raw_agent_role).strip().lower()
-                if raw_agent_role is not None else "workspace_chat"
-            )
-            if normalized_agent_role not in {"workspace_chat", "workspace_agent", "channels", "operations"}:
-                normalized_agent_role = "workspace_chat"
+            raw_runtime_policy = contract.get("runtime_policy")
+            if isinstance(raw_runtime_policy, dict):
+                runtime_policy = PromptService.normalize_runtime_policy(raw_runtime_policy)
+                runtime_role_explicit = True
+            else:
+                runtime_policy = PromptService.normalize_runtime_policy({
+                    "role": contract.get("agent_role"),
+                    "queue_tier": contract.get("queue_tier"),
+                    "context": contract.get("context_policy"),
+                })
+                runtime_role_explicit = contract.get("agent_role") is not None
+            normalized_agent_role = runtime_policy["role"]
+            contract["runtime_policy"] = runtime_policy
             contract["agent_role"] = normalized_agent_role
-            contract["execution_mode"] = (
-                "conversational" if normalized_agent_role == "workspace_chat" else "agentic"
-            )
-            if raw_agent_role is not None and normalized_agent_role in {"workspace_chat", "channels"}:
+            contract["execution_mode"] = PromptService.execution_mode_for_agent_role(normalized_agent_role)
+            if runtime_role_explicit and normalized_agent_role in {"workspace_chat", "channels"}:
                 contract["response_mode"] = "chat_compatible"
                 contract["schema"] = None
                 contract["schema_mode"] = "best_effort"
@@ -342,10 +338,7 @@ class QueryService:
                     })
             contract["resource_bindings"] = normalized_resource_bindings
             contract["tool_policy"] = self._normalize_prompt_tool_policy(contract.get("tool_policy"))
-            contract["context_policy"] = PromptService.normalize_context_policy(
-                contract.get("context_policy"),
-                contract.get("agent_role"),
-            )
+            contract["context_policy"] = runtime_policy["context"]
             contract["provider"] = self._get_provider(company.short_name, contract.get("llm_model") or "")
             return contract
         except Exception as e:

{iatoolkit-2.32.0 → iatoolkit-2.32.1}/src/iatoolkit/views/prompt_api_view.py

@@ -48,9 +48,17 @@ class PromptApiView(MethodView):
 
                 # get the prompt content
                 content = self.prompt_service.get_prompt_content(company, prompt_name)
+                meta = prompt_obj.to_dict()
+                runtime_policy = PromptService.normalize_runtime_policy(meta.get("runtime_policy"))
+                agent_role = runtime_policy["role"]
+                meta["runtime_policy"] = runtime_policy
+                meta["agent_role"] = agent_role
+                meta["execution_mode"] = PromptService.execution_mode_for_agent_role(agent_role)
+                meta["queue_tier"] = runtime_policy["queue_tier"]
+                meta["context_policy"] = runtime_policy["context"]
 
                 return jsonify({
-                    "meta": prompt_obj.to_dict(),
+                    "meta": meta,
                     "content": content
                 })
             else:

{iatoolkit-2.32.0 → iatoolkit-2.32.1/src/iatoolkit.egg-info}/PKG-INFO

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