kolega-code 0.28.2__tar.gz → 0.28.4__tar.gz

{kolega_code-0.28.2 → kolega_code-0.28.4}/CHANGELOG.md

@@ -6,6 +6,22 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 0.28.4 - 2026-08-12
+
+### Fixed
+
+- Conversation compaction now keeps the summarization request within the run's
+  input token budget, so auto-compaction no longer fails on long conversations
+  and lets the run continue instead of aborting.
+
+## 0.28.3 - 2026-08-12
+
+### Changed
+
+- Claude-style `edit` and `write` tools are now the default model-facing edit
+  protocol. Explicit overrides and model-catalog preferences still take
+  precedence, and the legacy search/replace protocol remains available.
+
 ## 0.28.2 - 2026-08-12
 
 ### Fixed

{kolega_code-0.28.2 → kolega_code-0.28.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.28.2
+Version: 0.28.4
 Summary: Multi-agent coding in the terminal
 Project-URL: Homepage, https://kolega-ai.github.io/kolega-code/
 Project-URL: Documentation, https://kolega-ai.github.io/kolega-code/

{kolega_code-0.28.2 → kolega_code-0.28.4}/kolega_code/__init__.py

@@ -173,4 +173,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.28.2"
+__version__ = "0.28.4"

{kolega_code-0.28.2 → kolega_code-0.28.4}/kolega_code/agent/__init__.py

@@ -51,4 +51,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.28.2"
+__version__ = "0.28.4"

{kolega_code-0.28.2 → kolega_code-0.28.4}/kolega_code/agent/baseagent.py

@@ -321,7 +321,7 @@ class BaseAgent(LogMixin):
         self.primary_model_config = self.config.model_config_for_agent(self.agent_name)
         resolved_edit_protocol = self.config.resolve_edit_protocol(self.primary_model_config)
         self.edit_protocol = (
-            resolved_edit_protocol if isinstance(resolved_edit_protocol, EditProtocol) else EditProtocol.SEARCH_REPLACE
+            resolved_edit_protocol if isinstance(resolved_edit_protocol, EditProtocol) else EditProtocol.CLAUDE_CODE
         )
         self.filesystem = context.services.filesystem
         self.terminal_manager = context.services.terminal_manager
@@ -1208,6 +1208,7 @@ class BaseAgent(LogMixin):
                 on_error=on_error,
                 system_prompt_text=compaction_system_prompt,
                 keep_recent=keep_recent,
+                max_input_tokens=self.model_max_input_tokens,
             )
             if result.ok:
                 # Compaction summarizes the injected volatile-context blocks along with

kolega_code-0.28.4/kolega_code/agent/compression.py

@@ -0,0 +1,324 @@
+"""History compression: summarize a conversation when it outgrows the context window."""
+
+import json
+import logging
+from dataclasses import dataclass
+from typing import Awaitable, Callable, List, Optional
+
+from .conversation import Conversation, replace_image_blocks_with_placeholders
+from kolega_code.llm.exceptions import LLMContextWindowExceededError
+from kolega_code.llm.ledger import helper_origin, llm_call_origin
+from kolega_code.llm.models import Message, MessageHistory, TextBlock, ToolCall, ToolResult
+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 = ""
+
+
+def _render_transcript(messages: List[Message]) -> str:
+    """Role-tagged plain text: JSON only for tool arguments, tool results raw.
+
+    JSON-escaping newline-heavy tool output costs ~30% more tokens than
+    leaving it raw.
+    """
+    out: List[str] = []
+    for message in messages:
+        if isinstance(message.content, str):
+            if message.content:
+                out.append(f"[{message.role}]\n{message.content}")
+            continue
+        for block in message.content:
+            if isinstance(block, ToolCall):
+                try:
+                    args = json.dumps(block.input, ensure_ascii=False)
+                except (TypeError, ValueError):
+                    args = str(block.input)
+                out.append(f"[assistant → {block.name}] {args}")
+            elif isinstance(block, ToolResult):
+                if isinstance(block.content, str):
+                    body = block.content
+                else:
+                    body = "\n".join(getattr(item, "text", "") or "" for item in block.content)
+                tag = "error" if block.is_error else "result"
+                out.append(f"[{block.name} {tag}]\n{body}")
+            else:
+                text = getattr(block, "text", None)
+                thinking = getattr(block, "thinking", None)
+                if text:
+                    out.append(f"[{message.role}]\n{text}")
+                elif thinking:
+                    out.append(f"[{message.role} thinking]\n{thinking}")
+    return "\n\n".join(out)
+
+
+def _omission_notice(omitted: int) -> str:
+    return f"[... {omitted} conversation message(s) omitted here so the compaction request fits the context budget ...]"
+
+
+def _approx_message_chars(message: Message) -> int:
+    """Size proxy for picking the omission gap; the request is re-counted before dispatch."""
+    if isinstance(message.content, str):
+        return len(message.content)
+    chars = 0
+    for block in message.content:
+        if isinstance(block, ToolCall):
+            try:
+                chars += len(json.dumps(block.input))
+            except (TypeError, ValueError):
+                chars += len(str(block.input))
+        elif isinstance(block, ToolResult):
+            if isinstance(block.content, str):
+                chars += len(block.content)
+            else:
+                chars += sum(len(getattr(item, "text", "") or "") for item in block.content)
+        else:
+            chars += len(getattr(block, "text", "") or "") + len(getattr(block, "thinking", "") or "")
+    return chars
+
+
+def _middle_gap(weights: List[int], target_chars: float) -> tuple[int, int]:
+    """Pick the (head_end, tail_start) gap keeping ~``target_chars``: half from the
+    oldest messages (task statement), half from the newest (continuity)."""
+    half = target_chars / 2
+    head_end, acc = 0, 0
+    for index, weight in enumerate(weights):
+        if acc + weight > half:
+            break
+        acc += weight
+        head_end = index + 1
+    tail_start, acc = len(weights), 0
+    for index in range(len(weights) - 1, head_end - 1, -1):
+        if acc + weights[index] > half:
+            break
+        acc += weights[index]
+        tail_start = index
+    return head_end, tail_start
+
+
+def _bundles_tool_results(message: Message) -> bool:
+    return isinstance(message.content, list) and any(isinstance(block, ToolResult) for block in message.content)
+
+
+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, but reasoning
+    # models (deepseek-v4-flash Responses, etc.) can consume the entire budget
+    # on chain-of-thought and leave no room for text output, producing an empty
+    # summary. A generous ceiling gives reasoning headroom while still staying
+    # well under the model's full completion budget.
+    SUMMARY_MAX_TOKENS = 8192
+    # Attempts at widening the omission gap per budget rung.
+    MAX_FIT_ATTEMPTS = 6
+
+    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, input_budget_tokens: int) -> bool:
+        """True when input exceeds the threshold fraction of the input budget."""
+        return input_tokens > input_budget_tokens * self.threshold
+
+    async def summarize(
+        self,
+        conversation: Conversation,
+        *,
+        llm,
+        model: str,
+        temperature: float,
+        thinking,
+        on_info: Optional[LogCallback] = None,
+        on_error: Optional[LogCallback] = None,
+        system_prompt_text: Optional[str] = None,
+        keep_recent: Optional[int] = None,
+        max_input_tokens: Optional[int] = 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.
+        The aged-out span is presented to the summarizer as a role-tagged
+        plain-text transcript (tool arguments as JSON, tool results raw).
+        Returns a CompactionResult describing what happened — never a silent no-op.
+
+        ``keep_recent`` overrides KEEP_RECENT_MESSAGES (the verbatim tail). A
+        literal ``0`` is the aggressive fallback: everything before the safe
+        boundary — potentially including recent user content — becomes eligible
+        for lossy summarization. The raw history is never modified, and the
+        safe-boundary snap still keeps tool_use/tool_result pairs together.
+
+        ``max_input_tokens`` bounds the summarization request itself: while the
+        rendered request exceeds it, whole messages are dropped from the middle
+        of the span (never splitting a tool exchange) and an omission notice is
+        left in the gap. Dispatch walks a descending budget ladder (100%, 90%,
+        80%, ... of the bound): if the enforcing side rejects a request the
+        counter accepted, the next rung re-widens the gap and retries until a
+        request is accepted. An unbounded request would be rejected before
+        dispatch and read as ``llm_error``, permanently disabling
+        auto-compaction.
+        """
+        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})."
+                ),
+            )
+
+        if keep_recent is None:
+            keep_recent = self.KEEP_RECENT_MESSAGES
+        split = conversation.compaction_split_point(keep_recent=keep_recent, 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:
+            # A summary needs no pixels, and base64 must stay out of the transcript.
+            prefix = replace_image_blocks_with_placeholders(list(history[prior_through:split]), model)
+            previous_summary = conversation.summary.get_text_content() if conversation.summary is not None else None
+
+            def build_request(head_end: int, tail_start: int) -> MessageHistory:
+                omitted = tail_start - head_end
+                if omitted:
+                    parts = [
+                        _render_transcript(prefix[:head_end]),
+                        _omission_notice(omitted),
+                        _render_transcript(prefix[tail_start:]),
+                    ]
+                    transcript = "\n\n".join(part for part in parts if part)
+                else:
+                    transcript = _render_transcript(prefix)
+                prompt = build_compression_summary_user_prompt(transcript, previous_summary=previous_summary)
+                return MessageHistory([Message(role="user", content=[TextBlock(text=prompt)])])
+
+            head_end, tail_start = len(prefix), len(prefix)
+            messages = build_request(head_end, tail_start)
+            system_text = system_prompt_text or COMPRESSION_SUMMARY_SYSTEM_PROMPT
+            system_message = Message(role="system", content=[TextBlock(text=system_text)])
+            weights = [_approx_message_chars(message) for message in prefix]
+
+            async def widen_gap_until_fits(budget: int) -> None:
+                nonlocal head_end, tail_start, messages
+                for _ in range(self.MAX_FIT_ATTEMPTS):
+                    counted = await llm.count_tokens(
+                        messages=messages, system=system_message, model=model, thinking=thinking
+                    )
+                    if counted.input_tokens <= budget:
+                        return
+                    kept_chars = sum(weights[:head_end]) + sum(weights[tail_start:])
+                    target_chars = kept_chars * budget / counted.input_tokens * 0.9
+                    new_head, new_tail = _middle_gap(weights, target_chars)
+                    # Keep tool exchanges whole on both edges of the gap.
+                    new_head = conversation.snap_split_point(prior_through + new_head) - prior_through
+                    while new_head < new_tail < len(prefix) and _bundles_tool_results(prefix[new_tail]):
+                        new_tail += 1
+                    if (new_head, new_tail) == (head_end, tail_start):
+                        # Stalled (fixed prompt parts dominate): let the budget
+                        # check or provider give the definitive answer.
+                        return
+                    head_end, tail_start = new_head, new_tail
+                    messages = build_request(head_end, tail_start)
+
+            # 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.
+            #
+            # The helper origin spans the whole request: providers may sample and
+            # emit their trace record at context entry or final-message time, not
+            # at stream().
+            response = None
+            last_error: Optional[LLMContextWindowExceededError] = None
+            dispatched_gap: Optional[tuple[int, int]] = None
+            rungs = range(10, 0, -1) if max_input_tokens is not None else range(1)
+            for tenths in rungs:
+                if max_input_tokens is not None:
+                    await widen_gap_until_fits(max_input_tokens * tenths // 10)
+                    if dispatched_gap == (head_end, tail_start):
+                        # This rung could not shrink the request any further;
+                        # re-sending it would only be rejected again.
+                        continue
+                try:
+                    with llm_call_origin(helper_origin("compression")):
+                        stream_cm = await llm.stream(
+                            messages=messages,
+                            system=system_message,
+                            temperature=temperature,
+                            model=model,
+                            max_completion_tokens=self.SUMMARY_MAX_TOKENS,
+                            thinking=thinking,
+                        )
+                        async with stream_cm as stream:
+                            async for _event in stream:
+                                pass
+                        response = await stream.get_final_message()
+                    break
+                except LLMContextWindowExceededError as exc:
+                    if max_input_tokens is None:
+                        raise
+                    dispatched_gap = (head_end, tail_start)
+                    last_error = exc
+            if response is None:
+                # Every rung was rejected or would have re-sent an identical request.
+                assert last_error is not None
+                raise last_error
+
+            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)

{kolega_code-0.28.2 → kolega_code-0.28.4}/kolega_code/agent/conversation.py

@@ -1085,6 +1085,11 @@ class Conversation:
             return None
         return candidate
 
+    def snap_split_point(self, idx: int) -> int:
+        """Clamp ``idx`` to history bounds and snap it backward so a tool_use/
+        tool_result group is never split across a compaction boundary."""
+        return self._snap_to_safe_boundary(max(0, min(idx, len(self._history))))
+
     def _snap_to_safe_boundary(self, idx: int) -> int:
         """Move ``idx`` backward past any assistant tool_use so a tool_use/tool_result
         group is never split across the compaction boundary."""

{kolega_code-0.28.2 → kolega_code-0.28.4}/kolega_code/agent/prompt_templates/auxiliary/compression/summary.user.md.j2

@@ -14,4 +14,4 @@ Summarize the following coding session so far:
 {{ history }}
 </conversation_history>
 
-Produce the continuity briefing exactly as specified in your instructions. Summary text only — do not call tools.
+Each transcript entry is tagged with its role; tool calls show their JSON arguments and tool results follow raw. A bracketed line marks messages omitted for length. Produce the continuity briefing exactly as specified in your instructions. Summary text only — do not call tools.

{kolega_code-0.28.2 → kolega_code-0.28.4}/kolega_code/agent/tools.py

@@ -341,9 +341,7 @@ class ToolCollection(LogMixin):
                 model_config = config.long_context_config
             resolved_edit_protocol = config.resolve_edit_protocol(model_config)
             self.edit_protocol = (
-                resolved_edit_protocol
-                if isinstance(resolved_edit_protocol, EditProtocol)
-                else EditProtocol.SEARCH_REPLACE
+                resolved_edit_protocol if isinstance(resolved_edit_protocol, EditProtocol) else EditProtocol.CLAUDE_CODE
             )
         self.langfuse_client = langfuse_client
         self.tool_extensions = tool_extensions or []

{kolega_code-0.28.2 → kolega_code-0.28.4}/kolega_code/config.py

@@ -313,7 +313,7 @@ class AgentConfig(BaseModel):
         preferred = preferred_edit_protocol(effective_model.provider, effective_model.model)
         if preferred is not None:
             return EditProtocol(preferred), "model_catalog"
-        return EditProtocol.SEARCH_REPLACE, "default"
+        return EditProtocol.CLAUDE_CODE, "default"
 
     def get_api_key(self, provider: ModelProvider) -> Optional[str]:
         """Get the API key for a specific provider."""

{kolega_code-0.28.2 → kolega_code-0.28.4}/kolega_code/llm/specs/catalog/thinking_machines.py

@@ -15,6 +15,7 @@ THINKING_MACHINES_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": True,
+        "preferred_edit_protocol": "claude_code",
         "thinking_effort": ThinkingEffortSpec(
             options=("none", "low", "medium", "high", "xhigh", "max"),
             default="high",
@@ -27,6 +28,7 @@ THINKING_MACHINES_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": True,
+        "preferred_edit_protocol": "claude_code",
         "thinking_effort": ThinkingEffortSpec(
             options=("none", "low", "medium", "high", "xhigh", "max"),
             default="high",

{kolega_code-0.28.2 → kolega_code-0.28.4}/kolega_code/llm/specs/catalog/tinker.py

@@ -16,6 +16,7 @@ TINKER_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": True,
+        "preferred_edit_protocol": "claude_code",
         "thinking_effort": ThinkingEffortSpec(
             options=("none", "low", "medium", "high", "xhigh", "max"),
             default="high",
@@ -28,6 +29,7 @@ TINKER_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": True,
+        "preferred_edit_protocol": "claude_code",
         "thinking_effort": ThinkingEffortSpec(
             options=("none", "low", "medium", "high", "xhigh", "max"),
             default="high",
@@ -40,6 +42,7 @@ TINKER_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": True,
+        "preferred_edit_protocol": "claude_code",
         "thinking_effort": ThinkingEffortSpec(
             options=("none", "low", "medium", "high", "xhigh", "max"),
             default="high",
@@ -52,6 +55,7 @@ TINKER_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": True,
+        "preferred_edit_protocol": "claude_code",
         "thinking_effort": ThinkingEffortSpec(
             options=("none", "low", "medium", "high", "xhigh", "max"),
             default="high",
@@ -64,6 +68,7 @@ TINKER_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": False,
+        "preferred_edit_protocol": "claude_code",
     },
     ("tinker", "nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B-BF16:peft:262144"): {
         "context_length": 262144,
@@ -71,6 +76,7 @@ TINKER_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": False,
+        "preferred_edit_protocol": "claude_code",
     },
     ("tinker", "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16"): {
         "context_length": 65536,
@@ -78,6 +84,7 @@ TINKER_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": False,
+        "preferred_edit_protocol": "claude_code",
     },
     ("tinker", "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16:peft:262144"): {
         "context_length": 262144,
@@ -85,6 +92,7 @@ TINKER_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": False,
+        "preferred_edit_protocol": "claude_code",
     },
     ("tinker", "nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16"): {
         "context_length": 65536,
@@ -92,6 +100,7 @@ TINKER_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": False,
+        "preferred_edit_protocol": "claude_code",
     },
     ("tinker", "moonshotai/Kimi-K2.6"): {
         "context_length": 32768,
@@ -99,6 +108,7 @@ TINKER_SPECS = {
         "input_budget": "output_shares_window",
         "default_temperature": 1.0,
         "supports_vision": True,
+        "preferred_edit_protocol": "claude_code",
         "thinking_effort": ThinkingEffortSpec(
             options=("none", "auto"),
             default="auto",
@@ -111,6 +121,7 @@ TINKER_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": True,
+        "preferred_edit_protocol": "claude_code",
         "thinking_effort": ThinkingEffortSpec(
             options=("none", "auto"),
             default="auto",
@@ -123,6 +134,7 @@ TINKER_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": True,
+        "preferred_edit_protocol": "claude_code",
         "thinking_effort": ThinkingEffortSpec(
             options=("none", "auto"),
             default="auto",
@@ -135,6 +147,7 @@ TINKER_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": True,
+        "preferred_edit_protocol": "claude_code",
         "thinking_effort": ThinkingEffortSpec(
             options=("none", "auto"),
             default="auto",
@@ -147,6 +160,7 @@ TINKER_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": True,
+        "preferred_edit_protocol": "claude_code",
         "thinking_effort": ThinkingEffortSpec(
             options=("none", "auto"),
             default="auto",
@@ -159,6 +173,7 @@ TINKER_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": True,
+        "preferred_edit_protocol": "claude_code",
         "thinking_effort": ThinkingEffortSpec(
             options=("none", "auto"),
             default="auto",
@@ -171,6 +186,7 @@ TINKER_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": True,
+        "preferred_edit_protocol": "claude_code",
         "thinking_effort": ThinkingEffortSpec(
             options=("none", "auto"),
             default="auto",
@@ -183,6 +199,7 @@ TINKER_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": True,
+        "preferred_edit_protocol": "claude_code",
         "thinking_effort": ThinkingEffortSpec(
             options=("none", "auto"),
             default="auto",
@@ -195,6 +212,7 @@ TINKER_SPECS = {
         "input_budget": "output_shares_window",
         "default_temperature": 1.0,
         "supports_vision": False,
+        "preferred_edit_protocol": "claude_code",
     },
     ("tinker", "openai/gpt-oss-120b"): {
         "context_length": 32768,
@@ -202,6 +220,7 @@ TINKER_SPECS = {
         "input_budget": "output_shares_window",
         "default_temperature": 1.0,
         "supports_vision": False,
+        "preferred_edit_protocol": "claude_code",
     },
     ("tinker", "openai/gpt-oss-120b:peft:131072"): {
         "context_length": 131072,
@@ -209,6 +228,7 @@ TINKER_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": False,
+        "preferred_edit_protocol": "claude_code",
     },
     ("tinker", "openai/gpt-oss-20b"): {
         "context_length": 32768,
@@ -216,6 +236,7 @@ TINKER_SPECS = {
         "input_budget": "output_shares_window",
         "default_temperature": 1.0,
         "supports_vision": False,
+        "preferred_edit_protocol": "claude_code",
     },
     ("tinker", "deepseek-ai/DeepSeek-V3.1"): {
         "context_length": 32768,
@@ -223,6 +244,7 @@ TINKER_SPECS = {
         "input_budget": "output_shares_window",
         "default_temperature": 1.0,
         "supports_vision": False,
+        "preferred_edit_protocol": "claude_code",
         "thinking_effort": ThinkingEffortSpec(
             options=("none", "auto"),
             default="auto",
@@ -240,5 +262,6 @@ TINKER_WILDCARD_SPECS = {
         "input_budget": "window_minus_output",
         "default_temperature": 1.0,
         "supports_vision": False,
+        "preferred_edit_protocol": "claude_code",
     },
 }

{kolega_code-0.28.2 → kolega_code-0.28.4}/kolega_code/llm/specs/tinker_catalog.py

@@ -51,6 +51,7 @@ _USER_AGENT = (
 # used across the direct-provider catalogs.
 MAX_COMPLETION_TOKENS = 32768
 DEFAULT_TEMPERATURE = 1.0
+PREFERRED_EDIT_PROTOCOL = "claude_code"
 
 # Named-effort spec for the Inkling family (tml-renderers effort floats).
 INKLING_EFFORT_SPEC = ThinkingEffortSpec(
@@ -131,6 +132,7 @@ def catalog_entries(payload: Any) -> list[tuple[str, dict[str, Any]]]:
             "input_budget": "output_shares_window",
             "default_temperature": DEFAULT_TEMPERATURE,
             "supports_vision": "Vision" in model_type,
+            "preferred_edit_protocol": PREFERRED_EDIT_PROTOCOL,
         }
         spec.update(_family_spec(str(identifier)))
         entries.append((str(identifier), spec))
@@ -160,6 +162,7 @@ def spec_to_jsonable(spec: Mapping[str, Any]) -> dict[str, Any]:
 def spec_from_jsonable(payload: Mapping[str, Any]) -> dict[str, Any]:
     """Rebuild a runtime spec from ``spec_to_jsonable`` output."""
     spec = dict(payload)
+    spec.setdefault("preferred_edit_protocol", PREFERRED_EDIT_PROTOCOL)
     thinking = spec.get("thinking_effort")
     if isinstance(thinking, Mapping) and thinking.get("mode") == "tinker_native_effort":
         spec["thinking_effort"] = ThinkingEffortSpec(
@@ -236,5 +239,6 @@ TINKER_WILDCARD_SPECS = {
         "input_budget": "output_shares_window",
         "default_temperature": DEFAULT_TEMPERATURE,
         "supports_vision": False,
+        "preferred_edit_protocol": PREFERRED_EDIT_PROTOCOL,
     },
 }

{kolega_code-0.28.2 → kolega_code-0.28.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "kolega-code"
-version = "0.28.2"
+version = "0.28.4"
 description = "Multi-agent coding in the terminal"
 readme = "README.md"
 license = {file = "LICENSE"}