kolega-code 0.11.0__tar.gz → 0.11.1__tar.gz

{kolega_code-0.11.0 → kolega_code-0.11.1}/CHANGELOG.md

@@ -6,6 +6,19 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 0.11.1 - 2026-06-26
+
+### Added
+
+- Made images `@`-mentionable in the TUI and moved file-index walking off the
+  event loop.
+
+### Fixed
+
+- Routed DeepSeek through the OpenAI-compatible `/v1` endpoint.
+- Bounded LLM streaming timeouts and added retry handling for transport errors.
+- Prevented DeepSeek stream freezes in the TUI.
+
 ## 0.11.0 - 2026-06-26
 
 ### Added

{kolega_code-0.11.0 → kolega_code-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.11.0
+Version: 0.11.1
 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.11.0 → kolega_code-0.11.1}/docs/src/assets/coverage.svg

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="114" height="20" role="img" aria-label="coverage: 80.66%"><title>coverage: 80.66%</title><filter id="blur"><feGaussianBlur stdDeviation="16"/></filter><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="114" height="20" rx="3"/></clipPath><g clip-path="url(#r)"><rect width="61" height="20" fill="#555"/><rect x="61" width="53" height="20" fill="#67ac09"/><rect width="114" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="315" y="150" fill-opacity=".8" filter="url(#blur)" textLength="510">coverage</text><text x="315" y="150" fill-opacity=".3" textLength="510">coverage</text></g><text x="315" y="140" textLength="510">coverage</text></g><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="865" y="150" fill-opacity=".8" filter="url(#blur)" textLength="430">80.66%</text><text x="865" y="150" fill-opacity=".3" textLength="430">80.66%</text></g><text x="865" y="140" textLength="430">80.66%</text></g></g></svg>
+<svg xmlns="http://www.w3.org/2000/svg" width="114" height="20" role="img" aria-label="coverage: 80.82%"><title>coverage: 80.82%</title><filter id="blur"><feGaussianBlur stdDeviation="16"/></filter><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="114" height="20" rx="3"/></clipPath><g clip-path="url(#r)"><rect width="61" height="20" fill="#555"/><rect x="61" width="53" height="20" fill="#67ac09"/><rect width="114" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="315" y="150" fill-opacity=".8" filter="url(#blur)" textLength="510">coverage</text><text x="315" y="150" fill-opacity=".3" textLength="510">coverage</text></g><text x="315" y="140" textLength="510">coverage</text></g><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="865" y="150" fill-opacity=".8" filter="url(#blur)" textLength="430">80.82%</text><text x="865" y="150" fill-opacity=".3" textLength="430">80.82%</text></g><text x="865" y="140" textLength="430">80.82%</text></g></g></svg>

{kolega_code-0.11.0 → kolega_code-0.11.1}/kolega_code/__init__.py

@@ -151,4 +151,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.11.0"
+__version__ = "0.11.1"

{kolega_code-0.11.0 → kolega_code-0.11.1}/kolega_code/agent/__init__.py

@@ -44,4 +44,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.11.0"
+__version__ = "0.11.1"

{kolega_code-0.11.0 → kolega_code-0.11.1}/kolega_code/agent/baseagent.py

@@ -28,6 +28,7 @@ from kolega_code.hooks import (
     LifecycleEvent,
 )
 from kolega_code.llm.exceptions import (
+    LLMConnectionError,
     LLMError,
     LLMInternalServerError,
     LLMRateLimitError,
@@ -1257,8 +1258,10 @@ class BaseAgent(LogMixin):
         retry_after = self._parse_retry_after(error)
         error = map_to_llm_error(error, provider=self.primary_model_config.provider.value)
 
-        # LLMInternalServerError covers 500/529 overloaded plus connection/transport errors.
-        if isinstance(error, (LLMRateLimitError, LLMInternalServerError)):
+        # Retry transient failures: rate limits, provider 5xx/overload, and transport-layer
+        # failures (LLMConnectionError, incl. its LLMTimeout subclass — e.g. a stalled
+        # streaming read hitting the per-request timeout, or a dropped connection).
+        if isinstance(error, (LLMRateLimitError, LLMInternalServerError, LLMConnectionError)):
             cap = self.primary_model_config.rate_limits.loop_max_retries
             self._consecutive_llm_retries += 1
             if self._consecutive_llm_retries > cap:
@@ -1277,6 +1280,12 @@ class BaseAgent(LogMixin):
                 f"Transient LLM error ({error}); retry {self._consecutive_llm_retries}/{cap} in {delay:.1f}s.",
                 sender=self.agent_name,
             )
+            # Surface the retry in the UI so a stalled stream (which now fails fast on the
+            # per-request timeout instead of hanging) reads as "retrying", not a freeze.
+            await self.emitter.llm_status(
+                "info",
+                f"Connection issue — retrying ({self._consecutive_llm_retries}/{cap}) in {delay:.0f}s…",
+            )
             await asyncio.sleep(delay)
             await self.log_info("Resuming after backoff.", sender=self.agent_name)
             # Don't re-raise - the turn loop re-issues the request.

{kolega_code-0.11.0 → kolega_code-0.11.1}/kolega_code/cli/app.py

@@ -158,6 +158,7 @@ class KolegaCodeApp(
         self.settings: CliSettings = CliSettings()
         self.skill_catalog: SkillCatalog = discover_skills(self.project_path)
         self.file_index = WorkspaceFileIndex(self.project_path)
+        self._file_index_refreshing = False
         self.browser_visible = browser_visible
         self.sidebar_visible = True
         self.check_for_updates = check_for_updates
@@ -419,6 +420,9 @@ class KolegaCodeApp(
         self._update_detach_button()
         if self.check_for_updates:
             self.run_worker(self._check_for_update_on_startup(), name="kolega-update-check", group="updates")
+        # Warm the @-mention file index off the event loop so the first mention has
+        # results without blocking the UI on os.walk (slow on iCloud/large trees).
+        self._maybe_refresh_file_index()
         self._schedule_conversation_bottom_anchor()
         self.run_worker(self._consume_events(), name="kolega-events", group="events")
         if self.config is not None:
@@ -832,12 +836,30 @@ class KolegaCodeApp(
         if active is None:
             dropdown.close()
             return
-        entries = self.file_index.search(active[0], limit=8)
+        # Search the cached snapshot only — never block the keystroke on os.walk. A
+        # stale/empty cache triggers a background refresh that re-runs this when done.
+        self._maybe_refresh_file_index()
+        entries = self.file_index.cached_search(active[0], limit=8)
         if not entries:
             dropdown.close()
             return
         dropdown.open_with([tui_widgets.file_completion_item(entry) for entry in entries])
 
+    def _maybe_refresh_file_index(self) -> None:
+        """Refresh the file index on a worker thread if it's stale and not already running."""
+        if self._file_index_refreshing or not self.file_index.is_stale():
+            return
+        self._file_index_refreshing = True
+        self.run_worker(self._refresh_file_index(), name="kolega-file-index", group="file-index")
+
+    async def _refresh_file_index(self) -> None:
+        try:
+            await asyncio.to_thread(self.file_index.refresh)
+        finally:
+            self._file_index_refreshing = False
+        # Surface freshly-walked results if an @-mention is still being typed.
+        self._refresh_completion_dropdown()
+
     def on_descendant_focus(self, event: events.DescendantFocus) -> None:
         # Fires after screen.focused settles. Catches AUTO_FOCUS landing on the
         # conversation transcript (resume/resize) and any other stray focus while a

{kolega_code-0.11.0 → kolega_code-0.11.1}/kolega_code/cli/file_index.py

@@ -11,6 +11,7 @@ from typing import List, Optional
 import pathspec
 
 from kolega_code.agent.tool_backend.glob_tool import GlobTool
+from kolega_code.utils.images import image_media_type
 
 
 @dataclass(frozen=True)
@@ -31,11 +32,16 @@ class WorkspaceFileIndex:
         self._refreshed_at: Optional[float] = None
 
     def entries(self) -> List[IndexEntry]:
-        now = time.monotonic()
-        if self._refreshed_at is None or now - self._refreshed_at > self.TTL_SECONDS:
+        if self.is_stale():
             self.refresh()
         return self._entries
 
+    def is_stale(self) -> bool:
+        """Whether the cache is empty or older than the TTL (a refresh is due)."""
+        if self._refreshed_at is None:
+            return True
+        return time.monotonic() - self._refreshed_at > self.TTL_SECONDS
+
     def refresh(self) -> None:
         gitignore = self._load_gitignore_spec()
         entries: List[IndexEntry] = []
@@ -54,7 +60,10 @@ class WorkspaceFileIndex:
             dirnames[:] = kept_dirs
 
             for name in sorted(filenames):
-                if Path(name).suffix.lower() in GlobTool.BINARY_EXTENSIONS:
+                # Exclude binaries, but keep attachable images: @-mentioning an image
+                # attaches it (build_file_attachments handles it via the same
+                # image_media_type), so it belongs in completions for vision models.
+                if Path(name).suffix.lower() in GlobTool.BINARY_EXTENSIONS and image_media_type(name) is None:
                     continue
                 rel = self._posix(rel_dir / name)
                 if gitignore is not None and gitignore.match_file(rel):
@@ -69,8 +78,21 @@ class WorkspaceFileIndex:
         self._refreshed_at = time.monotonic()
 
     def search(self, query: str, limit: int = 8) -> List[IndexEntry]:
+        """Search, refreshing the cache first if stale (may block on os.walk)."""
+        return self._rank(self.entries(), query, limit)
+
+    def cached_search(self, query: str, limit: int = 8) -> List[IndexEntry]:
+        """Search the current cached entries WITHOUT refreshing.
+
+        The UI uses this so a keystroke never blocks on ``os.walk``; a background
+        refresh (see ``app._refresh_file_index``) updates the cache out-of-band.
+        """
+        return self._rank(self._entries, query, limit)
+
+    @staticmethod
+    def _rank(entries: List[IndexEntry], query: str, limit: int) -> List[IndexEntry]:
         scored = []
-        for entry in self.entries():
+        for entry in entries:
             score = fuzzy_score(query, entry.path)
             if score is not None:
                 scored.append((score, entry))

{kolega_code-0.11.0 → kolega_code-0.11.1}/kolega_code/cli/theme.py

@@ -88,6 +88,14 @@ CONTEXT_BAR_WIDTH = 18
 INSET_WIDTH = 2
 MARKDOWN_CODE_THEME = "monokai"
 RENDER_COALESCE_INTERVAL = 0.05
+# Coalesce less aggressively as the live streaming entry grows: each flush still costs
+# Textual an O(height) re-measure of an auto-height widget, so for very large reasoning
+# streams we trade a little update latency for far fewer full re-measures. Sizes are
+# characters of the live entry; see transcript._invalidate_conversation.
+RENDER_COALESCE_INTERVAL_MEDIUM = 0.12
+RENDER_COALESCE_INTERVAL_LARGE = 0.25
+RENDER_COALESCE_MEDIUM_CHARS = 40_000
+RENDER_COALESCE_LARGE_CHARS = 200_000
 
 
 @lru_cache(maxsize=None)

{kolega_code-0.11.0 → kolega_code-0.11.1}/kolega_code/cli/tui/agent_runtime.py

@@ -214,7 +214,10 @@ class AgentRuntimeMixin:
         if queued.entry not in self.conversation_entries:
             self._add_conversation_entry(queued.entry)
         else:
-            self._render_conversation()
+            # The entry is already mounted (added when queued); just re-render that one
+            # widget for the queued->user transition instead of rebuilding the whole
+            # transcript, which on a long thread is a synchronous O(entries) hitch.
+            self._invalidate_conversation(queued.entry)
         self._refresh_queued_messages_panel()
         self._clear_composer_hint()
         self.agent_worker = self.run_worker(

{kolega_code-0.11.0 → kolega_code-0.11.1}/kolega_code/cli/tui/state.py

@@ -76,6 +76,24 @@ class ConversationEntry:
     full_content: str = ""  # untruncated tool output for expand-on-demand (capped)
     edit_preview: Optional[dict] = None  # UI-only structured diff/head preview for edit tools (not persisted)
     entry_id: str = field(default_factory=_next_entry_id)  # UI-only widget key, not persisted
+    # Streaming buffers (UI-only, excluded from equality/repr). Deltas accumulate in
+    # stream_parts and are joined into content once per render flush, not per chunk, to
+    # avoid O(n^2) attribute concatenation. render_cache holds the incrementally-built
+    # inset renderable so each flush appends only the new text rather than re-splitting
+    # the whole buffer. See transcript._apply_stream_chunk / _streaming_inset_renderable.
+    stream_parts: list[str] = field(default_factory=list, compare=False, repr=False)
+    render_cache: object = field(default=None, compare=False, repr=False)
+
+    def materialize(self) -> str:
+        """Fold any deferred stream deltas into ``content`` and return it.
+
+        Streaming appends land in ``stream_parts`` (O(1)); they are joined into
+        ``content`` once here — on each render flush and when the segment completes —
+        rather than on every chunk, so growth stays O(n) instead of O(n^2)."""
+        if self.stream_parts:
+            self.content += "".join(self.stream_parts)
+            self.stream_parts.clear()
+        return self.content
 
 
 @dataclass

{kolega_code-0.11.0 → kolega_code-0.11.1}/kolega_code/cli/tui/transcript.py

@@ -31,6 +31,29 @@ from .sub_agent_screen import SubAgentEntryWidget
 from .widgets import ConversationEntryWidget, JumpToBottomBar, ToolEntryWidget
 
 
+class _InsetRenderState:
+    """Incremental render cache for a streaming inset body (assistant/thinking).
+
+    Holds the Rich ``Text`` built so far plus enough state to append only newly
+    arrived characters on each flush, instead of re-splitting the whole growing
+    buffer. The output matches ``_format_inset_text`` for ``\\n``-delimited content
+    (the common case); completion does a canonical full reformat as a safety net.
+    """
+
+    __slots__ = ("text", "length", "started", "open_has_content", "deferred_newline", "style")
+
+    def __init__(self, style):
+        self.text = Text()
+        self.length = 0  # chars of entry.content already folded into `text`
+        self.started = False  # has the first line's inset bar been emitted?
+        self.open_has_content = False  # has the current (last) line emitted its " " + text?
+        # One pending line break: a "\n" defers its new line until either more content or
+        # another "\n" arrives, so a *trailing* terminator leaves no empty inset line
+        # (matching str.splitlines, which drops only the final terminator).
+        self.deferred_newline = False
+        self.style = style
+
+
 class TranscriptRenderingMixin:
     def _restore_conversation_history(self, history: list[dict]) -> None:
         self.conversation_entries = []
@@ -238,8 +261,14 @@ class TranscriptRenderingMixin:
             self.conversation_entries.append(entry)
             self._stream_entries[cache_key] = entry
 
-        entry.content += content
+        # Defer concatenation to the next render flush (see ConversationEntryWidget.
+        # refresh_content): per-chunk `content += content` is O(n^2) over the stream.
+        # On completion, materialize now so entry.content is current the moment the
+        # segment ends (one O(n) join), without waiting for the flush.
+        entry.stream_parts.append(content)
         entry.complete = complete
+        if complete:
+            entry.materialize()
         self._invalidate_conversation(entry)
 
     def _begin_turn_progress(self) -> None:
@@ -1112,9 +1141,10 @@ class TranscriptRenderingMixin:
         if self._render_pending:
             return
         self._render_pending = True
+        interval = self._render_coalesce_interval(entry)
         try:
             self.set_timer(
-                theme.RENDER_COALESCE_INTERVAL,
+                interval,
                 self._flush_conversation_render,
                 name="conversation-render",
             )
@@ -1122,6 +1152,23 @@ class TranscriptRenderingMixin:
             # Timers are unavailable before the app is running; render directly.
             self._flush_conversation_render()
 
+    def _render_coalesce_interval(self, entry: Optional[ConversationEntry]) -> float:
+        """Back off the flush cadence for very large live entries.
+
+        Each flush makes Textual re-measure the auto-height streaming widget (O(height)),
+        so for big reasoning streams fewer, larger flushes beat ~20/sec full re-measures.
+        Length lags one flush (deltas materialize at flush time), which is fine: the entry
+        only grows, so the cadence steps up within one interval of crossing a threshold.
+        """
+        if entry is None:
+            return theme.RENDER_COALESCE_INTERVAL
+        size = len(entry.content)
+        if size >= theme.RENDER_COALESCE_LARGE_CHARS:
+            return theme.RENDER_COALESCE_INTERVAL_LARGE
+        if size >= theme.RENDER_COALESCE_MEDIUM_CHARS:
+            return theme.RENDER_COALESCE_INTERVAL_MEDIUM
+        return theme.RENDER_COALESCE_INTERVAL
+
     def _flush_conversation_render(self) -> None:
         if not self._render_pending:
             return
@@ -1280,11 +1327,15 @@ class TranscriptRenderingMixin:
             header = theme.role_header(Glyph.AGENT, "Agent", Color.AGENT, state=streaming)
             if entry.complete and entry.content.strip():
                 return self._markdown_entry(header, entry.content)
+            if not entry.complete:
+                return self._streaming_inset_renderable(entry, header)
             return self._entry_renderable(header, entry.content)
         if entry.kind == "thinking":
             header = theme.role_header(
                 Glyph.STATUS, "Thinking", Color.THINKING, label_style="dim italic", state=streaming
             )
+            if not entry.complete:
+                return self._streaming_inset_renderable(entry, header, body_style="italic dim")
             return self._entry_renderable(header, entry.content, body_style="italic dim")
         if entry.kind == "progress":
             color = Color.ERROR if entry.tone == "error" else Color.WARNING
@@ -1336,6 +1387,63 @@ class TranscriptRenderingMixin:
             return header_text
         return Group(header_text, self._format_inset_text(body, style=body_style))
 
+    def _streaming_inset_renderable(self, entry, header: str, *, body_style: Optional[str] = None) -> Group:
+        """Inset body for a still-streaming entry, built incrementally (O(delta) per flush).
+
+        Caches the rendered Text on the entry so each flush only appends the newly
+        arrived characters instead of re-splitting and re-rendering the whole buffer
+        (the O(n^2) cliff). The header is small and rebuilt each call. On completion the
+        dispatcher routes to the canonical _entry_renderable/_markdown_entry instead.
+        """
+        state = entry.render_cache
+        content = entry.content
+        if not isinstance(state, _InsetRenderState) or state.style != body_style or state.length > len(content):
+            # First render for this entry, a body-style change, or a defensive shrink:
+            # fold the whole current buffer once.
+            state = _InsetRenderState(body_style)
+            entry.render_cache = state
+            self._extend_inset(state, content)
+        elif state.length < len(content):
+            self._extend_inset(state, content[state.length :])
+        return Group(Text.from_markup(header), state.text)
+
+    def _extend_inset(self, state: "_InsetRenderState", delta: str) -> None:
+        """Append ``delta`` to the cached inset Text, matching _format_inset_text for "\\n".
+
+        A pending newline is flushed (its new line materialized) as soon as another
+        newline *or* content follows it; only a still-pending terminator at the very end
+        is left unrendered, so the result equals ``_format_inset_text`` over the buffer.
+        """
+        if not delta and state.started:
+            return
+        bar = f"  {theme.g(Glyph.INSET_BAR)}"
+        text = state.text
+
+        def flush_deferred() -> None:
+            if state.deferred_newline:
+                text.append("\n")
+                text.append(bar, style="dim")
+                state.deferred_newline = False
+                state.open_has_content = False
+
+        if not state.started:
+            text.append(bar, style="dim")
+            state.started = True
+            state.open_has_content = False
+
+        for index, segment in enumerate(delta.split("\n")):
+            if index > 0:
+                # A "\n" boundary confirms any prior deferred line, then defers its own.
+                flush_deferred()
+                state.deferred_newline = True
+            if segment:
+                flush_deferred()
+                if not state.open_has_content:
+                    text.append(" ")
+                    state.open_has_content = True
+                text.append(segment, style=state.style)
+        state.length += len(delta)
+
     def _markdown_entry(self, header: str, content: str) -> Group:
         return Group(
             Text.from_markup(header),

{kolega_code-0.11.0 → kolega_code-0.11.1}/kolega_code/cli/tui/widgets.py

@@ -40,6 +40,10 @@ class ConversationEntryWidget(Static):
         self.refresh_content()
 
     def refresh_content(self) -> None:
+        # Join any streamed deltas into content once here (per flush) rather than on
+        # every chunk, so growth stays O(n) instead of O(n^2) attribute concatenation.
+        self.entry.materialize()
+
         kind_class = f"entry-{self.entry.kind}"
         if kind_class != self._kind_class:
             if self._kind_class:
@@ -55,13 +59,16 @@ class ConversationEntryWidget(Static):
         self.update(self._formatted)
 
     def _entry_snapshot(self) -> tuple[object, ...]:
+        # Use content lengths, not the full strings: streaming only appends, so length
+        # is a strictly-monotonic change signal and the comparison stays O(1) instead of
+        # an O(n) string compare on every coalesced flush.
         return (
             self.entry.kind,
-            self.entry.content,
+            len(self.entry.content),
             self.entry.complete,
             self.entry.tool_name,
             self.entry.tone,
-            self.entry.full_content,
+            len(self.entry.full_content),
             repr(self.entry.edit_preview),
         )
 

{kolega_code-0.11.0 → kolega_code-0.11.1}/kolega_code/llm/client.py

@@ -132,7 +132,11 @@ class LLMClient:
                 "xai": OpenAIProvider,
                 "dashscope": OpenAIProvider,
                 "moonshot": AnthropicProvider,
-                "deepseek": AnthropicProvider,
+                # DeepSeek's OpenAI-compatible /v1 endpoint streams reasoning_content
+                # continuously; its Anthropic-compatible endpoint goes silent during
+                # reasoning, so an idle-connection drop hangs streaming turns. Route
+                # through the OpenAI Chat path (matches opencode/openclaw, which work).
+                "deepseek": OpenAIProvider,
                 "zai": AnthropicProvider,
                 "kimi_coding": AnthropicProvider,
                 "ollama_cloud": OpenAIProvider,
@@ -148,7 +152,7 @@ class LLMClient:
                 "xai": "https://api.x.ai/v1",
                 "dashscope": "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
                 "moonshot": "https://api.moonshot.ai/anthropic",
-                "deepseek": "https://api.deepseek.com/anthropic",
+                "deepseek": "https://api.deepseek.com/v1",
                 "zai": "https://api.z.ai/api/anthropic",
                 "kimi_coding": "https://api.kimi.com/coding",
                 "ollama_cloud": "https://ollama.com/v1",

{kolega_code-0.11.0 → kolega_code-0.11.1}/kolega_code/llm/exceptions.py

@@ -39,11 +39,17 @@ import asyncio
 
 from anthropic import (
     AnthropicError,
+    APIConnectionError as AnthropicAPIConnectionError,
     APIStatusError as AnthropicAPIStatusError,
+    APITimeoutError as AnthropicAPITimeoutError,
     InternalServerError as AnthropicInternalServerError,
 )
 from google.genai.errors import APIError as GoogleAPIError
-from openai import OpenAIError
+from openai import (
+    APIConnectionError as OpenAIAPIConnectionError,
+    APITimeoutError as OpenAIAPITimeoutError,
+    OpenAIError,
+)
 
 try:
     import aiohttp
@@ -99,8 +105,15 @@ class LLMNotFoundError(LLMError):
     """Raised when the requested resource is not found."""
 
 
-class LLMTimeout(LLMError):
-    """Raised when the request to the LLM service times out."""
+class LLMConnectionError(LLMError):
+    """Raised when the transport layer fails — a connection that couldn't be established,
+    was dropped/reset, or stalled. Distinct from LLMInternalServerError (a provider 5xx):
+    nothing reached the model, or the connection died mid-stream. Transient and retryable."""
+
+
+class LLMTimeout(LLMConnectionError):
+    """Raised when a request to the LLM service times out (a stalled connection). A
+    specific kind of LLMConnectionError, e.g. a streaming read exceeding its timeout."""
 
 
 class LLMUnprocessableEntityError(LLMError):
@@ -191,6 +204,9 @@ def llm_error_message(error: LLMError, model: str | None = None) -> str:
     if isinstance(error, LLMTimeout):
         return f"{provider_model} timed out while processing this request. Please try again."
 
+    if isinstance(error, LLMConnectionError):
+        return f"{provider_model} could not be reached (connection error). Please try again."
+
     if isinstance(error, LLMContentPolicyViolationError):
         return f"{provider_model} blocked this request due to the provider's content policy."
 
@@ -248,6 +264,14 @@ def map_openai_errors(error: OpenAIError) -> LLMError:
         elif error.status_code == 500:
             return LLMInternalServerError(message=f"OpenAI APIError: {str(error)}", provider=ModelProvider.OPENAI.value)
 
+    # Transport failures (a stalled streaming read hitting the per-request timeout, a
+    # dropped/reset connection) are retryable. APITimeoutError subclasses APIConnectionError,
+    # so check the timeout case first for the more specific error/message.
+    if isinstance(error, OpenAIAPITimeoutError):
+        return LLMTimeout(message=f"OpenAI APIError: {str(error)}", provider=ModelProvider.OPENAI.value)
+    if isinstance(error, OpenAIAPIConnectionError):
+        return LLMConnectionError(message=f"OpenAI APIError: {str(error)}", provider=ModelProvider.OPENAI.value)
+
     return LLMError(message=f"OpenAI APIError: {str(error)}", provider=ModelProvider.OPENAI.value)
 
 
@@ -333,6 +357,14 @@ def map_anthropic_errors(error: AnthropicError, provider: str | None = None) ->
         if error.status_code == 529:
             return LLMInternalServerError(message=f"AnthropicError: {str(error)}", provider=provider)
 
+    # Transport failures (a stalled streaming read hitting the per-request timeout, a
+    # dropped/reset connection) are retryable. APITimeoutError subclasses APIConnectionError,
+    # so check the timeout case first for the more specific error/message.
+    if isinstance(error, AnthropicAPITimeoutError):
+        return LLMTimeout(message=f"AnthropicError: {str(error)}", provider=provider)
+    if isinstance(error, AnthropicAPIConnectionError):
+        return LLMConnectionError(message=f"AnthropicError: {str(error)}", provider=provider)
+
     return LLMError(message=f"AnthropicError: {str(error)}", provider=provider)
 
 
@@ -365,14 +397,20 @@ def map_to_llm_error(error: Exception, provider: str = None) -> LLMError:
     # Map common Python exceptions
     if isinstance(error, ValueError):
         return LLMInvalidRequestError(message=f"Invalid parameter: {str(error)}", provider=provider)
+    elif httpx and isinstance(error, httpx.TimeoutException):
+        # Read/connect/pool/write timeouts (e.g. a stalled streaming read). Check before
+        # the broader TransportError below; LLMTimeout is an LLMConnectionError subclass.
+        return LLMTimeout(message=f"Request timeout: {str(error)}", provider=provider)
     elif isinstance(error, (TimeoutError, asyncio.TimeoutError)):
         return LLMTimeout(message=f"Request timeout: {str(error)}", provider=provider)
     elif isinstance(error, ConnectionError):
-        return LLMInternalServerError(message=f"Connection error: {str(error)}", provider=provider)
+        return LLMConnectionError(message=f"Connection error: {str(error)}", provider=provider)
     elif aiohttp and isinstance(error, aiohttp.ClientError):
-        return LLMInternalServerError(message=f"HTTP client error: {str(error)}", provider=provider)
-    elif httpx and isinstance(error, httpx.RemoteProtocolError):
-        return LLMInternalServerError(message=f"HTTPX protocol error: {str(error)}", provider=provider)
+        return LLMConnectionError(message=f"HTTP client error: {str(error)}", provider=provider)
+    elif httpx and isinstance(error, httpx.TransportError):
+        # Connect/read/protocol/reset errors — transient transport failures (e.g. a dropped
+        # streaming connection), so retryable.
+        return LLMConnectionError(message=f"HTTPX transport error: {str(error)}", provider=provider)
     elif isinstance(error, KeyError):
         return LLMInvalidRequestError(message=f"Missing required parameter: {str(error)}", provider=provider)
     elif isinstance(error, TypeError):

{kolega_code-0.11.0 → kolega_code-0.11.1}/kolega_code/llm/instrumented_client.py

@@ -89,12 +89,22 @@ class InstrumentedLLMClient(LLMClient):
 
         provider = usage_metadata.get("provider", self.provider_name)
 
-        if provider in ["anthropic", "moonshot", "deepseek", "kimi_coding"]:
+        if provider in ["anthropic", "moonshot", "kimi_coding"]:
             input_tokens = usage_metadata.get("input_tokens", 0)
             output_tokens = usage_metadata.get("output_tokens", 0)
             cache_read_tokens = usage_metadata.get("cache_read_input_tokens", 0)
             cache_write_tokens = usage_metadata.get("cache_write_input_tokens", 0)
-        elif provider in ["openai", "openai_chatgpt", "together", "groq", "fireworks", "llama", "xai", "dashscope"]:
+        elif provider in [
+            "openai",
+            "openai_chatgpt",
+            "together",
+            "groq",
+            "fireworks",
+            "llama",
+            "xai",
+            "dashscope",
+            "deepseek",
+        ]:
             input_tokens = usage_metadata.get("prompt_tokens", 0)
             output_tokens = usage_metadata.get("completion_tokens", 0)
             cache_read_tokens = usage_metadata.get("cache_read_input_tokens", 0)
@@ -246,7 +256,7 @@ class InstrumentedLLMClient(LLMClient):
             normalized_usage = None
             if usage_details:
                 provider = usage_details.get("provider", self.provider_name)
-                if provider in ["anthropic", "moonshot", "deepseek", "kimi_coding"]:
+                if provider in ["anthropic", "moonshot", "kimi_coding"]:
                     normalized_usage = {
                         "input": usage_details.get("input_tokens", 0),
                         "output": usage_details.get("output_tokens", 0),
@@ -254,7 +264,7 @@ class InstrumentedLLMClient(LLMClient):
                         "cache_read_input_tokens": usage_details.get("cache_read_input_tokens", 0),
                         "cache_creation_input_tokens": usage_details.get("cache_write_input_tokens", 0),
                     }
-                elif provider in ["openai", "openai_chatgpt", "fireworks"]:
+                elif provider in ["openai", "openai_chatgpt", "fireworks", "deepseek"]:
                     normalized_usage = {
                         "input": usage_details.get("prompt_tokens", 0),
                         "output": usage_details.get("completion_tokens", 0),
@@ -495,7 +505,7 @@ class MinimalLangfuseStreamWrapper:
         usage_metadata = message.usage_metadata
         provider = usage_metadata.get("provider", "")
 
-        if provider in ["anthropic", "moonshot", "deepseek", "kimi_coding"]:
+        if provider in ["anthropic", "moonshot", "kimi_coding"]:
             return {
                 "input": usage_metadata.get("input_tokens", 0),
                 "output": usage_metadata.get("output_tokens", 0),
@@ -503,7 +513,7 @@ class MinimalLangfuseStreamWrapper:
                 "cache_read_input_tokens": usage_metadata.get("cache_read_input_tokens", 0),
                 "cache_creation_input_tokens": usage_metadata.get("cache_write_input_tokens", 0),
             }
-        elif provider in ["openai", "openai_chatgpt", "fireworks"]:
+        elif provider in ["openai", "openai_chatgpt", "fireworks", "deepseek"]:
             return {
                 "input": usage_metadata.get("prompt_tokens", 0),
                 "output": usage_metadata.get("completion_tokens", 0),