iatoolkit 2.74.1__tar.gz → 2.74.3__tar.gz

{iatoolkit-2.74.1/src/iatoolkit.egg-info → iatoolkit-2.74.3}/PKG-INFO

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

{iatoolkit-2.74.1 → iatoolkit-2.74.3}/src/iatoolkit/__init__.py

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

{iatoolkit-2.74.1 → iatoolkit-2.74.3}/src/iatoolkit/config/system_agents/history_compaction.prompt

@@ -1,6 +1,6 @@
 You compact the older part of a conversation between a person and a company's AI assistant. The conversation is too long for the model's context, so the turns below will be replaced by your summary; the most recent turns stay as they are. The assistant will continue the conversation from your summary alone, so anything you leave out is lost.
 
-Write the summary in the language of the conversation, as Markdown, with these sections (omit a section only when there is nothing for it):
+Write the summary in the language of the conversation, as Markdown, with these sections (omit a section only when there is nothing for it). Write the section headings in that language too, as level-2 headings (`## …`), and do not wrap the summary in a code block:
 
 - **Objective**: what the person is trying to achieve, and how it evolved.
 - **Decisions**: what was agreed, chosen or ruled out, and why when it was said.

{iatoolkit-2.74.1 → iatoolkit-2.74.3}/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 = 4
 
     @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,72 @@ 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 index, chunk in enumerate(chunks):
+            if index and not self._still_matches(company_short_name, user_identifier, model, plan):
+                # Each part costs a model call of minutes; once the history has
+                # changed under the plan, the rest would be summarized for nothing.
+                return {"status": "skipped", "reason": "history_changed", "summarized_parts": index}
+            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
@@ -214,6 +280,11 @@ class HistoryCompactionService:
     # Applying
     # ------------------------------------------------------------------
 
+    def _still_matches(self, company_short_name: str, user_identifier: str, model: str,
+                       plan: CompactionPlan) -> bool:
+        current = self.session_context.get_context_history(company_short_name, user_identifier, model=model) or []
+        return len(current) >= plan.cut and self._fingerprint(current[:plan.cut]) == plan.prefix_hash
+
     def _apply(self, company_short_name: str, user_identifier: str, model: str,
                plan: CompactionPlan, summary: str) -> dict:
         lock_key = self.history_manager.history_lock_key(company_short_name, user_identifier, model)
@@ -253,13 +324,46 @@ 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 HistoryCompactionService._unfence(structured["summary"])
+        answer = response.get("answer")
+        if isinstance(answer, str) and answer.strip():
+            text = HistoryCompactionService._unfence(answer)
+            try:
+                parsed = json.loads(text)
+            except (TypeError, ValueError):
+                return text
+            if isinstance(parsed, dict) and isinstance(parsed.get("summary"), str):
+                return HistoryCompactionService._unfence(parsed["summary"])
+            return text
         return ""
 
+    @staticmethod
+    def _unfence(text: str) -> str:
+        """The text without a Markdown code block around it.
+
+        Seen in production: the summary came back as ```summary ... ```, which
+        stored as is would put the whole summary inside a code block.
+        """
+        stripped = str(text or "").strip()
+        if not stripped.startswith("```"):
+            return stripped
+        lines = stripped.split("\n")
+        body = lines[1:]
+        if body and body[-1].strip() == "```":
+            body = body[:-1]
+        return "\n".join(body).strip()
+
     def _count(self, message: Any) -> int:
         try:
             return int(self.llm_client.count_tokens(json.dumps(message, ensure_ascii=False, default=str)))

{iatoolkit-2.74.1 → iatoolkit-2.74.3}/src/iatoolkit/services/history_manager_service.py

@@ -39,15 +39,29 @@ class HistoryManagerService:
     #: declare 128k of output; reserving all of it would waste a quarter of a
     #: 400k window on an answer that is almost never that long.
     MAX_OUTPUT_RESERVE_TOKENS = 32000
+    #: The most the history may take, whatever the model's window. Every turn
+    #: (and every round of its tool loop) sends the whole history, so a
+    #: million-token window filled on each call is a cost nobody chose: seen in
+    #: production, three calls of 393k tokens for one question. A company may
+    #: set its own with `llm.max_context_tokens`.
+    DEFAULT_MAX_CONTEXT_TOKENS = 200000
 
     #: Share of the budget at which a finished turn asks for a background
     #: compaction, and at which the next turn compacts in line because the
     #: background one did not land in time (BL-009, Fase E).
     COMPACTION_TRIGGER_SHARE = 0.70
     INLINE_COMPACTION_SHARE = 0.95
+    #: Parts an in-line compaction may summarize: one, the person is waiting.
+    INLINE_COMPACTION_MAX_CHUNKS = 1
     #: How long a turn waits for a compaction that is writing the history.
     HISTORY_LOCK_WAIT_SECONDS = 2.0
     HISTORY_LOCK_TTL_SECONDS = 30
+    #: The stored history never grows past this many budgets. Only the copy sent
+    #: to the model used to be trimmed, so a conversation that was never
+    #: compacted kept every turn in the session (829k tokens seen on a 400k
+    #: budget). Two budgets leave the background compaction room to summarize
+    #: what is over one; past them, the oldest turns go.
+    STORED_HISTORY_MAX_BUDGETS = 2
 
     #: Marks the message that holds the summary of the compacted turns. It goes
     #: to the model as it is, so it also tells the model what the text is.
@@ -187,6 +201,8 @@ class HistoryManagerService:
         elif response.get('answer'):
             context_history.append({"role": "assistant", "content": response.get('answer', '')})
 
+        self._cap_stored_history(company_short_name, model, context_history)
+
         self.session_context.save_context_history(
             company_short_name,
             user_identifier,
@@ -215,7 +231,14 @@ class HistoryManagerService:
 
     def _compact_in_line_if_needed(self, company_short_name: str, user_identifier: str, model: Optional[str],
                                    user_turn_prompt: str, budget: int):
-        """Compacts now when the turn about to run would not fit: the background one did not land in time."""
+        """Handles a turn that would not fit because the background compaction did not land in time.
+
+        With workers, the turn asks for the compaction again and goes out
+        trimmed: a summary takes one to three minutes (seen in production), and
+        the request would die long before (gunicorn's timeout is 60s). Only an
+        installation without workers compacts in line, since nothing else ever
+        would.
+        """
         try:
             measured = self.session_context.get_context_tokens(company_short_name, user_identifier, model=model)
             if not measured:
@@ -223,7 +246,12 @@ class HistoryManagerService:
             estimated = measured + self.llm_client.count_tokens(user_turn_prompt or "")
             if estimated < budget * self.INLINE_COMPACTION_SHARE:
                 return
-            result = self.compaction_service.compact(company_short_name, user_identifier, model)
+            if self.compaction_trigger.trigger(company_short_name, user_identifier, model):
+                return
+            result = self.compaction_service.compact(
+                company_short_name, user_identifier, model,
+                max_chunks=self.INLINE_COMPACTION_MAX_CHUNKS,
+            )
             logging.info(f"In-line compaction of {company_short_name}/{user_identifier}: {result}")
         except Exception as e:
             # The trim that follows still keeps the request inside the window.
@@ -282,13 +310,12 @@ class HistoryManagerService:
         else:
             budget = self.DEFAULT_CONTEXT_BUDGET_TOKENS
 
-        # A company may cap it below the window: filling a million-token window
-        # on every turn is a cost decision, not a technical one.
-        company_cap = self._company_context_cap(company_short_name)
-        return min(budget, company_cap) if company_cap else budget
+        # The window is a ceiling, not a target: the cap is a cost decision.
+        cap = self._company_context_cap(company_short_name) or self.DEFAULT_MAX_CONTEXT_TOKENS
+        return min(budget, cap)
 
     def _company_context_cap(self, company_short_name: str) -> int:
-        """`llm.max_context_tokens` in company.yaml; 0 when not set."""
+        """`llm.max_context_tokens` in company.yaml; 0 when not set (the platform default applies)."""
         if self.configuration_service is None:
             return 0
         try:
@@ -322,7 +349,17 @@ class HistoryManagerService:
             and not cls.is_summary_message(message)
         ]
 
-    def _trim_context_history(self, context_history: list, budget_tokens: Optional[int] = None):
+    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
+        # A cheap upper estimate first (a token is rarely under 3 characters):
+        # counting every save with the tokenizer would cost what this saves.
+        if len(json.dumps(context_history, default=str)) <= cap * 3:
+            return
+        self._trim_context_history(context_history, cap, purpose="stored")
+
+    def _trim_context_history(self, context_history: list, budget_tokens: Optional[int] = None,
+                              purpose: str = "request"):
         """Drops whole turns, oldest first, until the history fits the budget.
 
         A turn is a user message and everything up to the next one: the
@@ -341,6 +378,9 @@ class HistoryManagerService:
             return
 
         total_tokens = sum(token_counts)
+        initial_tokens = total_tokens
+        removed_turns = 0
+        removed_messages = 0
         while total_tokens > budget:
             turn_starts = self.turn_starts(context_history)
             if len(turn_starts) < 2:
@@ -350,9 +390,13 @@ class HistoryManagerService:
             del context_history[first:second]
             del token_counts[first:second]
             total_tokens -= removed_tokens
+            removed_turns += 1
+            removed_messages += second - first
+
+        if removed_turns:
             logging.warning(
-                f"History tokens exceed the budget of {budget}. Removed the oldest turn "
-                f"({second - first} messages). New total: {total_tokens} tokens."
+                f"History ({purpose}) over the budget of {budget} tokens: removed the {removed_turns} "
+                f"oldest turns ({removed_messages} messages), {initial_tokens} -> {total_tokens} tokens."
             )
 
     # --- this is for the history popup in the chat page

{iatoolkit-2.74.1 → iatoolkit-2.74.3/src/iatoolkit.egg-info}/PKG-INFO

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