contextpress 0.6.2__tar.gz → 0.6.4__tar.gz

{contextpress-0.6.2 → contextpress-0.6.4}/CHANGELOG.md

@@ -4,6 +4,25 @@ All notable changes to `contextpress` are recorded here.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.4] - 2026-08-18
+
+- **OpenAI tool messages** — ``role: tool`` / ``function`` are valid; ``tool_calls``,
+  ``tool_call_id``, and ``name`` round-trip on dict messages.
+- Structure minifies JSON in ``tool_calls[].function.arguments`` and tool-result content.
+- Filler never drops empty assistant turns that only carry ``tool_calls``.
+- Budget removes an assistant ``tool_calls`` turn together with matching ``role=tool``
+  results (no orphan tool messages).
+- Example: `examples/openai_tools_compress.py`.
+
+## [0.6.3] - 2026-08-12
+
+- **LangChain round-trip** — ``compress()`` maps remaining turns back onto their original
+  message objects (not list index), so dropped turns no longer remap roles/content.
+- **``output_tokens`` on cost stats** — ``attach_cost(output_tokens=...)``,
+  ``compress(..., output_tokens=...)``, and ``ContextManager(cost_output_tokens=...)``
+  add assumed completion USD; ``summary()`` prints output + total when set.
+- Example: `examples/langchain_roundtrip.py`.
+
 ## [0.6.2] - 2026-07-27
 
 - **Agent-oriented fixtures** — three offline agent threads under `tests/fixtures/chats/`

{contextpress-0.6.2 → contextpress-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: contextpress
-Version: 0.6.2
+Version: 0.6.4
 Summary: Deterministic context compression for LLM chat, RAG, and agent pipelines
 Project-URL: Homepage, https://github.com/Taha-azizi/contextpress
 Project-URL: Documentation, https://github.com/Taha-azizi/contextpress#readme
@@ -244,6 +244,8 @@ Description-Content-Type: text/markdown
 Deterministic context compression for LLM chat, RAG, and agent pipelines.
 Created and maintained by **[Taha Azizi](https://github.com/Taha-azizi)**.
 
+**Write-up:** [Introducing contextpress](https://pub.towardsai.net/introducing-contextpress-the-python-library-that-refactors-your-llm-context-c57965617edb) — Towards AI (Medium)
+
 ---
 
 ## Project Status
@@ -389,7 +391,7 @@ That script builds a long history and a tight `token_budget` so you can see turn
 
 - **chat** — Typical back-and-forth dialogue. Filler removal, repetition deduplication, resolution collapsing, recency weighting, and token budgets are tuned for conversational flow.
 - **rag_doc** — Document chunks or RAG context. Resolution is off; repetition compares all chunks; recency uses relevance to the latest user query instead of chat recency.
-- **agent** — Tool-using or task-oriented threads. Resolution can trigger on a single high-confidence completion signal; filler rules preserve tool-related turns when markers are present.
+- **agent** — Tool-using or task-oriented threads. Resolution can trigger on a single high-confidence completion signal; filler rules preserve tool-related turns when markers are present. OpenAI Chat Completions ``tool_calls`` / ``role: tool`` messages are first-class (0.6.4+).
 
 ```python
 ContextManager(type="chat")
@@ -398,6 +400,7 @@ ContextManager(type="agent")
 ```
 
 Runnable agent example: [`examples/agent_pipeline.py`](examples/agent_pipeline.py).
+OpenAI tools example: [`examples/openai_tools_compress.py`](examples/openai_tools_compress.py).
 
 ## Pipeline stages
 
@@ -406,7 +409,7 @@ Runnable agent example: [`examples/agent_pipeline.py`](examples/agent_pipeline.p
 3. **Repetition** — TF-IDF cosine similarity; keeps the more recent of similar turns.
 4. **Resolution** — Collapses agreed threads into a single `RESOLVED:` synthetic system turn (chat/agent only).
 5. **Recency** — Extractively compresses older turns (or low-relevance chunks in `rag_doc`) while preserving the latest context.
-6. **Budget** — Enforces a hard token limit with `tiktoken`, removing oldest turns first while protecting system prompts and recent turns.
+6. **Budget** — Enforces a hard token limit with `tiktoken`, removing oldest turns first while protecting system prompts and recent turns. Assistant ``tool_calls`` and matching ``role: tool`` results are dropped together (0.6.4+).
 
 **Cost estimate** (0.6+, approximate list prices for planning):
 
@@ -436,6 +439,20 @@ print(result.summary())
 # est. input cost: $0.000126 -> $0.000061 (saved $0.000065)   # when cost_provider set
 ```
 
+**Assumed completion tokens** (0.6.3+, opt-in; output cost is unchanged by compression):
+
+```python
+cm = ContextManager(type="chat", model="gpt-4o-mini", cost_provider="openai", cost_output_tokens=200)
+result = cm.compress(messages, token_budget=2000, return_stats=True)
+print(result.summary())
+# ...
+# est. output cost: $0.000120 (200 tokens)
+# est. total: $0.000246 -> $0.000181
+```
+
+LangChain-style message objects (``.type`` / ``.content``) round-trip through ``compress()``;
+dropped turns keep their original object types. See `examples/langchain_roundtrip.py`.
+
 See [`ROADMAP.md`](ROADMAP.md) for positioning vs heavier compression stacks and the 0.6.x plan.
 
 ## Tier 1 vs Tier 2 (classical NLP vs LLM)

{contextpress-0.6.2 → contextpress-0.6.4}/README.md

@@ -3,6 +3,8 @@
 Deterministic context compression for LLM chat, RAG, and agent pipelines.
 Created and maintained by **[Taha Azizi](https://github.com/Taha-azizi)**.
 
+**Write-up:** [Introducing contextpress](https://pub.towardsai.net/introducing-contextpress-the-python-library-that-refactors-your-llm-context-c57965617edb) — Towards AI (Medium)
+
 ---
 
 ## Project Status
@@ -148,7 +150,7 @@ That script builds a long history and a tight `token_budget` so you can see turn
 
 - **chat** — Typical back-and-forth dialogue. Filler removal, repetition deduplication, resolution collapsing, recency weighting, and token budgets are tuned for conversational flow.
 - **rag_doc** — Document chunks or RAG context. Resolution is off; repetition compares all chunks; recency uses relevance to the latest user query instead of chat recency.
-- **agent** — Tool-using or task-oriented threads. Resolution can trigger on a single high-confidence completion signal; filler rules preserve tool-related turns when markers are present.
+- **agent** — Tool-using or task-oriented threads. Resolution can trigger on a single high-confidence completion signal; filler rules preserve tool-related turns when markers are present. OpenAI Chat Completions ``tool_calls`` / ``role: tool`` messages are first-class (0.6.4+).
 
 ```python
 ContextManager(type="chat")
@@ -157,6 +159,7 @@ ContextManager(type="agent")
 ```
 
 Runnable agent example: [`examples/agent_pipeline.py`](examples/agent_pipeline.py).
+OpenAI tools example: [`examples/openai_tools_compress.py`](examples/openai_tools_compress.py).
 
 ## Pipeline stages
 
@@ -165,7 +168,7 @@ Runnable agent example: [`examples/agent_pipeline.py`](examples/agent_pipeline.p
 3. **Repetition** — TF-IDF cosine similarity; keeps the more recent of similar turns.
 4. **Resolution** — Collapses agreed threads into a single `RESOLVED:` synthetic system turn (chat/agent only).
 5. **Recency** — Extractively compresses older turns (or low-relevance chunks in `rag_doc`) while preserving the latest context.
-6. **Budget** — Enforces a hard token limit with `tiktoken`, removing oldest turns first while protecting system prompts and recent turns.
+6. **Budget** — Enforces a hard token limit with `tiktoken`, removing oldest turns first while protecting system prompts and recent turns. Assistant ``tool_calls`` and matching ``role: tool`` results are dropped together (0.6.4+).
 
 **Cost estimate** (0.6+, approximate list prices for planning):
 
@@ -195,6 +198,20 @@ print(result.summary())
 # est. input cost: $0.000126 -> $0.000061 (saved $0.000065)   # when cost_provider set
 ```
 
+**Assumed completion tokens** (0.6.3+, opt-in; output cost is unchanged by compression):
+
+```python
+cm = ContextManager(type="chat", model="gpt-4o-mini", cost_provider="openai", cost_output_tokens=200)
+result = cm.compress(messages, token_budget=2000, return_stats=True)
+print(result.summary())
+# ...
+# est. output cost: $0.000120 (200 tokens)
+# est. total: $0.000246 -> $0.000181
+```
+
+LangChain-style message objects (``.type`` / ``.content``) round-trip through ``compress()``;
+dropped turns keep their original object types. See `examples/langchain_roundtrip.py`.
+
 See [`ROADMAP.md`](ROADMAP.md) for positioning vs heavier compression stacks and the 0.6.x plan.
 
 ## Tier 1 vs Tier 2 (classical NLP vs LLM)

{contextpress-0.6.2 → contextpress-0.6.4}/ROADMAP.md

@@ -40,5 +40,7 @@ deterministic Tier‑1 NLP for chat / RAG / agent **message histories**, with op
 | **0.6.0** | `structure` stage + `estimate_cost()` + this roadmap — shipped |
 | **0.6.1** | Wire estimated USD into `CompressionStats` / reports — shipped |
 | **0.6.2** | Agent-oriented fixtures for JSON/tool payloads; `summary()` report — shipped |
+| **0.6.3** | LangChain compress round-trip; `output_tokens` on cost stats / `summary()` — shipped |
+| **0.6.4** | OpenAI `tool_calls` / `role=tool` round-trip, JSON minify, budget pair integrity — shipped |
 
 Stay classical-NLP-first; keep optional LLM extras optional.

{contextpress-0.6.2 → contextpress-0.6.4}/contextpress/__init__.py

@@ -16,7 +16,7 @@ __all__ = [
     "CompressionResult",
     "CompressionStats",
 ]
-__version__ = "0.6.2"
+__version__ = "0.6.4"
 
 
 def __getattr__(name: str) -> Any:

{contextpress-0.6.2 → contextpress-0.6.4}/contextpress/core.py

@@ -48,6 +48,7 @@ class ContextManager:
         llm_max_summary_tokens: int = 2048,
         llm_mode: str = "replace_all",
         cost_provider: str | None = None,
+        cost_output_tokens: int = 0,
     ):
         if type not in PROFILES:
             raise ValueError(f"unknown context type {type!r}")
@@ -65,6 +66,7 @@ class ContextManager:
         self.llm_mode = llm_mode
         # When set, compress(..., return_stats=True) attaches USD fields on stats.
         self.cost_provider = cost_provider
+        self.cost_output_tokens = int(cost_output_tokens)
         self._custom_stages: dict[str, StageConfig] = {}
 
     def estimate_tokens(self, messages: Any, *, model: str | None = None) -> int:
@@ -185,6 +187,7 @@ class ContextManager:
         return_stats: bool = False,
         dry_run: bool = False,
         cost_provider: str | None = None,
+        output_tokens: int | None = None,
     ) -> Any | CompressionResult:
         """Run the pipeline; return value matches input shape (dict list, tuples, strings, etc.).
 
@@ -193,6 +196,8 @@ class ContextManager:
         With ``dry_run=True``, runs Tier 1 only (no LLM calls) and returns the original messages.
         When ``cost_provider`` (or ``self.cost_provider``) is set and stats are returned,
         ``stats`` includes approximate input USD before/after compression.
+        ``output_tokens`` (or ``self.cost_output_tokens``) adds an assumed completion cost
+        that is unchanged by compression.
         """
         if dry_run:
             return_stats = True
@@ -228,7 +233,14 @@ class ContextManager:
             stats.warnings_emitted = captured
             prov = cost_provider if cost_provider is not None else self.cost_provider
             if prov is not None:
-                stats.attach_cost(provider=prov, model=self.model or "gpt-4o-mini")
+                out_tok = (
+                    output_tokens if output_tokens is not None else self.cost_output_tokens
+                )
+                stats.attach_cost(
+                    provider=prov,
+                    model=self.model or "gpt-4o-mini",
+                    output_tokens=out_tok,
+                )
         if dry_run:
             messages_out = denormalize_output(clone_conversation(conv), ctx)
         else:
@@ -249,6 +261,7 @@ class ContextManager:
         return_stats: bool = False,
         dry_run: bool = False,
         cost_provider: str | None = None,
+        output_tokens: int | None = None,
     ) -> list[Any] | list[CompressionResult]:
         """Run ``compress()`` on each conversation in ``conversations``."""
         if not isinstance(conversations, list):
@@ -263,6 +276,7 @@ class ContextManager:
                 return_stats=return_stats,
                 dry_run=dry_run,
                 cost_provider=cost_provider,
+                output_tokens=output_tokens,
             )
             for messages in conversations
         ]
@@ -278,6 +292,7 @@ class ContextManager:
         return_stats: bool = False,
         dry_run: bool = False,
         cost_provider: str | None = None,
+        output_tokens: int | None = None,
     ) -> Any | CompressionResult:
         """Async wrapper around ``compress()`` (runs in a worker thread)."""
         return await asyncio.to_thread(
@@ -290,6 +305,7 @@ class ContextManager:
             return_stats=return_stats,
             dry_run=dry_run,
             cost_provider=cost_provider,
+            output_tokens=output_tokens,
         )
 
     def set_compression(self, compression: str) -> None:

{contextpress-0.6.2 → contextpress-0.6.4}/contextpress/models.py

@@ -25,7 +25,7 @@ class Turn:
     This is the canonical unit the entire pipeline operates on.
     """
 
-    role: str  # "user" | "assistant" | "system"
+    role: str  # "user" | "assistant" | "system" | "tool" | "function"
     content: str | list[ContentBlock]  # string for simple, list for multimodal
     timestamp: datetime | None = None
     metadata: dict[str, Any] = field(default_factory=dict)

{contextpress-0.6.2 → contextpress-0.6.4}/contextpress/normalizer.py

@@ -12,11 +12,14 @@ from typing import Any
 
 from contextpress.models import ContentBlock, Conversation, Turn
 
-_VALID_ROLES = frozenset({"user", "assistant", "system"})
+_VALID_ROLES = frozenset({"user", "assistant", "system", "tool", "function"})
+_TOOL_COPY_KEYS = ("tool_calls", "tool_call_id", "name")
 _LC_TYPE_MAP = {
     "human": "user",
     "ai": "assistant",
     "system": "system",
+    "tool": "tool",
+    "function": "function",
 }
 
 
@@ -201,6 +204,9 @@ def normalize_messages(
             ts = _parse_timestamp(d)
             content = d.get("content", "")
             meta: dict[str, Any] = {"_dict_index": i, "_original_dict": d}
+            for key in _TOOL_COPY_KEYS:
+                if key in d:
+                    meta[key] = copy.deepcopy(d[key])
 
             if isinstance(content, list):
                 blocks = _blocks_from_openai_style(content)
@@ -247,15 +253,14 @@ def denormalize_output(conversation: Conversation, ctx: dict[str, Any]) -> Any:
         return out
 
     if fmt == "langchain":
-        # Reconstruct LangChain objects by copying original and setting content
-        lc_objs = ctx.get("lc_objects", [])
-        if not lc_objs:
-            return []
+        # Reconstruct LangChain objects from the turn's original message, not list index
+        # (dropped turns would otherwise remap remaining content onto the wrong objects).
         result = []
-        for i, t in enumerate(turns):
-            if i < len(lc_objs):
-                obj = copy.copy(lc_objs[i])
-                text = _turn_to_plain_text(t)
+        for t in turns:
+            orig = t.metadata.get("_lc_original") or t.metadata.get("_lc_obj")
+            text = _turn_to_plain_text(t)
+            if orig is not None:
+                obj = copy.copy(orig)
                 if hasattr(obj, "content"):
                     try:
                         obj.content = text
@@ -270,7 +275,7 @@ def denormalize_output(conversation: Conversation, ctx: dict[str, Any]) -> Any:
                         self.type = role
                         self.content = content
 
-                result.append(_Msg(t.role, _turn_to_plain_text(t)))
+                result.append(_Msg(t.role, text))
         return result
 
     # dict_list
@@ -283,8 +288,17 @@ def denormalize_output(conversation: Conversation, ctx: dict[str, Any]) -> Any:
             base["role"] = t.role
         if isinstance(t.content, list):
             base["content"] = _blocks_to_openai_style(t.content)
+        elif (
+            t.content == ""
+            and isinstance(t.metadata.get("_original_dict"), dict)
+            and t.metadata["_original_dict"].get("content") is None
+        ):
+            base["content"] = None
         else:
             base["content"] = t.content
+        for key in _TOOL_COPY_KEYS:
+            if key in t.metadata:
+                base[key] = copy.deepcopy(t.metadata[key])
         out_dicts.append(base)
     return out_dicts
 

{contextpress-0.6.2 → contextpress-0.6.4}/contextpress/stats.py

@@ -10,6 +10,7 @@ import tiktoken
 from contextpress.costs import estimate_token_cost
 from contextpress.models import Conversation, Turn
 from contextpress.normalizer import extract_text_for_processing
+from contextpress.tools import tool_payload_text
 
 
 def get_encoding(model: str | None) -> tiktoken.Encoding:
@@ -26,6 +27,9 @@ def count_turn_tokens(turn: Turn, encoding: tiktoken.Encoding) -> int:
         body = turn.content
     else:
         body = extract_text_for_processing(turn)
+    extra = tool_payload_text(turn)
+    if extra:
+        body = f"{body}\n{extra}" if body else extra
     return len(encoding.encode(f"{turn.role}\n{body}"))
 
 
@@ -57,6 +61,11 @@ class CompressionStats:
     cost_model: str | None = None
     estimated_input_cost_before_usd: float | None = None
     estimated_input_cost_after_usd: float | None = None
+    # Optional completion-side estimate (0.6.3+); same before/after (compression is input-only)
+    estimated_output_tokens: int | None = None
+    estimated_output_cost_usd: float | None = None
+    estimated_total_cost_before_usd: float | None = None
+    estimated_total_cost_after_usd: float | None = None
 
     @property
     def turns_removed(self) -> int:
@@ -86,14 +95,32 @@ class CompressionStats:
         *,
         provider: str = "openai",
         model: str | None = "gpt-4o-mini",
+        output_tokens: int = 0,
     ) -> CompressionStats:
-        """Fill USD fields from ``tokens_before`` / ``tokens_after``. Returns self."""
-        before = estimate_token_cost(self.tokens_before, provider=provider, model=model)
-        after = estimate_token_cost(self.tokens_after, provider=provider, model=model)
+        """Fill USD fields from ``tokens_before`` / ``tokens_after``. Returns self.
+
+        ``output_tokens`` is an assumed completion size (unchanged by compression).
+        """
+        before = estimate_token_cost(
+            self.tokens_before, provider=provider, model=model, output_tokens=output_tokens
+        )
+        after = estimate_token_cost(
+            self.tokens_after, provider=provider, model=model, output_tokens=output_tokens
+        )
         self.cost_provider = before.provider
         self.cost_model = before.model
         self.estimated_input_cost_before_usd = before.input_cost_usd
         self.estimated_input_cost_after_usd = after.input_cost_usd
+        if output_tokens > 0:
+            self.estimated_output_tokens = after.output_tokens
+            self.estimated_output_cost_usd = after.output_cost_usd
+            self.estimated_total_cost_before_usd = before.total_cost_usd
+            self.estimated_total_cost_after_usd = after.total_cost_usd
+        else:
+            self.estimated_output_tokens = None
+            self.estimated_output_cost_usd = None
+            self.estimated_total_cost_before_usd = None
+            self.estimated_total_cost_after_usd = None
         return self
 
     def summary(self) -> str:
@@ -118,6 +145,14 @@ class CompressionStats:
                 "est. input cost: "
                 f"${before_usd:.6f} -> ${after_usd:.6f} (saved ${saved:.6f})"
             )
+        out_usd = self.estimated_output_cost_usd
+        out_tok = self.estimated_output_tokens
+        if out_usd is not None and out_tok is not None:
+            lines.append(f"est. output cost: ${out_usd:.6f} ({out_tok} tokens)")
+        total_before = self.estimated_total_cost_before_usd
+        total_after = self.estimated_total_cost_after_usd
+        if total_before is not None and total_after is not None:
+            lines.append(f"est. total: ${total_before:.6f} -> ${total_after:.6f}")
         return "\n".join(lines)
 
     def to_dict(self) -> dict[str, Any]:
@@ -145,6 +180,10 @@ class CompressionStats:
             "estimated_input_cost_before_usd": self.estimated_input_cost_before_usd,
             "estimated_input_cost_after_usd": self.estimated_input_cost_after_usd,
             "estimated_cost_saved_usd": self.estimated_cost_saved_usd,
+            "estimated_output_tokens": self.estimated_output_tokens,
+            "estimated_output_cost_usd": self.estimated_output_cost_usd,
+            "estimated_total_cost_before_usd": self.estimated_total_cost_before_usd,
+            "estimated_total_cost_after_usd": self.estimated_total_cost_after_usd,
         }
 
 

{contextpress-0.6.2 → contextpress-0.6.4}/contextpress/strategies/budget.py

@@ -8,6 +8,7 @@ import tiktoken
 from contextpress.models import Conversation, Turn
 from contextpress.stats import count_turn_tokens, get_encoding
 from contextpress.strategies.base import BaseStrategy
+from contextpress.tools import tool_group_indices
 
 
 def _truncate_system_turn(turn: Turn, encoding: tiktoken.Encoding, max_tokens: int) -> Turn:
@@ -73,9 +74,17 @@ class BudgetStrategy(BaseStrategy):
             keep = min(2, len(ns_positions))
             protected = set(ns_positions[-keep:]) if keep else set()
             removable = [i for i in ns_positions if i not in protected]
-            if removable:
-                turns.pop(removable[0])
-                n_removed += 1
+            group: list[int] | None = None
+            for idx in removable:
+                candidate = tool_group_indices(turns, idx)
+                if any(g in protected for g in candidate):
+                    continue
+                group = candidate
+                break
+            if group is not None:
+                for g in sorted(group, reverse=True):
+                    turns.pop(g)
+                    n_removed += 1
                 continue
 
             # Last resort: truncate system (see behavior contract note on invariant 1)

{contextpress-0.6.2 → contextpress-0.6.4}/contextpress/strategies/filler.py

@@ -6,6 +6,7 @@ import re
 from contextpress.models import Conversation, Turn
 from contextpress.normalizer import apply_text_to_turn, extract_text_for_processing
 from contextpress.strategies.base import BaseStrategy
+from contextpress.tools import has_tool_marker
 
 # Curated lists — longer phrases first for safe replacement order
 FILLER_PHRASES = [
@@ -70,16 +71,6 @@ ACKNOWLEDGEMENT_PHRASES = [
     "thank you for that",
 ]
 
-_TOOL_MARKERS = ("tool_calls", "tool_call", "tool_use", "tool_result", "<tool", "[tool")
-
-
-def _has_tool_marker(turn: Turn) -> bool:
-    meta = turn.metadata or {}
-    if any(k in meta for k in ("tool_calls", "tool_call", "tool_use", "tool_result")):
-        return True
-    text = extract_text_for_processing(turn).lower()
-    return any(m in text for m in _TOOL_MARKERS)
-
 
 def _build_filler_pattern() -> re.Pattern[str]:
     pattern_parts: list[str] = []
@@ -155,7 +146,7 @@ class FillerStrategy(BaseStrategy):
                     new_turns.append(nt)
                 continue
 
-            if self.conv_type == "agent" and _has_tool_marker(turn):
+            if has_tool_marker(turn):
                 new_turns.append(copy.deepcopy(turn))
                 continue
 

{contextpress-0.6.2 → contextpress-0.6.4}/contextpress/strategies/structure.py

@@ -9,6 +9,7 @@ import re
 from contextpress.models import Conversation, Turn
 from contextpress.normalizer import apply_text_to_turn, extract_text_for_processing
 from contextpress.strategies.base import BaseStrategy
+from contextpress.tools import minify_tool_fields
 
 _CODE_FENCE = re.compile(r"(```[\s\S]*?```)", re.MULTILINE)
 _MULTI_BLANK = re.compile(r"\n{3,}")
@@ -85,9 +86,10 @@ class StructureStrategy(BaseStrategy):
             text = extract_text_for_processing(turn)
             compacted = compact_structure_text(text, aggressiveness=self.aggressiveness)
             if compacted != text:
-                new_turns.append(apply_text_to_turn(turn, compacted))
+                nt = apply_text_to_turn(turn, compacted)
             else:
-                new_turns.append(copy.deepcopy(turn))
+                nt = copy.deepcopy(turn)
+            new_turns.append(minify_tool_fields(nt))
         return Conversation(
             turns=new_turns,
             type=conversation.type,