kolega-code 0.7.1__tar.gz → 0.8.0__tar.gz

{kolega_code-0.7.1 → kolega_code-0.8.0}/.env.example

@@ -7,6 +7,7 @@ OPENAI_API_KEY=
 # (no key needed). Optional override of the OAuth client id, for testing only:
 # KOLEGA_CODE_CHATGPT_CLIENT_ID=
 GOOGLE_API_KEY=
+FIREWORKS_API_KEY=
 MOONSHOT_API_KEY=
 DEEPSEEK_API_KEY=
 ZAI_API_KEY=

{kolega_code-0.7.1 → kolega_code-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.7.1
+Version: 0.8.0
 Summary: Local-first AI coding agent for the terminal
 Project-URL: Homepage, https://kolega-ai.github.io/kolega-code/
 Project-URL: Documentation, https://kolega-ai.github.io/kolega-code/
@@ -54,6 +54,7 @@ Requires-Dist: nest-asyncio==1.6.0
 Requires-Dist: openai==1.109.1
 Requires-Dist: packaging==25.0
 Requires-Dist: pathspec==1.1.1
+Requires-Dist: pillow==12.2.0
 Requires-Dist: playwright==1.59.0
 Requires-Dist: psutil==7.2.2
 Requires-Dist: pydantic==2.13.4

{kolega_code-0.7.1 → kolega_code-0.8.0}/RELEASING.md

@@ -20,6 +20,12 @@ release branch.
 2. Update `pyproject.toml`, `uv.lock`, and package `__version__` values to the
    release version.
 
+   Running `uv lock` advances the `exclude-newer` cutoff recorded in `uv.lock`,
+   because `pyproject.toml` sets `exclude-newer = "1 week"` as a relative
+   duration. The cutoff timestamp moving forward, and any dependency versions
+   released within the new one-week window being pulled in, is expected and
+   acceptable. Do not revert these changes.
+
 3. Run the fast test suite:
 
    ```bash

{kolega_code-0.7.1 → kolega_code-0.8.0}/docs/src/content/docs/concepts/agents.md

@@ -12,10 +12,10 @@ agent can hand off to the others when a task benefits from focus.
 | Agent | Specialty | Can edit files? |
 | --- | --- | --- |
 | **Coder** | The main, general-purpose coding agent. Full toolset. | Yes |
-| **Investigation** | Read-only exploration of the codebase. | No |
+| **Investigation** | Read-only exploration of the codebase. Can run investigative commands. | No |
 | **Browser** | Web navigation and interaction via Playwright. | No (browser tools only) |
 | **General** | A flexible agent that can read and dispatch other agents. | Limited |
-| **Planning** | Drives [Plan mode](../../tui/modes/): investigates and writes a plan, read-only. | No |
+| **Planning** | Drives [Plan mode](../../tui/modes/): investigates and writes a plan. Can run commands but cannot edit files. | No |
 
 ## Dispatching sub-agents
 

{kolega_code-0.7.1 → kolega_code-0.8.0}/docs/src/content/docs/concepts/tools.md

@@ -61,13 +61,16 @@ and `dispatch_general_agent`.
 ## Read-only vs. full access
 
 Tools are gated by mode. In a read-only context — like [Plan mode](../../tui/modes/)
-or an investigation sub-agent — only non-mutating tools are available
+or an investigation sub-agent — the agent can read and search the codebase
 (`list_directory`, `read_entire_file`, `read_file_section`, `search_codebase`,
 `find_files_by_pattern`, `web_search`, `web_fetch`, `think_hard`, and reading
-memory). Editing files and running commands require Build mode's full toolset.
+memory) **and** run shell commands to investigate. Editing files still requires
+Build mode's full toolset.
 
-This separation is what makes Plan mode safe to run against any codebase: the
-planning agent can look but not touch.
+This separation is what keeps Plan mode safe to run against any codebase: the
+planning agent can look and run investigative commands, but it has no file-edit
+tools. Shell commands are further gated by the active permission mode — in `ask`
+they prompt before running.
 
 In the Textual TUI, Build mode defaults to `ask` permission mode. Shell commands
 and file edits must be approved before they run unless you switch to `auto` or

{kolega_code-0.7.1 → kolega_code-0.8.0}/docs/src/content/docs/configuration/environment-variables.md

@@ -118,6 +118,7 @@ starting point:
 # Pick one provider's key (or several)
 MOONSHOT_API_KEY=
 DEEPSEEK_API_KEY=
+FIREWORKS_API_KEY=
 ANTHROPIC_API_KEY=
 
 # Optional: choose models per role
@@ -125,6 +126,10 @@ KOLEGA_CODE_PROVIDER=moonshot
 KOLEGA_CODE_MODEL=kimi-k2.7-code
 KOLEGA_CODE_THINKING_EFFORT=auto
 
+# Fireworks example:
+# KOLEGA_CODE_PROVIDER=fireworks
+# KOLEGA_CODE_MODEL=accounts/fireworks/models/glm-5p2
+
 # Optional: web search
 KOLEGA_CODE_WEB_SEARCH_BACKEND=duckduckgo
 

{kolega_code-0.7.1 → kolega_code-0.8.0}/docs/src/content/docs/configuration/providers-and-models.mdx

@@ -45,11 +45,21 @@ with thinking effort `auto` (enabled) requests route to **K2.7 Code**, and with
 (disabled) they route to **K2.6**. Set `KIMI_CODING_API_KEY` to your Kimi Coding Plan key.
 </Aside>
 
+<Aside type="tip">
+**Fireworks.ai.** The `fireworks` provider targets Fireworks' OpenAI-compatible
+serverless endpoint (`https://api.fireworks.ai/inference/v1`) with `FIREWORKS_API_KEY`.
+Fireworks model IDs use resource names such as `accounts/fireworks/models/glm-5p2`.
+Kolega Code exposes GLM-5.2, GLM-5.1, Kimi K2.7 Code, DeepSeek V4 Pro/Flash,
+MiniMax M3, and Qwen 3.7 Plus through the Settings UI and CLI. Fireworks reasoning
+models return `reasoning_content`; Kolega Code exposes `none`, `low`, `medium`,
+`high`, and `max` as `reasoning_effort` values for these models.
+</Aside>
+
 <Aside type="note">
-The **Settings tab** in the TUI currently offers a curated shortlist —
-**Moonshot (Kimi K2.7 Code and Kimi K2.6)** and **DeepSeek (DeepSeek V4 Pro)**.
-The full provider list above is available through environment variables and CLI
-flags. See [Settings & API Keys](../settings-and-api-keys/).
+The **Settings tab** in the TUI is generated from Kolega Code's model registry, so
+new entries in the supported model catalog appear there automatically. You can also
+select any supported provider/model through environment variables and CLI flags.
+See [Settings & API Keys](../settings-and-api-keys/).
 </Aside>
 
 ## Model roles
@@ -153,6 +163,7 @@ models in the TUI.
 | Moonshot `kimi-k2.6` | `auto`, `none` | `auto` |
 | Z.AI `glm-5.2` | `high`, `max` | `max` |
 | Z.AI `glm-5.1` | `auto`, `none` | `auto` |
+| Fireworks serverless reasoning models | `none`, `low`, `medium`, `high`, `max` | `medium` |
 | Google `gemini-2.5-pro` | `auto`, `low`, `medium`, `high` | `medium` |
 | OpenAI reasoning models | `low`, `medium`, `high` | `medium` |
 

{kolega_code-0.7.1 → kolega_code-0.8.0}/docs/src/content/docs/hooks.md

@@ -63,6 +63,7 @@ Both files use the same shape:
 | `PreToolUse` | Before a tool runs (after the permission gate) | Denies the tool; the reason is returned to the agent as a tool error, so it can adjust |
 | `PostToolUse` | After a tool succeeds (and on failure) | Ends the turn; the reason is shown as a warning |
 | `PreCompact` | Before the conversation is compacted | Advisory |
+| `PostCompact` | After the conversation is compacted | Advisory; payload reports before/after token counts |
 | `Stop` | The agent is about to finish its turn | Keeps the agent working; the reason becomes its next instruction |
 | `SubagentStop` | A dispatched sub-agent finished | Advisory; can annotate the result the parent sees |
 | `Notification` | A permission prompt is about to be shown | Advisory (desktop notifications, sounds) |

{kolega_code-0.7.1 → kolega_code-0.8.0}/docs/src/content/docs/tui/modes.md

@@ -35,6 +35,8 @@ produces a plan.
 While planning, the agent can:
 
 - Read and search the codebase.
+- Run shell commands to investigate (e.g. `git log`, `grep`, running tests) —
+  subject to the current permission mode, so commands prompt for approval in `ask`.
 - Maintain a shared **task list** (visible in the Planning tab).
 - Write a structured plan, which appears in the **Planning** tab.
 

{kolega_code-0.7.1 → kolega_code-0.8.0}/kolega_code/__init__.py

@@ -148,4 +148,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.7.1"
+__version__ = "0.8.0"

{kolega_code-0.7.1 → kolega_code-0.8.0}/kolega_code/agent/__init__.py

@@ -39,4 +39,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.7.1"
+__version__ = "0.8.0"

{kolega_code-0.7.1 → kolega_code-0.8.0}/kolega_code/agent/baseagent.py

@@ -11,11 +11,11 @@ from pathlib import Path
 from typing import Any, AsyncGenerator, Dict, List, Optional
 
 from .common import LogMixin
-from .compression import HistoryCompressor
+from .compression import CompactionResult, HistoryCompressor
 from kolega_code.config import AgentConfig, ModelProvider
 from kolega_code.events import AgentConnectionManager
 from .context import AgentContext, AgentServices, Telemetry, WorkspaceInfo
-from .conversation import Conversation
+from .conversation import Conversation, adapt_history_for_provider
 from kolega_code.events import AgentEventEmitter
 from kolega_code.hooks import (
     NO_OP_DISPATCHER,
@@ -34,7 +34,7 @@ from kolega_code.llm.exceptions import (
 )
 from kolega_code.llm.models import ImageBlock, Message, MessageHistory, TextBlock, ToolCall, ToolResult
 from kolega_code.llm.providers.models import TokenCount
-from kolega_code.llm.specs import get_model_specs
+from kolega_code.llm.specs import get_model_specs, supports_vision as model_supports_vision
 from kolega_code.permissions import (
     PermissionDecision,
     PermissionMode,
@@ -90,10 +90,6 @@ class BaseAgent(LogMixin):
     long_content_tool_calls = ["create_file", "replace_entire_file"]
     max_tool_result_chars_in_history = 100_000
     skill_content_pattern = re.compile(r'<skill_content name="[^"]+">')
-    deepseek_image_unsupported_message = (
-        "DeepSeek V4 Pro does not support image input via the DeepSeek API. "
-        "Remove the image or switch to a vision-capable model for this request."
-    )
 
     def __init__(
         self,
@@ -270,6 +266,11 @@ class BaseAgent(LogMixin):
         self.model_context_length = model_specs["context_length"]
         self.model_completion_tokens = model_specs["max_completion_tokens"]
         self.model_default_temperature = model_specs.get("default_temperature", 1.0)
+        # Whether this agent's primary model can accept image input. Read by the
+        # ToolCollection read_image tool gate (so non-vision models never see the
+        # tool) and used by _unsupported_attachment_message to reject image
+        # attachments for non-vision models with a clear message.
+        self.supports_vision = bool(model_specs.get("supports_vision", False))
 
         self.llm = context.create_llm_client(agent_name=self.agent_name)
 
@@ -365,6 +366,26 @@ class BaseAgent(LogMixin):
         """
         return self.conversation.repaired(messages)
 
+    def _history_for_llm(self) -> MessageHistory:
+        """Build the message history to send to the LLM for this turn.
+
+        Compaction-aware and tool-call-repaired. For non-vision models, any
+        ``ImageBlock`` carried over from earlier turns (user attachments or
+        ``read_image`` tool results) is replaced with a text placeholder on this
+        request copy only — the stored history is never mutated, so switching
+        back to a vision-capable model restores the images.
+        """
+        effective = self.get_effective_history_for_llm()
+        fixed = self.fix_incomplete_tool_calls(list(effective))
+        provider = getattr(self.primary_model_config.provider, "value", self.primary_model_config.provider)
+        fixed = adapt_history_for_provider(
+            fixed,
+            target_provider=str(provider),
+            target_model=self.primary_model_config.model,
+            supports_vision=self.supports_vision,
+        )
+        return MessageHistory(fixed)
+
     def mark_cache_checkpoint(self) -> None:
         """
         Mark the last message in history for caching and remove cache_control from all other messages.
@@ -398,6 +419,14 @@ class BaseAgent(LogMixin):
         """Restores the message history from a list of dictionaries using custom methods."""
         self.conversation.restore(serialized_history)
 
+    def dump_compaction_state(self) -> Dict[str, Any]:
+        """Serialize the compaction boundary (summary + how many leading messages it folds)."""
+        return self.conversation.dump_compaction()
+
+    def restore_compaction_state(self, data: Optional[Dict[str, Any]]) -> None:
+        """Restore the compaction boundary; must be called after restore_message_history."""
+        self.conversation.restore_compaction(data)
+
     def _sanitize_oversized_tool_results(self) -> int:
         return self.conversation.sanitize_oversized_tool_results()
 
@@ -472,18 +501,22 @@ class BaseAgent(LogMixin):
     # ------------------------------------------------------------------
 
     def _unsupported_attachment_message(self, attachments: Optional[List[Dict[str, Any]]]) -> Optional[str]:
+        if not any(attachment.get("type") == "image" for attachment in attachments or []):
+            return None
+
         provider = getattr(
             self.primary_model_config.provider,
             "value",
             self.primary_model_config.provider,
         )
-        if provider != ModelProvider.DEEPSEEK.value:
+        if model_supports_vision(provider, self.primary_model_config.model):
             return None
 
-        if any(attachment.get("type") == "image" for attachment in attachments or []):
-            return self.deepseek_image_unsupported_message
-
-        return None
+        return (
+            f"{self.primary_model_config.model} does not support image input. "
+            "Your message was not sent to the model. "
+            "Remove the image attachment or switch to a vision-capable model with /model."
+        )
 
     def _attachment_blocks(self, attachments: Optional[List[Dict[str, Any]]]) -> List[Any]:
         """Convert attachment payloads into content blocks for a user message."""
@@ -510,9 +543,9 @@ class BaseAgent(LogMixin):
 
     async def count_current_context(self) -> TokenCount:
         self._sanitize_oversized_tool_results()
-        # Fix history before counting to get accurate count for what LLM will see
-        effective = self.get_effective_history_for_llm()
-        fixed_history = MessageHistory(self.fix_incomplete_tool_calls(list(effective)))
+        # History sent to the LLM (and to token counting): tool-call-repaired and,
+        # for non-vision models, stripped of image blocks from earlier turns.
+        fixed_history = self._history_for_llm()
         token_count = await self.llm.count_tokens(
             system=self.system_prompt,
             messages=fixed_history,
@@ -549,9 +582,12 @@ class BaseAgent(LogMixin):
             message=message,
         )
 
-    async def compress_history(self) -> None:
+    async def compress_history(self) -> CompactionResult:
         """
-        Non-destructively summarize the current history and mark a compression boundary.
+        Non-destructively summarize the current history, keeping recent turns
+        verbatim. Emits a compaction_status event around the work so the UI can
+        show progress, then recounts + emits a context_update so the gauge
+        refreshes. Returns the structured outcome.
         """
 
         async def on_info(message: str) -> None:
@@ -560,16 +596,34 @@ class BaseAgent(LogMixin):
         async def on_error(message: str) -> None:
             await self.log_error(message, sender=self.agent_name)
 
-        await self.compressor.summarize(
-            self.conversation,
-            llm=self.llm,
-            model=self.primary_model_config.model,
-            max_completion_tokens=self.model_completion_tokens,
-            temperature=self.model_default_temperature,
-            thinking=self.primary_model_config.thinking_effort,
-            on_info=on_info,
-            on_error=on_error,
+        await self.emitter.compaction_status("started", "Compacting conversation…")
+        try:
+            result = await self.compressor.summarize(
+                self.conversation,
+                llm=self.llm,
+                model=self.primary_model_config.model,
+                temperature=self.model_default_temperature,
+                # No extended thinking: a bounded summary doesn't need it, and the
+                # thinking budget could otherwise exceed the small summary max_tokens.
+                thinking=None,
+                on_info=on_info,
+                on_error=on_error,
+            )
+        finally:
+            # Recount + emit so the context gauge reflects post-compaction reality
+            # (even on a no-op the UI may have been stale).
+            await self.count_current_context()
+
+        phase = "finished" if result.ok else "error"
+        summary_text = (
+            self.conversation.summary.get_text_content() if result.ok and self.conversation.summary else ""
         )
+        await self.emitter.compaction_status(phase, result.message, summary=summary_text)
+        return result
+
+    def clear_history(self) -> None:
+        """Drop all history and reset compaction state."""
+        self.conversation.clear()
 
     # ------------------------------------------------------------------
     # Tool execution
@@ -1136,9 +1190,8 @@ class BaseAgent(LogMixin):
     #
     # process_message_stream is the single canonical loop shared by every
     # agent. Subclasses customize behavior through the hook methods below
-    # (build_user_content, apply_compression_fallback, on_tool_use_start,
-    # should_stop_after_tools, recap_agent_outcome) rather than overriding
-    # the loop itself.
+    # (build_user_content, on_tool_use_start, should_stop_after_tools,
+    # recap_agent_outcome) rather than overriding the loop itself.
     # ------------------------------------------------------------------
 
     completion_log_message = "Processing complete"
@@ -1166,21 +1219,6 @@ class BaseAgent(LogMixin):
 
         return content_blocks
 
-    def apply_compression_fallback(self) -> None:
-        """
-        Hard-truncate history when compression alone could not get under budget.
-
-        Default: keep the first message (the original task) plus any protected
-        skill-content messages.
-        """
-        first_message = self.history[0]
-        protected = [
-            message
-            for message in self.history
-            if message is not first_message and self._is_protected_skill_content(message)
-        ]
-        self.history = MessageHistory(protected + [first_message])
-
     async def on_tool_use_start(self, tool_call_delta: Dict[str, Any]) -> None:
         """
         Called when the provider streams a tool_use_start event (Anthropic only).
@@ -1252,20 +1290,35 @@ class BaseAgent(LogMixin):
                 logger.debug("Input token count: %s", token_count)
 
                 if self.compressor.over_budget(token_count.input_tokens, self.model_context_length):
+                    before_tokens = token_count.input_tokens
                     # PreCompact hooks (advisory): observe before history is compacted.
                     await self.fire_hook(
                         HookEvent.PRE_COMPACT,
                         {
                             "trigger": "auto",
-                            "input_tokens": token_count.input_tokens,
+                            "input_tokens": before_tokens,
                             "model_context_length": self.model_context_length,
                         },
                     )
-                    await self.compress_history()
+                    result = await self.compress_history()
                     token_count = await self.count_current_context()
 
-                    if self.compressor.over_budget(token_count.input_tokens, self.model_context_length):
-                        self.apply_compression_fallback()
+                    # PostCompact hooks (advisory): observe the outcome. There is no
+                    # destructive fallback — a bounded summary plus capped tool results
+                    # and a small verbatim tail keep us under budget; if somehow not, we
+                    # send as-is rather than wipe history.
+                    await self.fire_hook(
+                        HookEvent.POST_COMPACT,
+                        {
+                            "trigger": "auto",
+                            "ok": result.ok,
+                            "reason": result.reason,
+                            "summarized_messages": result.summarized_messages,
+                            "input_tokens_before": before_tokens,
+                            "input_tokens_after": token_count.input_tokens,
+                            "model_context_length": self.model_context_length,
+                        },
+                    )
 
                     self.mark_cache_checkpoint()
 
@@ -1276,9 +1329,9 @@ class BaseAgent(LogMixin):
                 response_uuid = str(uuid.uuid4())
                 thinking_uuid = str(uuid.uuid4())
 
-                # Fix history before sending to LLM to ensure valid tool call sequences
-                effective = self.get_effective_history_for_llm()
-                fixed_history = MessageHistory(self.fix_incomplete_tool_calls(list(effective)))
+                # History sent to the LLM: tool-call-repaired and, for non-vision
+                # models, stripped of image blocks carried over from earlier turns.
+                fixed_history = self._history_for_llm()
 
                 async with await self.llm.stream(
                     system=self.system_prompt,

kolega_code-0.8.0/kolega_code/agent/compression.py

@@ -0,0 +1,146 @@
+"""History compression: summarize a conversation when it outgrows the context window."""
+
+import logging
+from dataclasses import dataclass
+from typing import Awaitable, Callable, Optional
+
+from .conversation import Conversation
+from kolega_code.llm.models import Message, MessageHistory, TextBlock
+from .prompts import (
+    build_compression_summary_user_prompt,
+    COMPRESSION_SUMMARY_SYSTEM_PROMPT,
+)
+
+logger = logging.getLogger(__name__)
+
+LogCallback = Callable[[str], Awaitable[None]]
+
+
+@dataclass(frozen=True)
+class CompactionResult:
+    """Outcome of a compaction attempt, surfaced to callers and the UI.
+
+    ``reason`` is a machine tag: "ok" | "too_few" | "nothing_to_summarize" | "llm_error".
+    ``message`` is a human-readable line for the command output / logs.
+    """
+
+    ok: bool
+    reason: str
+    summarized_messages: int = 0
+    message: str = ""
+
+
+class HistoryCompressor:
+    """Summarizes a conversation non-destructively when it crosses the budget threshold."""
+
+    MIN_MESSAGES_TO_COMPRESS = 5
+    # How many of the most recent messages to keep verbatim after the summary.
+    KEEP_RECENT_MESSAGES = 6
+    # Don't bother summarizing a trivially short prefix.
+    MIN_PREFIX_TO_SUMMARIZE = 3
+    # Cap the summary length: the prompt targets ~600 words (~900 tokens), so a
+    # small ceiling keeps it tight and avoids the model's full completion budget.
+    SUMMARY_MAX_TOKENS = 2048
+
+    def __init__(self, threshold: float = 0.8) -> None:
+        # Fraction of the model context window above which compression kicks in
+        self.threshold = threshold
+
+    def over_budget(self, input_tokens: int, model_context_length: int) -> bool:
+        return input_tokens > model_context_length * self.threshold
+
+    async def summarize(
+        self,
+        conversation: Conversation,
+        *,
+        llm,
+        model: str,
+        temperature: float,
+        thinking,
+        on_info: Optional[LogCallback] = None,
+        on_error: Optional[LogCallback] = None,
+    ) -> CompactionResult:
+        """
+        Non-destructively summarize the aged-out prefix while keeping the most
+        recent turns verbatim, and move the compaction boundary.
+
+        Incremental: only the messages that have aged out since the previous
+        boundary are summarized, with the prior summary folded in for continuity.
+        Returns a CompactionResult describing what happened — never a silent no-op.
+        """
+        history = conversation.history
+        if not history or len(history) < self.MIN_MESSAGES_TO_COMPRESS:
+            return CompactionResult(
+                ok=False,
+                reason="too_few",
+                message=(
+                    f"Nothing to compress yet ({len(history)} message(s); "
+                    f"need at least {self.MIN_MESSAGES_TO_COMPRESS})."
+                ),
+            )
+
+        split = conversation.compaction_split_point(
+            keep_recent=self.KEEP_RECENT_MESSAGES, min_prefix=self.MIN_PREFIX_TO_SUMMARIZE
+        )
+        prior_through = conversation.compacted_through if conversation.summary is not None else 0
+        if split is None or split <= prior_through:
+            return CompactionResult(
+                ok=False,
+                reason="nothing_to_summarize",
+                message="Already compact — no older messages to summarize.",
+            )
+
+        if on_info:
+            await on_info("Compressing message history...")
+
+        try:
+            prefix = MessageHistory(list(history[prior_through:split]))
+            prefix_markdown = prefix.get_markdown_conversation()
+            previous_summary = conversation.summary.get_text_content() if conversation.summary is not None else None
+            user_prompt_filled = build_compression_summary_user_prompt(
+                prefix_markdown, previous_summary=previous_summary
+            )
+
+            messages = MessageHistory([Message(role="user", content=[TextBlock(text=user_prompt_filled)])])
+            system_message = Message(role="system", content=[TextBlock(text=COMPRESSION_SUMMARY_SYSTEM_PROMPT)])
+
+            # Stream and drain rather than calling generate(): the Anthropic SDK
+            # rejects non-streaming requests whose max_tokens is large enough to risk
+            # a >10-minute response, which the model's full completion budget triggers.
+            async with await llm.stream(
+                messages=messages,
+                system=system_message,
+                temperature=temperature,
+                model=model,
+                max_completion_tokens=self.SUMMARY_MAX_TOKENS,
+                thinking=thinking,
+            ) as stream:
+                async for _event in stream:
+                    pass
+            response = await stream.get_final_message()
+
+            summary_text = response.get_text_content()
+            if not summary_text or not summary_text.strip():
+                msg = "Compression produced an empty summary; history left unchanged."
+                if on_error:
+                    await on_error(msg)
+                else:
+                    logger.error(msg)
+                return CompactionResult(ok=False, reason="llm_error", message=msg)
+
+            folded = split - prior_through
+            conversation.apply_compaction(summary_text, split)
+
+            done = f"Compressed {folded} older message(s) into a summary; kept the latest turns verbatim."
+            if on_info:
+                await on_info(done)
+            return CompactionResult(ok=True, reason="ok", summarized_messages=folded, message=done)
+
+        except Exception as e:
+            # Never swallow into a fake success: log the full traceback and surface
+            # the real error to the caller.
+            logger.exception("Failed to compress message history")
+            msg = f"Failed to compress message history: {type(e).__name__}: {e}"
+            if on_error:
+                await on_error(msg)
+            return CompactionResult(ok=False, reason="llm_error", message=msg)