iatoolkit 2.76.10__tar.gz → 2.77.1__tar.gz

{iatoolkit-2.76.10/src/iatoolkit.egg-info → iatoolkit-2.77.1}/PKG-INFO

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

{iatoolkit-2.76.10 → iatoolkit-2.77.1}/src/iatoolkit/__init__.py

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

{iatoolkit-2.76.10 → iatoolkit-2.77.1}/src/iatoolkit/common/access.py

@@ -29,6 +29,8 @@ from __future__ import annotations
 import logging
 from typing import Callable, Protocol
 
+from iatoolkit.common.decision_types import chat_models, is_decision_model
+
 USE = 1
 EDIT = 2
 ADMIN = 3
@@ -181,11 +183,16 @@ def filter_llm_models(company_short_name: str, user_identifier: str | None, defa
     """The chat's model choice limited to the models this person may use (BL-010, Fase 2).
 
     When the company's default is not among them, the first one they may use becomes
-    their default."""
+    their default. Decision models (BL-008) never reach the chat: they answer
+    questions about a case, not messages."""
+    decision_ids = {str(m.get("id") or "") for m in models or [] if isinstance(m, dict) and is_decision_model(m)}
+    models = chat_models(models)
+    if default_model in decision_ids:
+        default_model = str((models[0] or {}).get("id") or "") or None if models else None
     if not user_identifier or not Access.registered():
         return default_model, models
-    allowed = [m for m in models or [] if can(company_short_name, user_identifier, USE, "model",
-                                              str((m or {}).get("id") or ""))]
+    allowed = [m for m in models if can(company_short_name, user_identifier, USE, "model",
+                                        str((m or {}).get("id") or ""))]
     allowed_ids = [str(m.get("id")) for m in allowed]
     if default_model and default_model not in allowed_ids:
         default_model = allowed_ids[0] if allowed_ids else None

iatoolkit-2.77.1/src/iatoolkit/common/decision_types.py

@@ -0,0 +1,376 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+"""Types of a decision model call (BL-008).
+
+A decision model does not write text: it answers a fixed set of questions about
+a case (the `state`) with calibrated probabilities. The contract is the one
+OpenRouter serves at `/api/alpha/decisions` for every decision model, and it is
+copied here as is, without a translation layer: questions travel as a map
+`{name: question}`, and each answer comes back under the same name.
+
+Only three question types are supported: `noul` (yes/no), `choice` (one of a set
+of options) and `score` (an ordered scale). The API also has `box`, a bounding
+box over an image, which needs `assets` and is out of the first stage.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Any
+
+QUESTION_NOUL = "noul"
+QUESTION_CHOICE = "choice"
+QUESTION_SCORE = "score"
+QUESTION_TYPES = (QUESTION_NOUL, QUESTION_CHOICE, QUESTION_SCORE)
+
+# Same shape as a tool argument name: the answers come back keyed by it, and the
+# agent's structured output exposes them under it.
+_QUESTION_NAME_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]{0,63}$")
+MAX_QUESTIONS = 20
+
+
+DECISION_MODEL_KIND = "decision"
+
+
+def model_kind(model_config: dict | None) -> str:
+    """The kind of model a configuration describes: "decision", or "" for chat.
+
+    Comes from the catalogue (`capabilities.kind`, written by `models-sync`); a
+    company.yaml entry outside the catalogue may state it at the top level.
+    """
+    if not isinstance(model_config, dict):
+        return ""
+    capabilities = model_config.get("capabilities")
+    kind = capabilities.get("kind") if isinstance(capabilities, dict) else None
+    return str(kind or model_config.get("kind") or "").strip().lower()
+
+
+def is_decision_model(model_config: dict | None) -> bool:
+    return model_kind(model_config) == DECISION_MODEL_KIND
+
+
+def chat_models(models: list | None) -> list:
+    """The models that write text: everything but decision models.
+
+    A company enables decision models like any other, so they are in its list
+    of models; but they cannot hold a conversation, so every place that picks a
+    model to chat with (the chat selector, the default, system agents) skips them.
+    """
+    return [model for model in models or [] if not (isinstance(model, dict) and is_decision_model(model))]
+
+
+class DecisionSpecError(ValueError):
+    """A decision spec that cannot be sent: the message names the field."""
+
+
+@dataclass(frozen=True)
+class DecisionQuestion:
+    name: str
+    type: str
+    instructions: str
+    #: `noul`: optional {"true": ..., "false": ...}; `choice`: {option: description};
+    #: `score`: list of level descriptions, index 0 first.
+    criteria: dict[str, str] | list[str] | None = None
+
+    def to_wire(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {"type": self.type, "instructions": self.instructions}
+        if self.criteria:
+            payload["criteria"] = self.criteria
+        return payload
+
+
+def _clean_text(value: Any) -> str:
+    return str(value if value is not None else "").strip()
+
+
+def parse_question(name: str, raw: Any) -> DecisionQuestion:
+    if not isinstance(name, str) or not _QUESTION_NAME_RE.match(name):
+        raise DecisionSpecError(
+            f"Question name '{name}' is invalid: use letters, digits and '_', starting with a letter."
+        )
+    if not isinstance(raw, dict):
+        raise DecisionSpecError(f"Question '{name}' must be an object.")
+
+    question_type = _clean_text(raw.get("type")).lower()
+    if question_type not in QUESTION_TYPES:
+        raise DecisionSpecError(
+            f"Question '{name}' has type '{question_type}'; expected one of {', '.join(QUESTION_TYPES)}."
+        )
+
+    instructions = _clean_text(raw.get("instructions"))
+    if not instructions:
+        raise DecisionSpecError(f"Question '{name}' needs 'instructions'.")
+
+    raw_criteria = raw.get("criteria")
+    criteria: dict[str, str] | list[str] | None = None
+
+    if question_type == QUESTION_NOUL:
+        if raw_criteria not in (None, {}, ""):
+            if not isinstance(raw_criteria, dict):
+                raise DecisionSpecError(f"Question '{name}': 'criteria' of a noul is {{true, false}}.")
+            unknown = set(str(key).lower() for key in raw_criteria) - {"true", "false"}
+            if unknown:
+                raise DecisionSpecError(
+                    f"Question '{name}': noul criteria only accept 'true' and 'false'."
+                )
+            criteria = {
+                str(key).lower(): _clean_text(value)
+                for key, value in raw_criteria.items()
+                if _clean_text(value)
+            } or None
+
+    elif question_type == QUESTION_CHOICE:
+        if not isinstance(raw_criteria, dict) or len(raw_criteria) < 2:
+            raise DecisionSpecError(
+                f"Question '{name}': a choice needs 'criteria' with at least two options."
+            )
+        criteria = {}
+        for option, description in raw_criteria.items():
+            option_name = _clean_text(option)
+            option_description = _clean_text(description)
+            if not option_name:
+                raise DecisionSpecError(f"Question '{name}': an option has no name.")
+            if not option_description:
+                raise DecisionSpecError(f"Question '{name}': option '{option_name}' needs a description.")
+            criteria[option_name] = option_description
+
+    else:  # score
+        if not isinstance(raw_criteria, list) or len(raw_criteria) < 2:
+            raise DecisionSpecError(
+                f"Question '{name}': a score needs 'criteria' as a list of at least two levels."
+            )
+        criteria = [_clean_text(level) for level in raw_criteria]
+        if any(not level for level in criteria):
+            raise DecisionSpecError(f"Question '{name}': every score level needs a description.")
+
+    return DecisionQuestion(name=name, type=question_type, instructions=instructions, criteria=criteria)
+
+
+def parse_decision_spec(spec: Any) -> dict[str, DecisionQuestion]:
+    """The questions of a decision spec, validated; raises DecisionSpecError.
+
+    The spec is `{"questions": {name: question}}`. It is validated in code before
+    any call because the API answers a bad question with a 400 that only names
+    the field path, after a network round trip.
+    """
+    if not isinstance(spec, dict):
+        raise DecisionSpecError("The decision spec must be an object with 'questions'.")
+    raw_questions = spec.get("questions")
+    if not isinstance(raw_questions, dict) or not raw_questions:
+        raise DecisionSpecError("The decision spec needs at least one question.")
+    if len(raw_questions) > MAX_QUESTIONS:
+        raise DecisionSpecError(f"A decision spec accepts at most {MAX_QUESTIONS} questions.")
+    return {name: parse_question(name, raw) for name, raw in raw_questions.items()}
+
+
+def normalize_decision_spec(spec: Any, *, allow_empty: bool = False) -> dict[str, Any]:
+    """The spec as it is stored: validated questions, in their order.
+
+    `allow_empty` is for saving: a decision agent exists from the moment it is
+    created, before anyone has written its questions. Running one still needs
+    at least one (`parse_decision_spec`).
+    """
+    if allow_empty and isinstance(spec, dict) and not spec.get("questions"):
+        return {"questions": {}}
+    questions = parse_decision_spec(spec)
+    return {"questions": {name: question.to_wire() for name, question in questions.items()}}
+
+
+def decision_output_schema(spec: Any) -> dict[str, Any]:
+    """The JSON Schema of a decision agent's answers, derived from its questions.
+
+    Describes `DecisionResult.answers_dict()`: one property per question, whose
+    `value` is the answer itself (a boolean for noul, one of the options for
+    choice, the 0-based weighted average for score). Published as the agent's
+    MCP `outputSchema`, so a client knows the shape before calling. Questions
+    that do not validate are left out rather than failing the whole catalogue.
+    """
+    try:
+        questions = parse_decision_spec(spec)
+    except DecisionSpecError:
+        questions = {}
+    probability = {"type": "number", "minimum": 0, "maximum": 1}
+    properties: dict[str, Any] = {}
+    for name, question in questions.items():
+        if question.type == QUESTION_NOUL:
+            value = {"type": ["boolean", "null"], "description": "true = sí, false = no."}
+            probabilities = {
+                "type": "object",
+                "properties": {"true": probability, "false": probability},
+            }
+            extra: dict[str, Any] = {}
+        elif question.type == QUESTION_CHOICE:
+            options = list(question.criteria or {})
+            value = {"type": ["string", "null"], "enum": options + [None]}
+            probabilities = {
+                "type": "object",
+                "properties": {option: probability for option in options},
+            }
+            extra = {}
+        else:
+            levels = list(question.criteria or [])
+            value = {
+                "type": ["number", "null"],
+                "minimum": 0,
+                "maximum": max(len(levels) - 1, 0),
+                "description": "Weighted average of the levels; 0 is the first one.",
+            }
+            probabilities = {
+                "type": "object",
+                "properties": {str(index): probability for index in range(len(levels))},
+            }
+            extra = {"legend": {"type": "object", "additionalProperties": {"type": "string"}}}
+        properties[name] = {
+            "type": "object",
+            "description": question.instructions,
+            "properties": {
+                "type": {"type": "string", "const": question.type},
+                "value": value,
+                "confidence": {"type": ["number", "null"], "minimum": 0, "maximum": 1},
+                "probabilities": probabilities,
+                **extra,
+            },
+            "required": ["type", "value", "confidence", "probabilities"],
+        }
+    return {
+        "type": "object",
+        "properties": properties,
+        "required": list(properties),
+    }
+
+
+@dataclass(frozen=True)
+class DecisionAnswer:
+    name: str
+    type: str
+    #: The answer itself: `True`/`False` for noul, the option for choice, the
+    #: weighted average (0-based) for score.
+    value: Any
+    confidence: float | None
+    probabilities: dict[str, float] = field(default_factory=dict)
+    legend: dict[str, str] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "type": self.type,
+            "value": self.value,
+            "confidence": self.confidence,
+            "probabilities": dict(self.probabilities),
+        }
+        if self.legend:
+            payload["legend"] = dict(self.legend)
+        return payload
+
+
+def _as_float(value: Any) -> float | None:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def parse_answer(name: str, raw: Any) -> DecisionAnswer:
+    raw = raw if isinstance(raw, dict) else {}
+    answer_type = _clean_text(raw.get("type")).lower()
+    probabilities = {
+        str(key): float(value)
+        for key, value in (raw.get("probabilities") or {}).items()
+        if _as_float(value) is not None
+    }
+
+    if answer_type == QUESTION_NOUL:
+        # A noul answer carries only p(true); its confidence is not in the
+        # response, so it is derived the same way for every model: how far p
+        # is from a coin toss.
+        p_true = _as_float(raw.get("noul"))
+        if p_true is None:
+            return DecisionAnswer(name=name, type=answer_type, value=None, confidence=None)
+        return DecisionAnswer(
+            name=name,
+            type=answer_type,
+            value=p_true >= 0.5,
+            confidence=round(abs(2 * p_true - 1), 6),
+            probabilities={"true": p_true, "false": round(1 - p_true, 6)},
+        )
+
+    if answer_type == QUESTION_SCORE:
+        legend = {str(key): _clean_text(value) for key, value in (raw.get("legend") or {}).items()}
+        return DecisionAnswer(
+            name=name,
+            type=answer_type,
+            value=_as_float(raw.get("score")),
+            confidence=_as_float(raw.get("confidence")),
+            probabilities=probabilities,
+            legend=legend,
+        )
+
+    return DecisionAnswer(
+        name=name,
+        type=answer_type or QUESTION_CHOICE,
+        value=raw.get("choice"),
+        confidence=_as_float(raw.get("confidence")),
+        probabilities=probabilities,
+    )
+
+
+@dataclass(frozen=True)
+class DecisionResult:
+    answers: dict[str, DecisionAnswer]
+    #: The dated model that answered (`typesafe/jev-1.14-20261014`), not the key asked for.
+    model: str
+    provider: str | None
+    response_id: str | None
+    input_tokens: int
+    output_tokens: int
+    cost_usd: float | None
+    latency_ms: int
+
+    @classmethod
+    def from_response(cls, body: dict[str, Any], *, requested_model: str, latency_ms: int) -> "DecisionResult":
+        usage = body.get("usage") if isinstance(body.get("usage"), dict) else {}
+        raw_answers = body.get("answers") if isinstance(body.get("answers"), dict) else {}
+        return cls(
+            answers={name: parse_answer(name, raw) for name, raw in raw_answers.items()},
+            model=_clean_text(body.get("model")) or requested_model,
+            provider=_clean_text(body.get("provider")) or None,
+            response_id=_clean_text(body.get("id")) or None,
+            input_tokens=int(_as_float(usage.get("input_tokens")) or 0),
+            output_tokens=int(_as_float(usage.get("output_tokens")) or 0),
+            cost_usd=_as_float(usage.get("cost")),
+            latency_ms=int(latency_ms),
+        )
+
+    def answers_dict(self) -> dict[str, Any]:
+        return {name: answer.to_dict() for name, answer in self.answers.items()}
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "answers": self.answers_dict(),
+            "model": self.model,
+            "provider": self.provider,
+            "response_id": self.response_id,
+            "usage": {
+                "input_tokens": self.input_tokens,
+                "output_tokens": self.output_tokens,
+                "cost_usd": self.cost_usd,
+            },
+            "latency_ms": self.latency_ms,
+        }
+
+    def summary_text(self) -> str:
+        """One line per question, for the places that show text (history, logs)."""
+        lines = []
+        for name, answer in self.answers.items():
+            confidence = "" if answer.confidence is None else f" (confianza {answer.confidence:.2f})"
+            if answer.type == QUESTION_NOUL:
+                value = "sí" if answer.value else "no"
+            elif answer.type == QUESTION_SCORE and answer.value is not None:
+                value = f"{answer.value:.2f}"
+            else:
+                value = str(answer.value)
+            lines.append(f"{name}: {value}{confidence}")
+        return "\n".join(lines)

{iatoolkit-2.76.10 → iatoolkit-2.77.1}/src/iatoolkit/infra/llm_proxy.py

@@ -180,6 +180,25 @@ class LLMProxy:
             **request_kwargs,
         )
 
+    def resolve_client_config(
+        self,
+        company_short_name: str,
+        provider: str,
+        model_config: Dict[str, Any] | None = None,
+    ) -> dict:
+        """The credentials, endpoint, headers and timeouts a call to `provider` uses.
+
+        Public for the callers that reach a provider outside the chat adapters —
+        the decision models (BL-008) are served by OpenRouter on an endpoint the
+        OpenAI SDK does not speak — so they pay with the same key, through the
+        same gateway and with the same timeouts as every other call.
+        """
+        return self._get_client_config(company_short_name, provider, model_config=model_config)
+
+    @staticmethod
+    def wire_model(model: str, model_config: Dict[str, Any] | None) -> str:
+        return LLMProxy._wire_model(model, model_config)
+
     def describe_transport(self, company_short_name: str, model: str) -> str:
         provider = self._resolve_provider_for_company_model(
             company_short_name=company_short_name,

iatoolkit-2.77.1/src/iatoolkit/infra/openrouter_decision_client.py

@@ -0,0 +1,177 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+"""HTTP client for OpenRouter's decision models (BL-008).
+
+Decision models are not served by the chat completions API, so the OpenAI SDK
+the proxy uses for OpenRouter cannot call them: this is a plain HTTP call to
+`/api/alpha/decisions`. Credentials, endpoint and timeouts are the ones the
+company already has for `openrouter`, resolved by `LLMProxy`.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any
+from urllib.parse import urlsplit
+
+import httpx
+
+from iatoolkit.common.decision_types import DecisionQuestion, DecisionResult
+from iatoolkit.common.exceptions import IAToolkitException
+
+DEFAULT_DECISIONS_PATH = "/api/alpha/decisions"
+DEFAULT_BASE_URL = "https://openrouter.ai/api/v1"
+RETRYABLE_STATUS = {408, 429, 500, 502, 503, 504}
+DEFAULT_RETRY_ATTEMPTS = 2
+RETRY_BACKOFF_SECONDS = 0.5
+
+
+class OpenRouterDecisionClient:
+
+    def __init__(self, http_client: httpx.Client | None = None, sleep=time.sleep):
+        self._http_client = http_client
+        self._sleep = sleep
+
+    @staticmethod
+    def decisions_url(base_url: str | None, path: str | None = None) -> str:
+        """The decisions endpoint on the company's OpenRouter host.
+
+        The configured `base_url` is the chat one (`https://openrouter.ai/api/v1`);
+        the decisions router lives on the same host under its own path, so only
+        the origin is kept. A gateway in front of OpenRouter keeps working as long
+        as it forwards that path.
+        """
+        parts = urlsplit(str(base_url or DEFAULT_BASE_URL).strip() or DEFAULT_BASE_URL)
+        origin = f"{parts.scheme or 'https'}://{parts.netloc or 'openrouter.ai'}"
+        decision_path = str(path or DEFAULT_DECISIONS_PATH).strip() or DEFAULT_DECISIONS_PATH
+        if not decision_path.startswith("/"):
+            decision_path = f"/{decision_path}"
+        return f"{origin}{decision_path}"
+
+    def decide(
+        self,
+        *,
+        api_key: str,
+        url: str,
+        model: str,
+        state: Any,
+        questions: dict[str, DecisionQuestion],
+        provider_policy: dict[str, Any] | None = None,
+        default_headers: dict[str, str] | None = None,
+        connect_timeout_seconds: float = 10.0,
+        read_timeout_seconds: float = 60.0,
+        retry_attempts: int = DEFAULT_RETRY_ATTEMPTS,
+        user: str | None = None,
+    ) -> DecisionResult:
+        payload: dict[str, Any] = {
+            "model": model,
+            "state": state,
+            "questions": {name: question.to_wire() for name, question in questions.items()},
+        }
+        if provider_policy:
+            payload["provider"] = dict(provider_policy)
+        if user:
+            payload["user"] = user
+
+        headers = dict(default_headers or {})
+        headers["Authorization"] = f"Bearer {api_key}"
+        headers["Content-Type"] = "application/json"
+        timeout = httpx.Timeout(read_timeout_seconds, connect=connect_timeout_seconds)
+
+        attempts = max(0, int(retry_attempts)) + 1
+        started = time.monotonic()
+        last_error: str | None = None
+        for attempt in range(1, attempts + 1):
+            try:
+                response = self._post(url, payload, headers, timeout)
+            except httpx.HTTPError as exc:
+                last_error = f"{type(exc).__name__}: {exc}"
+                if attempt < attempts:
+                    self._backoff(attempt)
+                    continue
+                raise IAToolkitException(
+                    IAToolkitException.ErrorType.LLM_ERROR,
+                    f"Decision model '{model}' could not be reached: {last_error}",
+                ) from exc
+
+            if response.status_code == 200:
+                body = self._json_body(response)
+                if not isinstance(body, dict) or not isinstance(body.get("answers"), dict):
+                    raise IAToolkitException(
+                        IAToolkitException.ErrorType.LLM_ERROR,
+                        f"Decision model '{model}' returned a response without answers.",
+                    )
+                latency_ms = int((time.monotonic() - started) * 1000)
+                return DecisionResult.from_response(body, requested_model=model, latency_ms=latency_ms)
+
+            message = self._error_message(response)
+            if response.status_code in RETRYABLE_STATUS and attempt < attempts:
+                logging.warning(
+                    "Decision model '%s' answered %s (attempt %s/%s): %s",
+                    model, response.status_code, attempt, attempts, message,
+                )
+                last_error = message
+                self._backoff(attempt)
+                continue
+            raise self._error_for(model, response.status_code, message)
+
+        raise IAToolkitException(  # pragma: no cover - the loop always returns or raises
+            IAToolkitException.ErrorType.LLM_ERROR,
+            f"Decision model '{model}' failed: {last_error}",
+        )
+
+    def _post(self, url: str, payload: dict, headers: dict, timeout: httpx.Timeout) -> httpx.Response:
+        if self._http_client is not None:
+            return self._http_client.post(url, json=payload, headers=headers, timeout=timeout)
+        with httpx.Client(timeout=timeout) as client:
+            return client.post(url, json=payload, headers=headers)
+
+    def _backoff(self, attempt: int) -> None:
+        self._sleep(RETRY_BACKOFF_SECONDS * (2 ** (attempt - 1)))
+
+    @staticmethod
+    def _json_body(response: httpx.Response) -> Any:
+        try:
+            return response.json()
+        except ValueError:
+            return None
+
+    @classmethod
+    def _error_message(cls, response: httpx.Response) -> str:
+        body = cls._json_body(response)
+        if isinstance(body, dict):
+            error = body.get("error")
+            if isinstance(error, dict) and error.get("message"):
+                return str(error["message"])
+            if isinstance(error, str):
+                return error
+        return (response.text or "").strip()[:300] or f"HTTP {response.status_code}"
+
+    @staticmethod
+    def _error_for(model: str, status_code: int, message: str) -> IAToolkitException:
+        if status_code == 404:
+            # What a data policy that leaves no endpoint looks like: OpenRouter
+            # found the model but no provider serving it under the policy sent.
+            return IAToolkitException(
+                IAToolkitException.ErrorType.MODEL,
+                f"Decision model '{model}' is not available under the company's data policy "
+                f"(llm.decisions.provider): {message}",
+            )
+        if status_code in (401, 403):
+            return IAToolkitException(
+                IAToolkitException.ErrorType.API_KEY,
+                f"OpenRouter refused the credentials for decision model '{model}': {message}",
+            )
+        if status_code == 400:
+            return IAToolkitException(
+                IAToolkitException.ErrorType.INVALID_PARAMETER,
+                f"Decision model '{model}' rejected the request: {message}",
+            )
+        return IAToolkitException(
+            IAToolkitException.ErrorType.LLM_ERROR,
+            f"Decision model '{model}' failed with HTTP {status_code}: {message}",
+        )

{iatoolkit-2.76.10 → iatoolkit-2.77.1}/src/iatoolkit/repositories/llm_query_repo.py

@@ -232,6 +232,7 @@ class LLMQueryRepo:
                 dict(getattr(new_prompt, "runtime_policy", None) or {})
                 or dict(getattr(prompt, "runtime_policy", None) or {})
             )
+            prompt.decision_spec = getattr(new_prompt, "decision_spec", None)
         else:
             if new_prompt.active is None:
                 new_prompt.active = True

{iatoolkit-2.76.10 → iatoolkit-2.77.1}/src/iatoolkit/repositories/models.py

@@ -1070,11 +1070,23 @@ class Prompt(Base):
     llm_request_options = Column(JSON_NATIVE, nullable=False, default=dict)
     tool_policy = Column(JSON_NATIVE, nullable=False, default=dict)
     runtime_policy = Column(JSON_NATIVE, nullable=False, default=dict)
+    #: The questions of a decision agent (BL-008), as
+    #: {"questions": {name: {type, instructions, criteria}}}. Non-null marks the
+    #: agent as a decision agent: its template renders the case a decision model
+    #: answers these questions about. Set when the agent is created; NULL for
+    #: every conversational agent.
+    #: `none_as_null`: a conversational agent stores SQL NULL, not JSON `null`,
+    #: so `decision_spec IS NULL` reads the type from SQL too.
+    decision_spec = Column(JSON(none_as_null=True), nullable=True, default=None)
     created_at = Column(DateTime, default=datetime.now)
 
     def to_dict(self):
         return {column.key: getattr(self, column.key) for column in class_mapper(self.__class__).columns}
 
+    @property
+    def is_decision_agent(self) -> bool:
+        return isinstance(self.decision_spec, dict)
+
     company = relationship("Company", back_populates="prompts")
     category = relationship("PromptCategory", back_populates="prompts")
     resource_bindings = relationship(