kolega-code 0.26.6__tar.gz → 0.26.8__tar.gz

{kolega_code-0.26.6 → kolega_code-0.26.8}/CHANGELOG.md

@@ -6,6 +6,83 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 0.26.8 - 2026-08-03
+
+### Added
+
+- Completed model messages now carry normalized token usage across supported
+  providers. Session usage is persisted across resume, exported with provider
+  and model breakdowns, and shown in a dedicated Usage card on the Status tab.
+- `kolega-code ask --json` now emits complete, replay-safe messages instead of
+  streaming prose chunks, including normalized usage and an explicit final
+  summary.
+- Detached background terminal sessions now keep stdin open, so callers can
+  send multiple inputs to long-running processes with `write_stdin`.
+
+### Changed
+
+- Build and ask agents now share stronger act-first and independent-verification
+  guidance. Silent reasoning-only turns are retried with escalating prompts,
+  and visible responses cut off at the output limit are asked to continue.
+- Tool dispatch accepts common parameter aliases for `exec_command`, `eval`,
+  and `find_files_by_pattern`, while canonical arguments still take precedence.
+- Turn status now appears immediately while checkpoints are prepared, and
+  session-diff baseline/checkpoint work is asynchronous and caches unchanged
+  files for faster turns.
+- Switching between Plan and Build with existing history now gives the model a
+  hidden toolset-change notice so it does not attempt tools from the old mode.
+- Web connection failures now distinguish unreachable hosts, TLS failures,
+  rate limits, and retryable errors, with guidance that reflects whether
+  outbound access is available.
+
+### Fixed
+
+- Installing on an Intel Mac no longer fails with a `cryptography` source-build
+  error (`Failed to build cryptography==50.0.0` / missing OpenSSL). cryptography
+  49+ stopped publishing Intel-mac wheels, so the installer tried to compile it
+  with Rust and OpenSSL; Intel Macs now install the last release that ships a
+  prebuilt universal2 wheel. Other platforms are unaffected.
+- DeepSeek requests now always carry an explicit output-token cap (64000, on
+  every provider that serves DeepSeek models: first-party, Fireworks, Ollama
+  Cloud, OpenRouter). DeepSeek's real per-response ceiling is ~64k — far below
+  its published 384000 — and a server-enforced cutoff is reported as a clean
+  finish, so long reasoning runs were being truncated silently mid-word. An
+  explicit client cap is enforced and reported honestly, so truncation now
+  surfaces as a real `max_tokens` stop the agent loop can react to.
+- The Responses API stream wrapper now captures the terminal
+  `response.incomplete` event, so a response truncated at `max_output_tokens`
+  reports stop reason `max_tokens` (and keeps its usage/billing metadata)
+  instead of looking like a clean `end_turn` with no usage.
+- A reply cut off at the output-token limit mid-message is no longer delivered
+  as-is: the agent asks the model to continue (up to 3 escalating continuation
+  prompts, mirroring the silent-turn guard), and only finalizes with the
+  partial output if the reply is still truncated after that.
+- The non-streaming chat `generate()` path now maps `finish_reason` (it lives
+  on the choice, not the message), so its responses carry a real stop reason
+  instead of `None`.
+- Quitting while a question or approval is pending no longer raises a Textual
+  teardown traceback.
+- JavaScript eval kernels no longer wait for orphaned cell timers during
+  shutdown.
+
+### Removed
+
+- The `KOLEGA_CODE_OPENROUTER_MAX_TOKENS` environment variable. OpenRouter
+  requests still send no `max_tokens` by default (it acts as a routing filter
+  on the gateway), except DeepSeek models, which now always send the honest
+  clamped cap.
+
+## 0.26.7 - 2026-08-03
+
+### Fixed
+
+- Local token counting no longer crashes on content that contains a tokenizer
+  special-token literal (for example `<|endoftext|>` or `<|im_start|>`, common in
+  ML/tokenizer files and chat-format prompts); those strings are now counted as
+  ordinary text instead of aborting the run.
+- The Private Project Memory screen no longer crashes with an internal
+  "NoMatches" error when it is closed while still loading.
+
 ## 0.26.6 - 2026-08-03
 
 ### Changed

{kolega_code-0.26.6 → kolega_code-0.26.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.26.6
+Version: 0.26.8
 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/
@@ -230,6 +230,7 @@ Classifier: Topic :: Utilities
 Requires-Python: >=3.11
 Requires-Dist: anthropic==0.101.0
 Requires-Dist: beautifulsoup4==4.14.3
+Requires-Dist: cryptography==48.0.1; sys_platform == 'darwin' and platform_machine == 'x86_64'
 Requires-Dist: ddgs==9.14.4
 Requires-Dist: fastapi==0.139.2
 Requires-Dist: filelock==3.20.3

{kolega_code-0.26.6 → kolega_code-0.26.8}/kolega_code/__init__.py

@@ -151,4 +151,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.26.6"
+__version__ = "0.26.8"

{kolega_code-0.26.6 → kolega_code-0.26.8}/kolega_code/agent/__init__.py

@@ -51,4 +51,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.26.6"
+__version__ = "0.26.8"

{kolega_code-0.26.6 → kolega_code-0.26.8}/kolega_code/agent/baseagent.py

@@ -42,9 +42,15 @@ from kolega_code.llm.exceptions import (
     map_to_llm_error,
 )
 from kolega_code.llm.instrumented_client import get_output_tokens
+from kolega_code.llm.ledger import HISTORY_ORIGIN, LlmCallOrigin, helper_origin, llm_call_origin
 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, supports_vision as model_supports_vision
+from kolega_code.llm.specs import (
+    deepseek_output_token_cap,
+    get_model_specs,
+    is_deepseek_model,
+    supports_vision as model_supports_vision,
+)
 from kolega_code.permissions import (
     PermissionDecision,
     PermissionMode,
@@ -133,6 +139,25 @@ class BaseAgent(LogMixin):
     # Cap on how many times a Stop hook may force the agent to keep working in one
     # turn, so a misbehaving "don't stop until X" hook cannot loop forever.
     MAX_STOP_HOOK_OVERRIDES = 5
+    # Cap on consecutive re-prompts after a "silent turn": the model ended its
+    # turn with no tool call and no visible text (empty or reasoning-only).
+    # Finalizing such a turn reports nothing — in non-interactive modes that
+    # reads as success with empty output — so the loop nudges the model to act
+    # instead, and after the cap terminates the turn and surfaces the failure.
+    # Runtime half of the coder_base.md.j2 invariant ("Thinking is invisible
+    # and changes nothing on its own").
+    MAX_SILENT_TURN_NUDGES = 3
+    # Cap on consecutive continuation prompts after a truncated turn: the model
+    # hit the output-token limit mid-reply (honest "max_tokens" stop, visible
+    # text, no tool call). Unlike a silent turn there IS partial content, so
+    # exhausting the cap finalizes the turn with what was produced instead of
+    # reporting no result.
+    MAX_TRUNCATED_TURN_NUDGES = 3
+    # A DeepSeek response whose output lands within this many tokens of the wire
+    # output cap without an honest "max_tokens" stop was likely truncated
+    # server-side: DeepSeek reports its own cutoff as a clean finish (probed
+    # 2026-08-03; see DEEPSEEK_WIRE_OUTPUT_CAP in llm/specs/accessors.py).
+    DEEPSEEK_OUTPUT_CAP_SLACK = 1024
     long_content_tool_calls = ["write"]
     max_tool_result_chars_in_history = 100_000
     skill_content_pattern = re.compile(r'<skill_content name="[^"]+">')
@@ -163,6 +188,7 @@ class BaseAgent(LogMixin):
         permission_callback: Optional[Any] = None,
         usage_recorder: Optional[Any] = None,
         sub_agent_recorder: Optional[Any] = None,
+        usage_ledger: Optional[Any] = None,
         session_recorder: Optional[Any] = None,
         hook_dispatcher: Optional[HookDispatcher] = None,
         context: Optional[AgentContext] = None,
@@ -241,6 +267,7 @@ class BaseAgent(LogMixin):
                     user_email=user_email,
                     usage_recorder=usage_recorder,
                     sub_agent_recorder=sub_agent_recorder,
+                    usage_ledger=usage_ledger,
                 ),
                 agent_mode=agent_mode,
                 prompt_provider=prompt_provider,
@@ -301,6 +328,7 @@ class BaseAgent(LogMixin):
         self.hook_dispatcher = context.hook_dispatcher or NO_OP_DISPATCHER
         self.usage_recorder = context.telemetry.usage_recorder
         self.sub_agent_recorder = context.telemetry.sub_agent_recorder
+        self.usage_ledger = context.telemetry.usage_ledger
         self.session_recorder = None if sub_agent else session_recorder
         self.custom_agent_catalog = custom_agent_catalog
         self.memory_manager = context.services.memory_manager
@@ -416,6 +444,18 @@ 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)
+        # The clamped cap DeepSeek requests carry on the wire (None for other
+        # models). Used to flag probable silent server-side truncation — see the
+        # at-ceiling warning in process_message_stream.
+        self.deepseek_wire_output_cap = (
+            deepseek_output_token_cap(
+                self.primary_model_config.provider,
+                self.primary_model_config.model,
+                self.model_completion_tokens,
+            )
+            if is_deepseek_model(self.primary_model_config.model)
+            else None
+        )
         # 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
@@ -492,6 +532,15 @@ class BaseAgent(LogMixin):
         """
         self.conversation.append_assistant(message)
 
+    async def _record_context_user_message(self, text: str) -> None:
+        """Journal and append a runtime-injected user message (not typed by the user)."""
+        if self.session_recorder is not None:
+            await asyncio.to_thread(
+                self.session_recorder.record_context_message,
+                Message(role="user", content=[TextBlock(text=text)]),
+            )
+        self.append_user_message([TextBlock(text=text)])
+
     def extend_history(self, messages: List[Message]) -> None:
         """
         Safely extend history with multiple messages, validating the sequence.
@@ -1051,11 +1100,14 @@ class BaseAgent(LogMixin):
         try:
             registry = self.tool_collection.registry()
             if tool_name not in registry:
-                error_message = f"Tool '{tool_name}' is not available in this mode."
-                await self.log_error(error_message, sender=self.agent_name)
+                short_message = f"Tool '{tool_name}' is not available in this mode."
+                # The model gets the available-tool list so it can self-correct;
+                # the transcript row keeps the short form.
+                error_message = f"{short_message} Available tools: {', '.join(sorted(registry.names()))}."
+                await self.log_error(short_message, sender=self.agent_name)
                 await self.send_chat_message(
                     message_type="tool_error",
-                    content=error_message,
+                    content=short_message,
                     is_streaming=False,
                     tool_description=tool_name,
                     tool_call_id=tool_execution_id,
@@ -1379,6 +1431,27 @@ class BaseAgent(LogMixin):
     async def _log_hook_message(self, message: str) -> None:
         await self.log_warning(message, sender=self.agent_name)
 
+    def _main_loop_origin(self) -> LlmCallOrigin:
+        """Attribution for this agent's main-loop LLM calls.
+
+        HISTORY marks exactly the responses the session recorder journals as
+        ``assistant.message`` (the same ``session_recorder is not None``
+        condition guards ``record_assistant``), so the persistence sink skips
+        them and no response is ever journaled twice.
+        """
+        if self.session_recorder is not None:
+            return HISTORY_ORIGIN
+        if self.sub_agent:
+            context = getattr(self, "sub_agent_context", None) or {}
+            return LlmCallOrigin(
+                kind="sub_agent",
+                agent_name=self.agent_name,
+                agent_id=context.get("agent_id"),
+                parent_tool_call_id=context.get("parent_tool_call_id") or getattr(self, "parent_tool_call_id", None),
+                depth=context.get("depth"),
+            )
+        return LlmCallOrigin(kind="primary", agent_name=self.agent_name)
+
     async def _run_hook_prompt(self, prompt_text: str, model_hint: Optional[str]) -> str:
         """Run a `prompt` hook: a single completion on a chosen model slot.
 
@@ -1404,14 +1477,16 @@ class BaseAgent(LogMixin):
             requests_per_minute=model_config.rate_limits.requests_per_minute,
             tokens_per_minute=model_config.rate_limits.tokens_per_minute,
             token_manager=self.config.get_chatgpt_token_manager(),
+            usage_ledger=self.usage_ledger,
         )
-        response = await client.generate(
-            model=model_config.model,
-            max_completion_tokens=512,
-            system=Message(role="system", content=[TextBlock(text=HOOK_DECISION_SYSTEM_PROMPT)]),
-            messages=MessageHistory([Message(role="user", content=[TextBlock(text=prompt_text)])]),
-            temperature=0.0,
-        )
+        with llm_call_origin(helper_origin("hook_prompt")):
+            response = await client.generate(
+                model=model_config.model,
+                max_completion_tokens=512,
+                system=Message(role="system", content=[TextBlock(text=HOOK_DECISION_SYSTEM_PROMPT)]),
+                messages=MessageHistory([Message(role="user", content=[TextBlock(text=prompt_text)])]),
+                temperature=0.0,
+            )
         return response.get_text_content() or ""
 
     async def _run_hook_agent(self, task: str) -> str:
@@ -1712,6 +1787,17 @@ class BaseAgent(LogMixin):
         """Return the agent's final report: the text of the last message in history."""
         return self.history[-1].get_text_content()
 
+    @staticmethod
+    def _is_silent_turn(message: Message) -> bool:
+        """True when an assistant message has no tool calls and no visible text.
+
+        ThinkingBlock carries ``.thinking`` rather than ``.text``, so a
+        reasoning-only message reads as empty here. Evaluate the streamed
+        message, not history: Conversation.append_assistant replaces empty
+        content with a placeholder TextBlock.
+        """
+        return not message.tool_calls and not message.get_text_content().strip()
+
     async def _deliver_queued_user_inputs(self) -> None:
         """Append user inputs drained from the host while the current turn is running."""
         if self.queued_input_provider is None:
@@ -1911,6 +1997,8 @@ class BaseAgent(LogMixin):
 
         stop_reason = None
         stop_overrides = 0
+        silent_turn_nudges = 0
+        truncated_turn_nudges = 0
         iterations = 0
         while stop_reason not in ["end_turn", "max_tokens", "stop_sequence"]:
             iterations += 1
@@ -1994,18 +2082,19 @@ class BaseAgent(LogMixin):
                 # provider is ``async def``, so the call is always a coroutine that we
                 # await into the context manager. Cast to the coroutine form for the type
                 # checker rather than awaiting the union directly.
-                stream_cm = await cast(
-                    Coroutine[Any, Any, AbstractAsyncContextManager[Any]],
-                    self.llm.stream(
-                        system=self.system_prompt,
-                        max_completion_tokens=self.model_completion_tokens,
-                        temperature=self.model_default_temperature,
-                        messages=fixed_history,
-                        model=self.primary_model_config.model,
-                        tools=self.tool_collection.get_tool_list(),
-                        thinking=self.primary_model_config.thinking_effort,
-                    ),
-                )
+                with llm_call_origin(self._main_loop_origin()):
+                    stream_cm = await cast(
+                        Coroutine[Any, Any, AbstractAsyncContextManager[Any]],
+                        self.llm.stream(
+                            system=self.system_prompt,
+                            max_completion_tokens=self.model_completion_tokens,
+                            temperature=self.model_default_temperature,
+                            messages=fixed_history,
+                            model=self.primary_model_config.model,
+                            tools=self.tool_collection.get_tool_list(),
+                            thinking=self.primary_model_config.thinking_effort,
+                        ),
+                    )
                 async with stream_cm as stream:
                     async for event in stream:
                         if event.type == "text":
@@ -2049,10 +2138,11 @@ class BaseAgent(LogMixin):
                 assistant_message = await stream.get_final_message()
                 self._normalize_freeform_tool_calls(assistant_message)
                 assistant_message.usage_metadata["edit_protocol"] = self.edit_protocol.value
-                self.total_tokens_used += get_output_tokens(
+                response_output_tokens = get_output_tokens(
                     assistant_message.usage_metadata,
                     self.primary_model_config.provider.value,
                 )
+                self.total_tokens_used += response_output_tokens
                 if self._accounting_reservation is not None:
                     self._accounting_reservation.report_total(self.total_tokens_used)
                 stop_reason = assistant_message.stop_reason
@@ -2063,6 +2153,23 @@ class BaseAgent(LogMixin):
                     elapsed_s=round(time.monotonic() - _req_start, 2),
                     stop_reason=stop_reason,
                 )
+                # DeepSeek reports a SERVER-side output cutoff as a clean finish;
+                # the clamped wire cap should always fire first as an honest
+                # "max_tokens" stop. A response landing at/near the cap without
+                # one was likely truncated silently — surface it in the
+                # trajectory (log_message event) since the stop reason cannot be
+                # recovered.
+                if (
+                    self.deepseek_wire_output_cap is not None
+                    and stop_reason != "max_tokens"
+                    and response_output_tokens >= self.deepseek_wire_output_cap - self.DEEPSEEK_OUTPUT_CAP_SLACK
+                ):
+                    await self.log_warning(
+                        f"DeepSeek response used {response_output_tokens} output tokens — at or near "
+                        f"the {self.deepseek_wire_output_cap}-token output cap — but reported "
+                        f"stop_reason={stop_reason!r}; the output was likely truncated server-side.",
+                        sender=self.agent_name,
+                    )
 
                 if self.session_recorder is not None:
                     await asyncio.to_thread(self.session_recorder.record_assistant, assistant_message)
@@ -2070,6 +2177,15 @@ class BaseAgent(LogMixin):
                 # A clean stream resets the transient-failure budget, so the cap measures
                 # only consecutive failures, not lifetime failures across the turn.
                 self._consecutive_llm_retries = 0
+                # Likewise, a response with a tool call or visible text resets the
+                # silent-turn budget: the cap measures only consecutive silence.
+                if not self._is_silent_turn(assistant_message):
+                    silent_turn_nudges = 0
+                # And any response that was not cut off at the output limit
+                # resets the truncation budget: the cap measures only
+                # consecutive truncations.
+                if stop_reason != "max_tokens":
+                    truncated_turn_nudges = 0
 
                 if thinking_started or current_thinking:
                     yield {"type": "thinking", "content": current_thinking, "complete": True, "uuid": thinking_uuid}
@@ -2123,18 +2239,87 @@ class BaseAgent(LogMixin):
                     # host UI so the next model request sees them.
                     await self._deliver_queued_user_inputs()
 
+                # Silent-turn guard: the model ended this iteration with no tool
+                # call and no visible text (reasoning-only or empty). Finalizing
+                # would report nothing, so re-prompt with an escalating reminder;
+                # after the cap, terminate the turn and surface the failure. Runs
+                # before the Stop hook: a nudged iteration is not a turn end, and
+                # clearing stop_reason makes the stop-hook block skip itself.
+                if stop_reason in ["end_turn", "max_tokens", "stop_sequence"] and self._is_silent_turn(
+                    assistant_message
+                ):
+                    from .prompts import SILENT_TURN_EXHAUSTED_NOTICE, build_silent_turn_nudge
+
+                    if silent_turn_nudges < self.MAX_SILENT_TURN_NUDGES:
+                        silent_turn_nudges += 1
+                        await self.emitter.llm_status(
+                            "info",
+                            "Model returned no output — asking it to act "
+                            f"({silent_turn_nudges}/{self.MAX_SILENT_TURN_NUDGES})…",
+                        )
+                        await self._record_context_user_message(build_silent_turn_nudge(silent_turn_nudges))
+                        stop_reason = None
+                    else:
+                        await self.log_warning(
+                            f"Model ended {self.MAX_SILENT_TURN_NUDGES + 1} consecutive responses with "
+                            "no tool call and no visible output; terminating the turn.",
+                            sender=self.agent_name,
+                        )
+                        await self.emitter.llm_status(
+                            "warning",
+                            "Model returned no output after repeated reminders — ending the turn with no result.",
+                        )
+                        await self._record_context_user_message(SILENT_TURN_EXHAUSTED_NOTICE)
+                        yield {
+                            "type": "response",
+                            "content": (
+                                "[no output] The model ended its turn with no tool call and no visible "
+                                f"message {self.MAX_SILENT_TURN_NUDGES + 1} times in a row despite "
+                                "reminders. The turn was terminated without a result."
+                            ),
+                            "complete": True,
+                            "uuid": str(uuid.uuid4()),
+                        }
+                        break
+
+                # Truncated-turn guard: an honest "max_tokens" stop with visible
+                # text and no tool call means the reply was cut off mid-message
+                # (the silent-turn guard above owns the no-visible-output case
+                # and cleared stop_reason if it fired). Finalizing would deliver
+                # a partial answer, so ask the model to continue; after the cap,
+                # finalize with the partial output — unlike a silent turn there
+                # IS content worth delivering.
+                if stop_reason == "max_tokens" and not assistant_message.tool_calls:
+                    from .prompts import build_truncated_turn_nudge
+
+                    if truncated_turn_nudges < self.MAX_TRUNCATED_TURN_NUDGES:
+                        truncated_turn_nudges += 1
+                        await self.emitter.llm_status(
+                            "info",
+                            "Response hit the output limit — asking the model to continue "
+                            f"({truncated_turn_nudges}/{self.MAX_TRUNCATED_TURN_NUDGES})…",
+                        )
+                        await self._record_context_user_message(build_truncated_turn_nudge(truncated_turn_nudges))
+                        stop_reason = None
+                    else:
+                        await self.log_warning(
+                            f"Model hit the output-token limit {self.MAX_TRUNCATED_TURN_NUDGES + 1} times "
+                            "in a row; finalizing the turn with the partial output.",
+                            sender=self.agent_name,
+                        )
+                        await self.emitter.llm_status(
+                            "warning",
+                            "Response still truncated after repeated continuation prompts — "
+                            "delivering the partial output.",
+                        )
+
                 # Stop hooks (main agent only). On a natural turn end, a hook may
                 # keep the agent working by blocking the stop and returning a reason.
                 if stop_reason in ["end_turn", "max_tokens", "stop_sequence"] and not self.sub_agent:
                     keep_working = await self._fire_stop_hook(stop_reason)
                     if keep_working is not None and stop_overrides < self.MAX_STOP_HOOK_OVERRIDES:
                         stop_overrides += 1
-                        if self.session_recorder is not None:
-                            await asyncio.to_thread(
-                                self.session_recorder.record_context_message,
-                                Message(role="user", content=[TextBlock(text=keep_working)]),
-                            )
-                        self.append_user_message([TextBlock(text=keep_working)])
+                        await self._record_context_user_message(keep_working)
                         stop_reason = None
 
             except Exception as ex:

{kolega_code-0.26.6 → kolega_code-0.26.8}/kolega_code/agent/browseragent.py

@@ -74,6 +74,7 @@ class BrowserAgent(BaseAgent):
         permission_mode: Optional[Any] = None,
         permission_callback: Optional[Any] = None,
         usage_recorder: Optional[Any] = None,
+        usage_ledger: Optional[Any] = None,
         sub_agent_recorder: Optional[Any] = None,
         hook_dispatcher: Optional[Any] = None,
         max_iterations: Optional[int] = None,
@@ -130,6 +131,7 @@ class BrowserAgent(BaseAgent):
             permission_mode=permission_mode,
             permission_callback=permission_callback,
             usage_recorder=usage_recorder,
+            usage_ledger=usage_ledger,
             sub_agent_recorder=sub_agent_recorder,
             hook_dispatcher=hook_dispatcher,
             max_iterations=max_iterations,

{kolega_code-0.26.6 → kolega_code-0.26.8}/kolega_code/agent/coder.py

@@ -46,6 +46,7 @@ class CoderAgent(BaseAgent, LogMixin):
         permission_mode: Optional[Any] = None,
         permission_callback: Optional[Any] = None,
         usage_recorder: Optional[Any] = None,
+        usage_ledger: Optional[Any] = None,
         sub_agent_recorder: Optional[Any] = None,
         session_recorder: Optional[Any] = None,
         hook_dispatcher: Optional[Any] = None,
@@ -111,6 +112,7 @@ class CoderAgent(BaseAgent, LogMixin):
             permission_mode=permission_mode,
             permission_callback=permission_callback,
             usage_recorder=usage_recorder,
+            usage_ledger=usage_ledger,
             sub_agent_recorder=sub_agent_recorder,
             session_recorder=session_recorder,
             hook_dispatcher=hook_dispatcher,

{kolega_code-0.26.6 → kolega_code-0.26.8}/kolega_code/agent/common.py

@@ -49,3 +49,13 @@ class LogMixin:
         """
         log_event = AgentEvent(event_type="log_message", sender=sender, content={"text": message, "level": "warning"})
         await self.connection_manager.broadcast_event(log_event, self.workspace_id, self.thread_id)
+
+    async def log_debug(self, message: str, sender: str = "agent") -> None:
+        """
+        Log a debug-level message to the logs panel.
+
+        Args:
+            message: The debug message to log
+        """
+        log_event = AgentEvent(event_type="log_message", sender=sender, content={"text": message, "level": "debug"})
+        await self.connection_manager.broadcast_event(log_event, self.workspace_id, self.thread_id)

{kolega_code-0.26.6 → kolega_code-0.26.8}/kolega_code/agent/compression.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass
 from typing import Awaitable, Callable, Optional
 
 from .conversation import Conversation
+from kolega_code.llm.ledger import helper_origin, llm_call_origin
 from kolega_code.llm.models import Message, MessageHistory, TextBlock
 from .prompts import (
     build_compression_summary_user_prompt,
@@ -109,14 +110,16 @@ class HistoryCompressor:
             # 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:
+            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()

{kolega_code-0.26.6 → kolega_code-0.26.8}/kolega_code/agent/context.py

@@ -75,6 +75,10 @@ class Telemetry:
     user_email: Optional[str] = None
     usage_recorder: Optional[Any] = None
     sub_agent_recorder: Optional[Any] = None
+    # Process-wide runtime usage accounting (kolega_code/llm/ledger.py). Unlike
+    # the recorders above it does not require Langfuse: it reaches the plain
+    # LLMClient too.
+    usage_ledger: Optional[Any] = None
 
 
 @dataclass
@@ -122,6 +126,7 @@ class AgentContext:
                 user_email=self.telemetry.user_email,
                 usage_recorder=self.telemetry.usage_recorder,
                 token_manager=self.config.get_chatgpt_token_manager(),
+                usage_ledger=self.telemetry.usage_ledger,
             )
 
         return LLMClient(
@@ -132,4 +137,5 @@ class AgentContext:
             requests_per_minute=model_config.rate_limits.requests_per_minute,
             tokens_per_minute=model_config.rate_limits.tokens_per_minute,
             token_manager=self.config.get_chatgpt_token_manager(),
+            usage_ledger=self.telemetry.usage_ledger,
         )

{kolega_code-0.26.6 → kolega_code-0.26.8}/kolega_code/agent/conversation.py

@@ -163,6 +163,7 @@ def _message_with_content(message: Message, content: List[Any]) -> Message:
         stop_reason=message.stop_reason,
         tool_calls=tool_calls,
         usage_metadata=message.usage_metadata,
+        usage=message.usage,
     )
 
 
@@ -699,6 +700,7 @@ class Conversation:
                 stop_reason=message.stop_reason,
                 tool_calls=message.tool_calls,
                 usage_metadata=message.usage_metadata,
+                usage=message.usage,
             )
 
         self.history.append(message)

{kolega_code-0.26.6 → kolega_code-0.26.8}/kolega_code/agent/custom_agents.py

@@ -384,6 +384,7 @@ class CustomAgent(BaseAgent):
         permission_mode: Optional[Any] = None,
         permission_callback: Optional[Any] = None,
         usage_recorder: Optional[Any] = None,
+        usage_ledger: Optional[Any] = None,
         sub_agent_recorder: Optional[Any] = None,
         hook_dispatcher: Optional[Any] = None,
         max_iterations: Optional[int] = None,
@@ -419,6 +420,7 @@ class CustomAgent(BaseAgent):
             permission_mode=permission_mode,
             permission_callback=permission_callback,
             usage_recorder=usage_recorder,
+            usage_ledger=usage_ledger,
             sub_agent_recorder=sub_agent_recorder,
             hook_dispatcher=hook_dispatcher,
             max_iterations=definition.max_iterations if definition.max_iterations is not None else max_iterations,

{kolega_code-0.26.6 → kolega_code-0.26.8}/kolega_code/agent/eval/kernel.py

@@ -184,8 +184,9 @@ class BaseKernel:
             try:
                 if proc.stdin is not None:
                     proc.stdin.write(encode_frame({"type": "exit"}))
-                    await proc.stdin.wait_closed()
-            except (BrokenPipeError, ConnectionError, RuntimeError):
+                    proc.stdin.close()
+                    await asyncio.wait_for(proc.stdin.wait_closed(), timeout=timeout)
+            except (BrokenPipeError, ConnectionError, RuntimeError, asyncio.TimeoutError):
                 pass
             try:
                 await asyncio.wait_for(proc.wait(), timeout=timeout)