iatoolkit 2.74.0__tar.gz → 2.74.2__tar.gz

{iatoolkit-2.74.0/src/iatoolkit.egg-info → iatoolkit-2.74.2}/PKG-INFO

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

{iatoolkit-2.74.0 → iatoolkit-2.74.2}/src/iatoolkit/__init__.py

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

{iatoolkit-2.74.0 → iatoolkit-2.74.2}/src/iatoolkit/common/model_registry.py

@@ -165,21 +165,58 @@ class ModelRegistry:
             return candidate  # type: ignore[return-value]
         return self.get_provider(model or "")
 
-    def get_capabilities(self, model: str, provider: str | None = None) -> dict:
+    @staticmethod
+    def catalog_capabilities(model_config: dict | None) -> dict | None:
+        """The capabilities the model catalogue holds for a model, or None when unknown.
+
+        Written by `models-sync` from OpenRouter (BL-009, Fase F) and carried in
+        the model's configuration. Empty, or a company.yaml model outside the
+        catalogue, means unknown: the provider's rules decide.
+        """
+        capabilities = (model_config or {}).get("capabilities") if isinstance(model_config, dict) else None
+        if not isinstance(capabilities, dict):
+            return None
+        if not capabilities.get("supported_parameters") and not capabilities.get("input_modalities"):
+            return None
+        return capabilities
+
+    @staticmethod
+    def _declares(capabilities: dict | None, *parameters: str) -> bool | None:
+        """Whether the model declares any of `parameters`; None when nothing is known."""
+        if not capabilities:
+            return None
+        declared = {str(value).strip().lower() for value in capabilities.get("supported_parameters") or []}
+        if not declared:
+            return None
+        return any(parameter in declared for parameter in parameters)
+
+    def get_capabilities(self, model: str, provider: str | None = None, capabilities: dict | None = None) -> dict:
+        """What the request may carry for this model.
+
+        Two halves, both required: what the provider's adapter knows how to send,
+        and what the model accepts. The second comes from the model catalogue
+        (`capabilities`) when it is known; without it, the provider decides alone.
+        The catalogue only ever narrows: a parameter the adapter cannot send is
+        never offered because the model would accept it.
+        """
         normalized_provider = self.normalize_provider(provider=provider, model=model)
         # `openai_compatible` is absent on purpose. Its adapter targets any server
         # that speaks chat.completions — llama.cpp, vLLM, a private gateway — and
         # forwards no reasoning field, because one the server does not know earns a
         # 400. Claiming the capability here made the tenant's Models page offer a
         # reasoning control whose value went nowhere.
-        supports_reasoning_effort = normalized_provider in {
+        adapter_sends_reasoning = normalized_provider in {
             "openai",
             "xai",
             "openrouter",
             "deepseek",
         }
-        supports_text_verbosity = normalized_provider in {"openai", "xai", "openrouter"}
-        supports_store = normalized_provider in {"openai", "xai"}
+        adapter_sends_verbosity = normalized_provider in {"openai", "xai", "openrouter"}
+
+        model_reasons = self._declares(capabilities, "reasoning", "reasoning_effort")
+        model_takes_verbosity = self._declares(capabilities, "verbosity")
+        supports_reasoning_effort = adapter_sends_reasoning and model_reasons is not False
+        supports_text_verbosity = adapter_sends_verbosity and model_takes_verbosity is not False
 
         return {
             "provider": normalized_provider,
@@ -187,7 +224,7 @@ class ModelRegistry:
             "allowed_reasoning_efforts": list(self._reasoning_effort_options) if supports_reasoning_effort else [],
             "supports_text_verbosity": supports_text_verbosity,
             "allowed_text_verbosity": list(self._text_verbosity_options) if supports_text_verbosity else [],
-            "supports_store": supports_store,
+            "capabilities_source": "catalog" if model_reasons is not None else "provider",
         }
 
     def get_request_defaults(self, model: str) -> dict:

{iatoolkit-2.74.0 → iatoolkit-2.74.2}/src/iatoolkit/infra/llm_providers/openai_adapter.py

@@ -19,8 +19,9 @@ class OpenAIAdapter:
         self.client = openai_client
 
     #: Reasoning models whose reasoning can travel between calls as encrypted
-    #: items. Asked only of these: a model without reasoning answers the
-    #: `include` with a 400.
+    #: items, for a model the catalogue does not describe: a model without
+    #: reasoning answers the `include` with a 400. When the catalogue knows the
+    #: model, the proxy says so (`carries_reasoning`) and this list is not read.
     _ENCRYPTED_REASONING_MODEL_PREFIXES = ("gpt-5", "o1", "o3", "o4")
 
     def create_response(self,
@@ -35,7 +36,8 @@ class OpenAIAdapter:
                         attachments: Optional[List[Dict]] = None,
                         store: Optional[bool] = None,
                         metadata: Optional[Dict[str, str]] = None,
-                        telemetry_execution: Any = None) -> LLMResponse:
+                        telemetry_execution: Any = None,
+                        carries_reasoning: Optional[bool] = None) -> LLMResponse:
         """Llamada a la API de OpenAI y mapeo a estructura común.
 
         IAToolkit owns the history (BL-009): every call carries the whole
@@ -62,7 +64,7 @@ class OpenAIAdapter:
 
             # Nothing stays at OpenAI: the next call sends the history again.
             params['store'] = False
-            if self._carries_encrypted_reasoning(model):
+            if self._carries_encrypted_reasoning(model, carries_reasoning):
                 # Without a stored response the model would lose its reasoning
                 # between tool rounds; it comes back encrypted and is sent again.
                 params['include'] = ["reasoning.encrypted_content"]
@@ -93,7 +95,9 @@ class OpenAIAdapter:
             raise IAToolkitException(IAToolkitException.ErrorType.LLM_ERROR, error_message)
 
     @classmethod
-    def _carries_encrypted_reasoning(cls, model: str) -> bool:
+    def _carries_encrypted_reasoning(cls, model: str, carries_reasoning: Optional[bool] = None) -> bool:
+        if carries_reasoning is not None:
+            return carries_reasoning
         name = str(model or "").strip().lower()
         if "-chat" in name:
             return False  # gpt-5-chat-latest and the like do not reason

{iatoolkit-2.74.0 → iatoolkit-2.74.2}/src/iatoolkit/infra/llm_proxy.py

@@ -160,6 +160,12 @@ class LLMProxy:
             provider=provider,
             request_kwargs=request_kwargs,
         )
+        request_kwargs = self._apply_model_capabilities(
+            model=model,
+            provider=provider,
+            model_config=model_config,
+            request_kwargs=request_kwargs,
+        )
         if telemetry_execution is not None:
             request_kwargs["telemetry_execution"] = telemetry_execution
 
@@ -451,6 +457,42 @@ class LLMProxy:
         effective_kwargs["reasoning"] = merged_reasoning
         return effective_kwargs
 
+    def _apply_model_capabilities(
+        self,
+        model: str,
+        provider: str,
+        model_config: Dict[str, Any] | None,
+        request_kwargs: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """Drops the parameters the model itself does not accept (BL-009, Fase F).
+
+        The steps before this one decide by provider: every OpenAI model gets a
+        reasoning effort and a verbosity, which a model that does not reason
+        (gpt-4.1, gpt-5-chat) refuses. When the catalogue knows the model, its
+        `supported_parameters` have the last word. When it does not, nothing
+        changes: the provider's rules stay as they were.
+        """
+        catalog_capabilities = ModelRegistry.catalog_capabilities(model_config)
+        if catalog_capabilities is None:
+            return request_kwargs
+
+        capabilities = self.model_registry.get_capabilities(
+            model, provider=provider, capabilities=catalog_capabilities
+        )
+        effective_kwargs = dict(request_kwargs or {})
+        if not capabilities.get("supports_reasoning_effort"):
+            effective_kwargs.pop("reasoning", None)
+            effective_kwargs.pop("reasoning_effort", None)
+        if not capabilities.get("supports_text_verbosity"):
+            text = effective_kwargs.get("text")
+            if isinstance(text, dict) and "verbosity" in text:
+                effective_kwargs["text"] = {key: value for key, value in text.items() if key != "verbosity"}
+        if provider == self.PROVIDER_OPENAI:
+            # Whether the model's reasoning can travel between calls: the adapter
+            # asks for it only then, instead of guessing from the model's name.
+            effective_kwargs["carries_reasoning"] = bool(capabilities.get("supports_reasoning_effort"))
+        return effective_kwargs
+
     # -------------------------------------------------------------------------
     # Client cache
     # -------------------------------------------------------------------------

{iatoolkit-2.74.0 → iatoolkit-2.74.2}/src/iatoolkit/services/attachment_policy_service.py

@@ -10,13 +10,10 @@ from typing import Any, Dict, List
 import base64
 import logging
 import mimetypes
-import threading
-import time
-
-import requests
 
 from injector import inject
 
+from iatoolkit.common.model_registry import ModelRegistry
 from iatoolkit.services.configuration_service import ConfigurationService
 from iatoolkit.common.util import Utility
 
@@ -30,16 +27,12 @@ class AttachmentPolicyService:
 
     DEFAULT_MODE = MODE_EXTRACTED_ONLY
     DEFAULT_FALLBACK = FALLBACK_EXTRACT
-    OPENROUTER_MODELS_CACHE_TTL_SECONDS = 300
-    OPENROUTER_MODELS_TIMEOUT_SECONDS = 8
 
     @inject
     def __init__(self, configuration_service: ConfigurationService, util: Utility):
         self.configuration_service = configuration_service
         self.util = util
         self._default_capabilities: dict | None = None
-        self._openrouter_models_cache: dict[str, dict[str, Any]] = {}
-        self._openrouter_models_cache_lock = threading.Lock()
         self._default_capabilities_path = (
             Path(__file__).resolve().parent.parent / "config" / "llm_capabilities.yaml"
         )
@@ -72,7 +65,7 @@ class AttachmentPolicyService:
     ) -> dict:
         mode = self.normalize_mode((policy or {}).get("attachment_mode"))
         fallback = self.normalize_fallback((policy or {}).get("attachment_fallback"))
-        capabilities = self.get_effective_provider_capabilities(company_short_name, provider)
+        capabilities = self.get_effective_capabilities(company_short_name, provider, model)
 
         if not files:
             return {
@@ -102,8 +95,6 @@ class AttachmentPolicyService:
             "fallback_to_extract": 0,
             "errors": 0,
         }
-        openrouter_native_image_error: str | None = None
-        openrouter_native_image_checked = False
 
         for file_obj in files:
             stats["total_files"] += 1
@@ -114,36 +105,17 @@ class AttachmentPolicyService:
                 wants_native = self._wants_native(mode, meta, capabilities)
                 wants_extract = self._wants_extract(mode, meta, capabilities)
                 native_ok = False
-                native_blocked_by_model_catalog = False
 
                 if wants_native:
-                    if str(provider or "").strip().lower() == "openrouter":
-                        if not openrouter_native_image_checked:
-                            openrouter_native_image_error = self._get_openrouter_native_image_error(
-                                company_short_name=company_short_name,
-                                model=model,
-                            )
-                            openrouter_native_image_checked = True
-                        if openrouter_native_image_error:
-                            if fallback == self.FALLBACK_EXTRACT or wants_extract:
-                                stats["fallback_to_extract"] += 1
-                                wants_extract = True
-                                native_blocked_by_model_catalog = True
-                            else:
-                                if openrouter_native_image_error not in errors:
-                                    errors.append(openrouter_native_image_error)
-                                continue
-                    if (not native_blocked_by_model_catalog) and bool(capabilities.get("supports_native_images")):
+                    if bool(capabilities.get("supports_native_images")):
                         files_for_context.append(dict(file_obj))
                         native_ok = True
                         stats["native_sent_count"] += 1
-                    elif (not native_blocked_by_model_catalog) and (fallback == self.FALLBACK_EXTRACT or wants_extract):
+                    elif fallback == self.FALLBACK_EXTRACT or wants_extract:
                         stats["fallback_to_extract"] += 1
                         wants_extract = True
-                    elif not native_blocked_by_model_catalog:
-                        errors.append(
-                            f"Image attachment '{filename}' cannot be sent as native image for provider '{provider}'."
-                        )
+                    else:
+                        errors.append(self._native_image_error(filename, provider, model, capabilities))
 
                 if wants_extract:
                     extract_copy = dict(file_obj)
@@ -204,6 +176,51 @@ class AttachmentPolicyService:
             "stats": stats,
         }
 
+    def get_effective_capabilities(self, company_short_name: str, provider: str, model: str | None) -> dict:
+        """What can go natively to this model: what the provider's adapter sends, narrowed by the model.
+
+        The provider half (llm_capabilities.yaml and the company's overrides)
+        says what our adapter knows how to send. The model half comes from the
+        model catalogue (BL-009, Fase F): `input_modalities` as OpenRouter
+        publishes them. Both must hold, so a provider that takes images does not
+        make a text-only model take them. A model the catalogue does not know
+        keeps the provider's answer.
+        """
+        capabilities = dict(self.get_effective_provider_capabilities(company_short_name, provider))
+        capabilities["capabilities_source"] = "provider"
+        modalities = self._model_input_modalities(company_short_name, model)
+        if modalities is None:
+            return capabilities
+        capabilities["supports_native_images"] = bool(capabilities.get("supports_native_images")) and "image" in modalities
+        capabilities["supports_native_files"] = bool(capabilities.get("supports_native_files")) and "file" in modalities
+        capabilities["input_modalities"] = sorted(modalities)
+        capabilities["capabilities_source"] = "catalog"
+        return capabilities
+
+    def _model_input_modalities(self, company_short_name: str, model: str | None) -> set[str] | None:
+        if not model:
+            return None
+        try:
+            model_config = self.configuration_service.get_llm_model_config(company_short_name, model) or {}
+        except Exception as e:
+            logging.debug("Could not read the configuration of model '%s': %s", model, e)
+            return None
+        catalog = ModelRegistry.catalog_capabilities(model_config)
+        if not catalog or not catalog.get("input_modalities"):
+            return None
+        return {str(value).strip().lower() for value in catalog["input_modalities"] if str(value or "").strip()}
+
+    @staticmethod
+    def _native_image_error(filename: str, provider: str, model: str | None, capabilities: dict) -> str:
+        if capabilities.get("capabilities_source") == "catalog":
+            modalities = ", ".join(capabilities.get("input_modalities") or []) or "(none)"
+            return (
+                f"Image attachment '{filename}' cannot be sent as a native image: the model catalogue "
+                f"publishes '{model}' with input modalities {modalities}, without 'image'. "
+                "Use a model that takes images, or allow text extraction."
+            )
+        return f"Image attachment '{filename}' cannot be sent as native image for provider '{provider}'."
+
     def get_effective_provider_capabilities(self, company_short_name: str, provider: str) -> dict:
         provider_key = str(provider or "unknown").strip().lower() or "unknown"
         defaults = self._load_default_capabilities().get(provider_key) or self._load_default_capabilities().get("unknown", {})
@@ -270,104 +287,6 @@ class AttachmentPolicyService:
         merged.setdefault("max_files_per_request", 0)
         return merged
 
-    def _get_openrouter_native_image_error(self, company_short_name: str, model: str | None) -> str | None:
-        model_id = str(model or "").strip()
-        if not model_id:
-            return (
-                "Este modelo/provider no expone visión nativa por API: no se resolvio el modelo efectivo "
-                "para OpenRouter, por lo que no puedo confirmar soporte de imagenes nativas."
-            )
-
-        model_metadata, verified = self._lookup_openrouter_model_metadata(company_short_name, model_id)
-        if not verified:
-            return None
-        if not isinstance(model_metadata, dict):
-            return (
-                "Este modelo/provider no expone visión nativa por API verificable: "
-                f"OpenRouter no publica metadata para el modelo '{model_id}', por lo que no puedo confirmar "
-                "que acepte imagenes nativas."
-            )
-
-        architecture = model_metadata.get("architecture") or {}
-        raw_input_modalities = architecture.get("input_modalities") or []
-        input_modalities = [
-            str(modality or "").strip().lower()
-            for modality in raw_input_modalities
-            if str(modality or "").strip()
-        ]
-        if "image" in input_modalities:
-            return None
-
-        published_model_id = str(model_metadata.get("id") or model_id).strip() or model_id
-        published_modalities = ", ".join(input_modalities) if input_modalities else "(vacio)"
-        return (
-            "Este modelo/provider no expone visión nativa por API: "
-            f"OpenRouter publica el modelo '{published_model_id}' con input_modalities={published_modalities}, "
-            "sin 'image'. Para enviar imagenes nativas usa un modelo/provider que publique 'image' "
-            "como modalidad de entrada."
-        )
-
-    def _lookup_openrouter_model_metadata(self, company_short_name: str, model: str) -> tuple[dict | None, bool]:
-        provider_config = self.configuration_service.get_llm_provider_config(company_short_name, "openrouter") or {}
-        base_url = str(provider_config.get("base_url") or "https://openrouter.ai/api/v1").strip()
-        models_url = f"{base_url.rstrip('/')}/models"
-        catalog = self._get_openrouter_models_catalog(models_url)
-        if catalog is None:
-            return None, False
-
-        model_key = str(model or "").strip().lower()
-        for item in catalog:
-            if not isinstance(item, dict):
-                continue
-            candidates = {
-                str(item.get("id") or "").strip().lower(),
-                str(item.get("canonical_slug") or "").strip().lower(),
-            }
-            candidates.update(
-                {
-                    candidate.split("/")[-1]
-                    for candidate in list(candidates)
-                    if candidate and "/" in candidate
-                }
-            )
-            if model_key and model_key in candidates:
-                return item, True
-
-        return None, True
-
-    def _get_openrouter_models_catalog(self, models_url: str) -> list[dict] | None:
-        current_time = time.time()
-        with self._openrouter_models_cache_lock:
-            cached_entry = self._openrouter_models_cache.get(models_url)
-            if cached_entry and (current_time - float(cached_entry.get("fetched_at") or 0)) < self.OPENROUTER_MODELS_CACHE_TTL_SECONDS:
-                cached_data = cached_entry.get("data")
-                if isinstance(cached_data, list):
-                    return cached_data
-
-        try:
-            response = requests.get(
-                models_url,
-                params={"output_modalities": "all"},
-                timeout=self.OPENROUTER_MODELS_TIMEOUT_SECONDS,
-                headers={"User-Agent": "IAToolkit AttachmentPolicy/1.0"},
-            )
-            response.raise_for_status()
-            payload = response.json()
-            catalog = payload.get("data") if isinstance(payload, dict) else None
-            if not isinstance(catalog, list):
-                logging.warning("OpenRouter models API returned an unexpected payload shape for '%s'.", models_url)
-                return None
-        except Exception as exc:
-            logging.warning("Could not fetch OpenRouter model metadata from '%s': %s", models_url, exc)
-            return None
-
-        with self._openrouter_models_cache_lock:
-            self._openrouter_models_cache[models_url] = {
-                "fetched_at": current_time,
-                "data": catalog,
-            }
-        return catalog
-
     def _normalize_file_meta(self, file_obj: dict) -> dict:
         if not isinstance(file_obj, dict):
             return {"name": "attachment", "payload": "", "mime_type": "application/octet-stream", "is_image": False}

{iatoolkit-2.74.0 → iatoolkit-2.74.2}/src/iatoolkit/services/configuration_service.py

@@ -1435,7 +1435,11 @@ class ConfigurationService:
             provider=normalized.get("provider"),
             model=model_id,
         )
-        capabilities = self.model_registry.get_capabilities(model_id, provider=provider)
+        capabilities = self.model_registry.get_capabilities(
+            model_id,
+            provider=provider,
+            capabilities=self.model_registry.catalog_capabilities(normalized),
+        )
         descriptor = dict(normalized)
         descriptor["id"] = model_id
         descriptor["label"] = str(descriptor.get("label") or model_id).strip()

{iatoolkit-2.74.0 → iatoolkit-2.74.2}/src/iatoolkit/services/history_compaction_service.py

@@ -54,7 +54,13 @@ class HistoryCompactionService:
     #: Tool outputs and long answers are cut in the transcript the agent reads:
     #: the summary keeps facts, and a 200-row result would crowd out the rest.
     MAX_MESSAGE_CHARS = 4000
+    #: What one call to the agent reads. A longer stretch is summarized in
+    #: parts, oldest first, each part extending the summary of the previous one.
     MAX_TRANSCRIPT_CHARS = 400_000
+    #: Parts per compaction: in the background, enough for a history that grew
+    #: without compaction (before BL-009) without summarizing forever; in line,
+    #: one, because the person is waiting.
+    MAX_CHUNKS = 6
 
     @inject
     def __init__(self,
@@ -73,7 +79,19 @@ class HistoryCompactionService:
     # Entry point
     # ------------------------------------------------------------------
 
-    def compact(self, company_short_name: str, user_identifier: str, model: str) -> dict:
+    def compact(self, company_short_name: str, user_identifier: str, model: str,
+                max_chunks: Optional[int] = None) -> dict:
+        result = self._compact(company_short_name, user_identifier, model, max_chunks)
+        if result.get("status") != "compacted":
+            # A run that ends without applying anything is as worth knowing as
+            # one that does: in production both looked the same ("executed").
+            log = logging.warning if result.get("status") == "error" else logging.info
+            log("History of %s/%s (model=%s) not compacted: %s",
+                company_short_name, user_identifier, model, result)
+        return result
+
+    def _compact(self, company_short_name: str, user_identifier: str, model: str,
+                 max_chunks: Optional[int]) -> dict:
         history = self.session_context.get_context_history(company_short_name, user_identifier, model=model) or []
         budget = self.history_manager.context_budget_tokens(company_short_name, model)
         plan = self.plan(history, budget)
@@ -86,24 +104,68 @@ class HistoryCompactionService:
         if not company:
             return {"status": "error", "reason": "company_not_found"}
 
-        try:
-            response = self.system_agent_runner.run(
-                company,
-                self.AGENT_KEY,
-                {
-                    "previous_summary": plan.previous_summary,
-                    "transcript": self.render_transcript(plan.material),
-                },
-                user_identifier=user_identifier,
+        chunks = self.chunk_material(plan.material)
+        limit = max(int(max_chunks or self.MAX_CHUNKS), 1)
+        dropped_chunks = max(len(chunks) - limit, 0)
+        if dropped_chunks:
+            # The oldest parts go unsummarized: a cost bound, logged so a short
+            # summary of a very long conversation can be explained.
+            logging.warning(
+                "History of %s/%s (model=%s) needs %s parts to summarize; only the %s most recent are.",
+                company_short_name, user_identifier, model, len(chunks), limit,
             )
-        except SystemAgentUnavailable as e:
-            return {"status": "skipped", "reason": str(e)}
-
-        summary = self._summary_from(response)
-        if not summary:
-            return {"status": "error", "reason": "empty_summary"}
+            chunks = chunks[-limit:]
+
+        summary = plan.previous_summary
+        for chunk in chunks:
+            try:
+                response = self.system_agent_runner.run(
+                    company,
+                    self.AGENT_KEY,
+                    {"previous_summary": summary, "transcript": self.render_transcript(chunk)},
+                    user_identifier=user_identifier,
+                )
+            except SystemAgentUnavailable as e:
+                return {"status": "skipped", "reason": str(e)}
+            part = self._summary_from(response)
+            if not part:
+                return {"status": "error", "reason": "empty_summary"}
+            summary = part
+
+        result = self._apply(company_short_name, user_identifier, model, plan, summary)
+        if result.get("status") == "compacted":
+            result["chunks"] = len(chunks)
+            if dropped_chunks:
+                result["dropped_chunks"] = dropped_chunks
+        return result
 
-        return self._apply(company_short_name, user_identifier, model, plan, summary)
+    @classmethod
+    def chunk_material(cls, material: list) -> list[list]:
+        """The material split into parts the agent can read in one call, at turn boundaries.
+
+        A turn is never split, so a tool call stays with its result. A single
+        turn longer than a part is a part of its own (render_transcript clips it).
+        """
+        turns: list[list] = []
+        for message in material or []:
+            if (isinstance(message, dict) and message.get("role") == "user") or not turns:
+                turns.append([message])
+            else:
+                turns[-1].append(message)
+
+        chunks: list[list] = []
+        current: list = []
+        current_chars = 0
+        for turn in turns:
+            turn_chars = len(cls.render_transcript(turn))
+            if current and current_chars + turn_chars > cls.MAX_TRANSCRIPT_CHARS:
+                chunks.append(current)
+                current, current_chars = [], 0
+            current.extend(turn)
+            current_chars += turn_chars
+        if current:
+            chunks.append(current)
+        return chunks
 
     # ------------------------------------------------------------------
     # Planning
@@ -253,11 +315,27 @@ class HistoryCompactionService:
 
     @staticmethod
     def _summary_from(response: Any) -> str:
+        """The summary, however the model returned it.
+
+        The agent asks for `{"summary": ...}`, but over a long transcript a model
+        may answer the Markdown alone. That is still the summary; dropping it
+        threw away minutes of work and left the history to grow.
+        """
         if not isinstance(response, dict):
             return ""
-        structured = response.get("structured_output")
-        if isinstance(structured, dict) and isinstance(structured.get("summary"), str):
-            return structured["summary"].strip()
+        for key in ("structured_output", "parsed_output"):
+            structured = response.get(key)
+            if isinstance(structured, dict) and isinstance(structured.get("summary"), str):
+                return structured["summary"].strip()
+        answer = response.get("answer")
+        if isinstance(answer, str) and answer.strip():
+            text = answer.strip()
+            try:
+                parsed = json.loads(text)
+            except (TypeError, ValueError):
+                return text
+            if isinstance(parsed, dict) and isinstance(parsed.get("summary"), str):
+                return parsed["summary"].strip()
         return ""
 
     def _count(self, message: Any) -> int: