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

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

@@ -6,6 +6,21 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 0.28.2 - 2026-08-12
+
+### Fixed
+
+- Native Tinker sessions now keep repeated provider tool-call IDs paired with
+  their distinct executions after persistence, avoiding false interrupted-tool
+  placeholders and preserving every result in subsequent model history.
+
+## 0.28.1 - 2026-08-12
+
+### Fixed
+
+- Restored native Tinker tool dispatch so generated tool calls execute through
+  the agent loop instead of being returned as plain assistant output.
+
 ## 0.28.0 - 2026-08-11
 
 ### Added

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.28.0
+Version: 0.28.2
 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/
@@ -278,7 +278,8 @@ Requires-Dist: pytest==9.0.3; extra == 'dev'
 Requires-Dist: ruff==0.15.12; extra == 'dev'
 Requires-Dist: twine==6.2.0; extra == 'dev'
 Provides-Extra: tinker
-Requires-Dist: tinker-cookbook==0.5.3; extra == 'tinker'
+Requires-Dist: tinker-cookbook==0.5.4; extra == 'tinker'
+Requires-Dist: tinker==0.25.0; extra == 'tinker'
 Requires-Dist: tml-renderers==0.1.0; extra == 'tinker'
 Description-Content-Type: text/markdown
 

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

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

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

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

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

@@ -9,8 +9,9 @@ holding their own reference.
 
 import logging
 import re
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union, cast
 
+from kolega_code.agent.tool_backend.hashline_v2 import strip_hashline_read_output
 from kolega_code.llm.models import (
     ContentBlock,
     ImageBlock,
@@ -23,10 +24,10 @@ from kolega_code.llm.models import (
     ToolCall,
     ToolResult,
     WebSearchCallBlock,
+    same_tool_execution,
 )
 from kolega_code.llm.specs import prior_reasoning_is_replayable
 from kolega_code.utils import images as image_utils
-from kolega_code.agent.tool_backend.hashline_v2 import strip_hashline_read_output
 
 logger = logging.getLogger(__name__)
 
@@ -630,25 +631,48 @@ class Conversation:
             content_blocks = [content]
 
         if isinstance(content_blocks, list):
-            new_tool_results = {}
+            new_tool_results: List[ToolResult] = []
             other_blocks = []
 
             for block in content_blocks:
                 if isinstance(block, ToolResult):
-                    new_tool_results[block.tool_use_id] = block
+                    duplicate_index = next(
+                        (
+                            index
+                            for index, existing in enumerate(new_tool_results)
+                            if same_tool_execution(existing, block)
+                        ),
+                        None,
+                    )
+                    if duplicate_index is None:
+                        new_tool_results.append(block)
+                    else:
+                        new_tool_results[duplicate_index] = block
                 else:
                     other_blocks.append(block)
 
             if new_tool_results:
-                # Find and update any existing tool results with the same IDs
+                # Find and update any existing result for the same execution.
                 for i, msg in enumerate(self.history):
                     if msg.role == "user" and isinstance(msg.content, list):
                         updated_content = []
                         replaced_any = False
 
                         for block in msg.content:
-                            if isinstance(block, ToolResult) and block.tool_use_id in new_tool_results:
-                                new_result = new_tool_results[block.tool_use_id]
+                            matching_index = (
+                                next(
+                                    (
+                                        index
+                                        for index, candidate in enumerate(new_tool_results)
+                                        if same_tool_execution(block, candidate)
+                                    ),
+                                    None,
+                                )
+                                if isinstance(block, ToolResult)
+                                else None
+                            )
+                            if isinstance(block, ToolResult) and matching_index is not None:
+                                new_result = new_tool_results[matching_index]
                                 # Replace if: old is dummy error OR new is success and old is error
                                 should_replace = (block.is_error and "Operation was interrupted" in block.content) or (
                                     not new_result.is_error and block.is_error
@@ -658,14 +682,13 @@ class Conversation:
                                     updated_content.append(new_result)
                                     replaced_any = True
                                     logger.debug("Replaced tool result for tool_use_id: %s", block.tool_use_id)
-                                    del new_tool_results[block.tool_use_id]
+                                    del new_tool_results[matching_index]
                                 else:
                                     updated_content.append(block)
-                                    if block.tool_use_id in new_tool_results:
-                                        logger.debug(
-                                            "Skipping duplicate tool result for tool_use_id: %s", block.tool_use_id
-                                        )
-                                        del new_tool_results[block.tool_use_id]
+                                    logger.debug(
+                                        "Skipping duplicate tool result for tool_use_id: %s", block.tool_use_id
+                                    )
+                                    del new_tool_results[matching_index]
                             else:
                                 updated_content.append(block)
 
@@ -679,7 +702,7 @@ class Conversation:
                             )
 
                 # Add any remaining new tool results along with other blocks
-                content_blocks = list(new_tool_results.values()) + other_blocks
+                content_blocks = cast(List[ContentBlock], list(new_tool_results)) + other_blocks
 
                 # If all blocks were handled (replaced or skipped), don't add empty message
                 if not content_blocks:
@@ -826,19 +849,32 @@ class Conversation:
                     fixed_messages.append(current_message)
                     processed_indices.add(i)
 
-                    # Collect all tool results from the entire remaining conversation
-                    tool_call_ids = {call.id for call in tool_calls}
-                    all_tool_results = {}
+                    # Collect all tool results from the entire remaining conversation.
+                    # Provider IDs may repeat across responses, so correlate modern
+                    # records by their durable execution IDs and fall back to provider
+                    # IDs only when either side is legacy.
+                    all_tool_results: Dict[int, ToolResult] = {}
                     other_content_blocks = []  # Non-tool-result content from the next user message
 
+                    def unmatched_call_index(block: ToolResult) -> Optional[int]:
+                        return next(
+                            (
+                                index
+                                for index, call in enumerate(tool_calls)
+                                if index not in all_tool_results and same_tool_execution(call, block)
+                            ),
+                            None,
+                        )
+
                     # First, check the immediately following message (expected position)
                     next_user_message = None
                     if i + 1 < len(messages) and messages[i + 1].role == "user":
                         next_user_message = messages[i + 1]
                         if isinstance(next_user_message.content, list):
                             for block in next_user_message.content:
-                                if isinstance(block, ToolResult) and block.tool_use_id in tool_call_ids:
-                                    all_tool_results[block.tool_use_id] = block
+                                call_index = unmatched_call_index(block) if isinstance(block, ToolResult) else None
+                                if isinstance(block, ToolResult) and call_index is not None:
+                                    all_tool_results[call_index] = block
                                 else:
                                     other_content_blocks.append(block)
 
@@ -848,8 +884,7 @@ class Conversation:
                             processed_indices.add(i + 1)
 
                     # Search the entire remaining conversation for any missing tool results
-                    missing_ids = tool_call_ids - set(all_tool_results.keys())
-                    if missing_ids:
+                    if len(all_tool_results) < len(tool_calls):
                         for j in range(i + 1, len(messages)):
                             if j in processed_indices:
                                 continue
@@ -860,15 +895,15 @@ class Conversation:
                                 found_any = False
 
                                 for block in msg.content:
-                                    if isinstance(block, ToolResult) and block.tool_use_id in missing_ids:
+                                    call_index = unmatched_call_index(block) if isinstance(block, ToolResult) else None
+                                    if isinstance(block, ToolResult) and call_index is not None:
                                         logger.warning(
                                             "Found tool result %s at position %s instead of expected position %s",
                                             block.tool_use_id,
                                             j,
                                             i + 1,
                                         )
-                                        all_tool_results[block.tool_use_id] = block
-                                        missing_ids.remove(block.tool_use_id)
+                                        all_tool_results[call_index] = block
                                         found_any = True
                                     else:
                                         remaining_content.append(block)
@@ -890,9 +925,9 @@ class Conversation:
 
                     # Create the complete tool results list in the correct order
                     complete_tool_results = []
-                    for tool_call in tool_calls:
-                        if tool_call.id in all_tool_results:
-                            complete_tool_results.append(all_tool_results[tool_call.id])
+                    for call_index, tool_call in enumerate(tool_calls):
+                        if call_index in all_tool_results:
+                            complete_tool_results.append(all_tool_results[call_index])
                         else:
                             logger.warning("Adding placeholder result for missing tool call: %s", tool_call.id)
                             complete_tool_results.append(
@@ -901,6 +936,7 @@ class Conversation:
                                     content="Operation was interrupted. Please retry if needed.",
                                     name=tool_call.name,
                                     is_error=True,
+                                    execution_id=tool_call.execution_id,
                                     input_kind=tool_call.input_kind,
                                 )
                             )

{kolega_code-0.28.0 → kolega_code-0.28.2}/kolega_code/llm/models.py

@@ -1119,6 +1119,34 @@ class ToolResult(ContentBlock):
         return f"{status} from tool call (ID: {self.tool_use_id}):\n\n```\n{markdown_content}\n```"
 
 
+ToolExecutionBlock = Union[ToolCall, ToolResult]
+
+
+def provider_tool_call_id(block: ToolExecutionBlock) -> str:
+    """Return the provider-owned identifier used on the model wire."""
+    return block.id if isinstance(block, ToolCall) else block.tool_use_id
+
+
+def same_tool_execution(left: ToolExecutionBlock, right: ToolExecutionBlock) -> bool:
+    """Whether two call/result blocks describe one app-level execution.
+
+    Modern records carry the globally unique app ``execution_id`` on both
+    sides. Legacy records may lack it on the result (while restoring the call
+    generates one), so provider-ID matching remains the compatibility fallback
+    whenever either side has no durable execution ID.
+    """
+    if left.execution_id is not None and right.execution_id is not None:
+        return left.execution_id == right.execution_id
+    return provider_tool_call_id(left) == provider_tool_call_id(right)
+
+
+def tool_result_identity(result: ToolResult) -> tuple[str, str]:
+    """Stable de-duplication key for one result, with legacy fallback."""
+    if result.execution_id is not None:
+        return ("execution", result.execution_id)
+    return ("provider", result.tool_use_id)
+
+
 def _tool_result_blocks(tool_result: "ToolResult") -> List[ContentBlock]:
     if isinstance(tool_result.content, list):
         return tool_result.content
@@ -1905,31 +1933,46 @@ class MessageHistory(list):
 
     def to_openai(self, provider: Optional[str] = None, model: Optional[str] = None) -> list:
         processed_messages = []
-        consumed_tool_result_ids = set()
+        # A provider tool-call ID need not be globally unique (native Tinker
+        # emits call_0 in each response). Track their execution identities
+        # instead of treating wire IDs as conversation-global IDs.
+        consumed_tool_results: set[tuple[str, str]] = set()
         messages = list(self)
 
         def payload_has_content(payload: Dict[str, Any]) -> bool:
             content = payload.get("content")
             return (isinstance(content, str) and bool(content)) or (isinstance(content, list) and bool(content))
 
-        def collect_lookahead_tool_results(start_index: int, needed_ids: set) -> List[ToolResult]:
+        def unmatched_tool_calls(calls: List[ToolCall], results: List[ToolResult]) -> List[ToolCall]:
+            unmatched = list(calls)
+            for result in results:
+                matching_index = next(
+                    (index for index, call in enumerate(unmatched) if same_tool_execution(call, result)),
+                    None,
+                )
+                if matching_index is not None:
+                    unmatched.pop(matching_index)
+            return unmatched
+
+        def collect_lookahead_tool_results(start_index: int, needed_calls: List[ToolCall]) -> List[ToolResult]:
             found: List[ToolResult] = []
-            if not needed_ids:
+            unmatched = list(needed_calls)
+            if not unmatched:
                 return found
-            found_ids = set()
             for look_ahead in messages[start_index + 1 :]:
                 if not isinstance(look_ahead.content, list):
                     continue
                 for item in look_ahead.content:
-                    if (
-                        isinstance(item, ToolResult)
-                        and item.tool_use_id in needed_ids
-                        and item.tool_use_id not in consumed_tool_result_ids
-                        and item.tool_use_id not in found_ids
-                    ):
+                    if not isinstance(item, ToolResult) or tool_result_identity(item) in consumed_tool_results:
+                        continue
+                    matching_index = next(
+                        (index for index, call in enumerate(unmatched) if same_tool_execution(call, item)),
+                        None,
+                    )
+                    if matching_index is not None:
                         found.append(item)
-                        found_ids.add(item.tool_use_id)
-                if needed_ids.issubset(found_ids):
+                        unmatched.pop(matching_index)
+                if not unmatched:
                     break
             return found
 
@@ -1944,7 +1987,7 @@ class MessageHistory(list):
             tool_result_blocks = [
                 item
                 for item in message.content
-                if isinstance(item, ToolResult) and item.tool_use_id not in consumed_tool_result_ids
+                if isinstance(item, ToolResult) and tool_result_identity(item) not in consumed_tool_results
             ]
 
             if tool_result_blocks:
@@ -1964,22 +2007,21 @@ class MessageHistory(list):
 
                 # If this same message included tool_calls, pull any missing tool
                 # results forward so all role=tool messages stay contiguous.
-                tool_call_ids = [item.id for item in message.content if isinstance(item, ToolCall)]
-                found_ids = {tr.tool_use_id for tr in tool_result_blocks}
-                lookahead_results = collect_lookahead_tool_results(index, set(tool_call_ids) - found_ids)
+                tool_calls = [item for item in message.content if isinstance(item, ToolCall)]
+                missing_calls = unmatched_tool_calls(tool_calls, tool_result_blocks)
+                lookahead_results = collect_lookahead_tool_results(index, missing_calls)
                 batch_tool_results = tool_result_blocks + lookahead_results
 
                 processed_messages.extend(_openai_tool_result_message(tr) for tr in batch_tool_results)
                 for tr in batch_tool_results:
-                    consumed_tool_result_ids.add(tr.tool_use_id)
+                    consumed_tool_results.add(tool_result_identity(tr))
 
                 # If still missing, emit placeholder tool messages to satisfy API requirements.
                 # These must come before any image follow-up user messages so all required
                 # role=tool responses stay contiguous after the assistant tool calls.
-                added_ids = {tr.tool_use_id for tr in lookahead_results}
-                remaining = set(tool_call_ids) - (found_ids | added_ids)
-                for missing_id in remaining:
-                    processed_messages.append({"role": "tool", "content": "", "tool_call_id": missing_id})
+                remaining_calls = unmatched_tool_calls(missing_calls, lookahead_results)
+                for missing_call in remaining_calls:
+                    processed_messages.append({"role": "tool", "content": "", "tool_call_id": missing_call.id})
                 for tr in batch_tool_results:
                     followup = _openai_tool_result_image_followup(tr)
                     if followup is not None:
@@ -1997,20 +2039,19 @@ class MessageHistory(list):
 
                 tool_calls = temp_payload.get("tool_calls") or []
                 if tool_calls:
-                    tool_call_ids = [tc.get("id") for tc in tool_calls if tc.get("id")]
-                    lookahead_results = collect_lookahead_tool_results(index, set(tool_call_ids))
+                    content_tool_calls = [item for item in message.content if isinstance(item, ToolCall)]
+                    lookahead_results = collect_lookahead_tool_results(index, content_tool_calls)
 
                     processed_messages.extend(_openai_tool_result_message(tr) for tr in lookahead_results)
                     for tr in lookahead_results:
-                        consumed_tool_result_ids.add(tr.tool_use_id)
+                        consumed_tool_results.add(tool_result_identity(tr))
 
                     # If any are still missing, emit placeholder tool messages to satisfy API ordering.
                     # Placeholders also come before image follow-up user messages to keep all role=tool
                     # responses contiguous after the assistant tool-call message.
-                    added_ids = {tr.tool_use_id for tr in lookahead_results}
-                    remaining = [tc_id for tc_id in tool_call_ids if tc_id not in added_ids]
-                    for missing_id in remaining:
-                        processed_messages.append({"role": "tool", "content": "", "tool_call_id": missing_id})
+                    remaining_calls = unmatched_tool_calls(content_tool_calls, lookahead_results)
+                    for missing_call in remaining_calls:
+                        processed_messages.append({"role": "tool", "content": "", "tool_call_id": missing_call.id})
                     for tr in lookahead_results:
                         followup = _openai_tool_result_image_followup(tr)
                         if followup is not None:

{kolega_code-0.28.0 → kolega_code-0.28.2}/kolega_code/llm/providers/tinker.py

@@ -166,6 +166,7 @@ def _parsed_to_message(parsed: Any, stop_reason: str) -> Message:
     are fabricated when the renderer does not emit one.
     """
     blocks: List[Any] = []
+    message_tool_calls: List[ToolCall] = []
 
     reasoning = (
         parsed.get("reasoning_content") if isinstance(parsed, dict) else getattr(parsed, "reasoning_content", None)
@@ -211,11 +212,18 @@ def _parsed_to_message(parsed: Any, stop_reason: str) -> Message:
                 tool_input = {"raw": arguments}
             raw_id = call.get("id") if isinstance(call, dict) else getattr(call, "id", None)
             call_id = str(raw_id) if raw_id else f"call_{index}"
-            blocks.append(ToolCall(id=call_id, name=name, input=tool_input))
+            tool_call = ToolCall(id=call_id, name=name, input=tool_input)
+            message_tool_calls.append(tool_call)
+            blocks.append(tool_call)
 
     if not blocks:
         blocks.append(TextBlock(text=""))
-    return Message(role="assistant", content=blocks, stop_reason=stop_reason)
+    return Message(
+        role="assistant",
+        content=blocks,
+        stop_reason="tool_use" if message_tool_calls else stop_reason,
+        tool_calls=message_tool_calls,
+    )
 
 
 def _kolega_stop_reason(sdk_reason: str, termination: Any) -> str:
@@ -573,7 +581,12 @@ def _message_to_chunks(message: Message) -> List[MessageChunk]:
             chunks.append(
                 MessageChunk(
                     type="tool_use_start",
-                    tool_call_delta={"id": block.id, "name": block.name, "input": ""},
+                    tool_call_delta={
+                        "id": block.id,
+                        "name": block.name,
+                        "input": "",
+                        "execution_id": block.execution_id,
+                    },
                 )
             )
             chunks.append(

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "kolega-code"
-version = "0.28.0"
+version = "0.28.2"
 description = "Multi-agent coding in the terminal"
 readme = "README.md"
 license = {file = "LICENSE"}
@@ -107,7 +107,8 @@ cli = []
 # tml-renderers >=2.10) and transformers; the base install stays torch-free.
 # tml-renderers ships abi3 wheels for Linux x86_64/aarch64 and macOS arm64 only.
 tinker = [
-    "tinker-cookbook==0.5.3",
+    "tinker==0.25.0",
+    "tinker-cookbook==0.5.4",
     "tml-renderers==0.1.0",
 ]
 dev = [
@@ -166,7 +167,16 @@ exclude-newer = "1 week"
 # h2 4.4.1 (released 2026-08-03) is the only release fixing GHSA-6hr6-w5qg-qmwg
 # (CVE-2026-71554, duplicate Host header request smuggling) and sits inside the
 # same quarantine; admit it the same way.
-exclude-newer-package = { cryptography = "2026-08-01T00:00:00Z", h2 = "2026-08-04T00:00:00Z" }
+# tinker 0.25.0 (released 2026-08-08) is required by the live service, which
+# warns that 0.24.0 is outdated; admit that SDK without widening the global window.
+# tinker-cookbook 0.5.4 (released 2026-08-11) is the matching current cookbook;
+# admit it through the same targeted exception.
+
+[tool.uv.exclude-newer-package]
+cryptography = "2026-08-01T00:00:00Z"
+h2 = "2026-08-04T00:00:00Z"
+tinker = "2026-08-09T00:00:00Z"
+tinker-cookbook = "2026-08-12T00:00:00Z"
 
 [tool.pyright]
 include = ["kolega_code", "benchmarks", "tests"]