iatoolkit 2.76.1__tar.gz → 2.76.3__tar.gz

{iatoolkit-2.76.1/src/iatoolkit.egg-info → iatoolkit-2.76.3}/PKG-INFO

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

{iatoolkit-2.76.1 → iatoolkit-2.76.3}/src/iatoolkit/__init__.py

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

{iatoolkit-2.76.1 → iatoolkit-2.76.3}/src/iatoolkit/repositories/database_manager.py

@@ -394,11 +394,17 @@ class DatabaseManager(DatabaseProvider):
 
     # -- schema methods ----
     @staticmethod
-    def _safe_inspector_name_list(fetcher, schema: str | None) -> list[str]:
+    def _safe_inspector_name_list(fetcher, schema: str | None, *, required: bool = False) -> list[str]:
+        """The names a listing returns. `required` (the tables) raises when it fails: an
+        empty answer would read as "this source has no tables" when the connection, the
+        schema or the user's grants are wrong. Views stay optional, as some engines
+        cannot list them."""
         try:
             names = fetcher(schema=schema)
         except Exception as e:
             logging.warning("Could not list schema objects for schema %s: %s", schema, e)
+            if required:
+                raise
             return []
 
         if not isinstance(names, list):
@@ -421,7 +427,7 @@ class DatabaseManager(DatabaseProvider):
         schema_objects: list[tuple[str, str]] = []
         schema_objects.extend(
             (table_name, "table")
-            for table_name in self._safe_inspector_name_list(inspector.get_table_names, effective_schema)
+            for table_name in self._safe_inspector_name_list(inspector.get_table_names, effective_schema, required=True)
         )
         schema_objects.extend(
             (view_name, "view")

{iatoolkit-2.76.1 → iatoolkit-2.76.3}/src/iatoolkit/services/history_manager_service.py

@@ -68,6 +68,11 @@ class HistoryManagerService:
     #: one a follow-up ("of those...") refers to; with two, one turn of 80k of
     #: results kept a compacted history at 130k.
     KEEP_TOOL_OUTPUT_TURNS = 1
+    #: ...unless what that turn carries for its tools (outputs, arguments and
+    #: reasoning) passes this: a turn of eight SQL rounds left 142k tokens for a
+    #: follow-up answered from the conversation in 5 seconds. Its answer stays,
+    #: and the model can call the tools again.
+    MAX_KEPT_TOOL_PAYLOAD_CHARS = 40000
     #: What is kept of a cut output: its beginning, enough to remember its shape.
     TRIMMED_TOOL_OUTPUT_CHARS = 1500
     TRIMMED_TOOL_OUTPUT_MARKER = "[tool output trimmed"
@@ -405,9 +410,13 @@ class HistoryManagerService:
         then stays the same from turn to turn, which is what a prompt cache reuses.
         """
         turn_starts = cls.turn_starts(context_history)
-        if len(turn_starts) <= cls.KEEP_TOOL_OUTPUT_TURNS:
+        if len(turn_starts) < cls.KEEP_TOOL_OUTPUT_TURNS or not turn_starts:
             return
         boundary = turn_starts[-cls.KEEP_TOOL_OUTPUT_TURNS]
+        kept_payload = cls._tool_payload_chars(context_history[boundary:])
+        if kept_payload > cls.MAX_KEPT_TOOL_PAYLOAD_CHARS:
+            logging.info(f"Last turn carries {kept_payload} characters for its tools: cut as an older turn.")
+            boundary = len(context_history)
         tool_names = {}
         for message in context_history[:boundary]:
             if not isinstance(message, dict):
@@ -438,6 +447,24 @@ class HistoryManagerService:
                 f"Call {tool} again if you need all of it.]"
             )
 
+    @staticmethod
+    def _tool_payload_chars(messages: list) -> int:
+        """Characters of tool outputs, tool call arguments and reasoning in these messages."""
+        total = 0
+        for message in messages:
+            if not isinstance(message, dict):
+                continue
+            if message.get("type") == "function_call_output" and isinstance(message.get("output"), str):
+                total += len(message["output"])
+            total += len(str(message.get("reasoning_content") or ""))
+            if message.get("reasoning_details"):
+                total += len(json.dumps(message["reasoning_details"], default=str))
+            for call in message.get("tool_calls") or []:
+                function = call.get("function") if isinstance(call, dict) else None
+                if isinstance(function, dict) and isinstance(function.get("arguments"), str):
+                    total += len(function["arguments"])
+        return total
+
     def _cap_stored_history(self, company_short_name: str, model: Optional[str], context_history: list):
         """Keeps the stored history under STORED_HISTORY_MAX_BUDGETS budgets, whole turns at a time."""
         cap = self.context_budget_tokens(company_short_name, model) * self.STORED_HISTORY_MAX_BUDGETS

{iatoolkit-2.76.1 → iatoolkit-2.76.3}/src/iatoolkit/services/llm_client_service.py

@@ -1327,6 +1327,9 @@ class llmClient:
         response_mode = str(response_contract.get("response_mode") or "chat_compatible").strip().lower()
         provider = str(response_contract.get("provider") or "").strip().lower()
         allow_additional_property_repair = provider in {"deepseek", "openai_compatible"}
+        # In strict mode the provider got every optional field as nullable
+        # (StructuredOutputService.to_strict_schema): a null there means absent.
+        drop_optional_nulls = schema_mode == "strict"
         candidates: list[Any] = []
         seen: set[str] = set()
 
@@ -1354,7 +1357,9 @@ class llmClient:
         _add_candidate(decoded_response.get("output_text"))
 
         evaluations = [
-            StructuredOutputService.evaluate_output(raw_output=candidate, schema=schema)
+            StructuredOutputService.evaluate_output(
+                raw_output=candidate, schema=schema, drop_optional_nulls=drop_optional_nulls,
+            )
             for candidate in candidates
         ]
         repaired_evaluations = []
@@ -1363,6 +1368,7 @@ class llmClient:
                 StructuredOutputService.evaluate_output(
                     raw_output=candidate,
                     schema=schema,
+                    drop_optional_nulls=drop_optional_nulls,
                     drop_additional_properties=True,
                 )
                 for candidate in candidates
@@ -1372,6 +1378,7 @@ class llmClient:
             StructuredOutputService.evaluate_output(
                 raw_output=decoded_response.get("output_text"),
                 schema=schema,
+                drop_optional_nulls=drop_optional_nulls,
             )
         ]
         if allow_additional_property_repair:
@@ -1379,6 +1386,7 @@ class llmClient:
                 StructuredOutputService.evaluate_output(
                     raw_output=decoded_response.get("output_text"),
                     schema=schema,
+                    drop_optional_nulls=drop_optional_nulls,
                     drop_additional_properties=True,
                 )
             )

{iatoolkit-2.76.1 → iatoolkit-2.76.3}/src/iatoolkit/services/query_service.py

@@ -16,6 +16,7 @@ from iatoolkit.services.attachment_policy_service import AttachmentPolicyService
 from iatoolkit.services.memory_lookup_policy_service import MemoryLookupPolicyService
 from iatoolkit.services.telemetry_service import NoopTelemetryService
 from iatoolkit.services.prompt_service import PromptService
+from iatoolkit.services.structured_output_service import StructuredOutputService
 from iatoolkit.common.model_registry import ModelRegistry
 from iatoolkit.common.exceptions import IAToolkitException
 from injector import inject
@@ -844,12 +845,17 @@ class QueryService:
 
         provider = self._get_provider(company_short_name, model)
         schema_mode = str(contract.get("schema_mode") or "best_effort").strip().lower()
+        # Strict structured outputs only accept closed objects with every property
+        # required; a schema written with optional fields would get a 400. The
+        # provider gets that shape (optional fields nullable) and the answer is
+        # mapped back to the stored schema when it is validated.
+        provider_schema = StructuredOutputService.to_strict_schema(schema) if schema_mode == "strict" else schema
         if provider in ("openai", "xai"):
             return {
                 "format": {
                     "type": "json_schema",
                     "name": self._sanitize_schema_name(contract.get("prompt_name") or "prompt_output"),
-                    "schema": schema,
+                    "schema": provider_schema,
                     "strict": schema_mode == "strict",
                 }
             }
@@ -878,7 +884,7 @@ class QueryService:
                     "json_schema": {
                         "name": self._sanitize_schema_name(contract.get("prompt_name") or "prompt_output"),
                         "strict": schema_mode == "strict",
-                        "schema": schema,
+                        "schema": provider_schema,
                     },
                 }
             }

{iatoolkit-2.76.1 → iatoolkit-2.76.3}/src/iatoolkit/services/structured_output_service.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import copy
 import html
 import json
 import re
@@ -129,6 +130,7 @@ class StructuredOutputService:
         schema: dict | None,
         *,
         drop_additional_properties: bool = False,
+        drop_optional_nulls: bool = False,
     ) -> dict:
         if not schema:
             return {
@@ -151,6 +153,7 @@ class StructuredOutputService:
             candidate,
             schema,
             drop_additional_properties=drop_additional_properties,
+            drop_optional_nulls=drop_optional_nulls,
         )
         errors = cls.validate_instance(candidate, schema, path="$")
         return {
@@ -282,6 +285,7 @@ class StructuredOutputService:
         schema: dict | None,
         *,
         drop_additional_properties: bool = False,
+        drop_optional_nulls: bool = False,
     ) -> Any:
         if not isinstance(schema, dict):
             return instance
@@ -303,19 +307,32 @@ class StructuredOutputService:
             additional = schema.get("additionalProperties", True)
             normalized_object: dict[str, Any] = {}
 
+            required = set(schema.get("required") or []) if isinstance(schema.get("required"), list) else set()
             for key, value in instance.items():
                 child_schema = properties.get(key)
+                if (
+                    drop_optional_nulls
+                    and value is None
+                    and key not in required
+                    and isinstance(child_schema, dict)
+                    and not cls._schema_allows_null(child_schema)
+                ):
+                    # A strict provider schema made this optional field nullable
+                    # (see to_strict_schema); absent is what the contract means.
+                    continue
                 if isinstance(child_schema, dict):
                     normalized_object[key] = cls.normalize_instance(
                         value,
                         child_schema,
                         drop_additional_properties=drop_additional_properties,
+                        drop_optional_nulls=drop_optional_nulls,
                     )
                 elif isinstance(additional, dict):
                     normalized_object[key] = cls.normalize_instance(
                         value,
                         additional,
                         drop_additional_properties=drop_additional_properties,
+                        drop_optional_nulls=drop_optional_nulls,
                     )
                 elif additional is False and drop_additional_properties:
                     continue
@@ -333,6 +350,7 @@ class StructuredOutputService:
                     item,
                     item_schema,
                     drop_additional_properties=drop_additional_properties,
+                    drop_optional_nulls=drop_optional_nulls,
                 )
                 for item in instance
             ]
@@ -503,6 +521,77 @@ class StructuredOutputService:
 
         return count
 
+    @classmethod
+    def to_strict_schema(cls, schema: dict | None) -> dict | None:
+        """The schema in the shape strict structured outputs accept (OpenAI and
+        the providers that follow it): every object closed with
+        additionalProperties false and every property required, the optional
+        ones made nullable. Same meaning: an optional field comes back null
+        instead of absent, and normalize_instance(drop_optional_nulls=True)
+        turns it back into absent before validating against the original.
+        Returns a copy; the stored schema is never changed.
+        """
+        if not isinstance(schema, dict):
+            return schema
+        return cls._strict_node(copy.deepcopy(schema))
+
+    @classmethod
+    def _strict_node(cls, node: dict) -> dict:
+        if cls._is_type(node.get("type"), "object") or isinstance(node.get("properties"), dict):
+            properties = node.get("properties") if isinstance(node.get("properties"), dict) else {}
+            required = set(node.get("required") or []) if isinstance(node.get("required"), list) else set()
+            for key, child in list(properties.items()):
+                if not isinstance(child, dict):
+                    continue
+                child = cls._strict_node(child)
+                if key not in required:
+                    child = cls._nullable(child)
+                properties[key] = child
+            node["properties"] = properties
+            node["required"] = list(properties.keys())
+            # A map (additionalProperties as a schema) cannot be expressed in
+            # strict mode; it is left as written and the provider decides.
+            if not isinstance(node.get("additionalProperties"), dict):
+                node["additionalProperties"] = False
+
+        items = node.get("items")
+        if isinstance(items, dict):
+            node["items"] = cls._strict_node(items)
+        for key in ("anyOf", "oneOf"):
+            if isinstance(node.get(key), list):
+                node[key] = [cls._strict_node(item) if isinstance(item, dict) else item for item in node[key]]
+        return node
+
+    @classmethod
+    def _nullable(cls, node: dict) -> dict:
+        if cls._schema_allows_null(node):
+            return node
+        schema_type = node.get("type")
+        if isinstance(schema_type, str):
+            node["type"] = [schema_type, "null"]
+        elif isinstance(schema_type, list):
+            node["type"] = [*schema_type, "null"]
+        else:
+            for key in ("anyOf", "oneOf"):
+                if isinstance(node.get(key), list):
+                    node[key] = [*node[key], {"type": "null"}]
+                    break
+        if isinstance(node.get("enum"), list) and None not in node["enum"]:
+            node["enum"] = [*node["enum"], None]
+        return node
+
+    @classmethod
+    def _schema_allows_null(cls, schema: dict) -> bool:
+        if bool(schema.get("nullable", False)) or cls._allows_null(schema.get("type")):
+            return True
+        for key in ("anyOf", "oneOf"):
+            options = schema.get(key)
+            if isinstance(options, list) and any(
+                isinstance(option, dict) and cls._allows_null(option.get("type")) for option in options
+            ):
+                return True
+        return False
+
     @classmethod
     def _allows_null(cls, schema_type: Any) -> bool:
         if isinstance(schema_type, list):

{iatoolkit-2.76.1 → iatoolkit-2.76.3/src/iatoolkit.egg-info}/PKG-INFO

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