kolega-code 0.26.3__tar.gz → 0.26.5__tar.gz

{kolega_code-0.26.3 → kolega_code-0.26.5}/CHANGELOG.md

@@ -6,6 +6,27 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 0.26.5 - 2026-08-02
+
+### Fixed
+
+- DeepSeek `deepseek-v4-flash` on the Responses API no longer crashes mid-task
+  with a 400 "No tool output found for tool call ..." when the model returns tool
+  calls together with assistant text. The text was serialized between the tool
+  calls and their outputs, which DeepSeek rejects; it is now emitted before the
+  calls so each call's output stays adjacent. Tool calls are also defensively
+  guaranteed a matching output on replay.
+
+## 0.26.4 - 2026-08-02
+
+### Changed
+
+- `deepseek-v4-flash` now connects over DeepSeek's **Responses API**
+  (`https://api.deepseek.com`) for its native tool-calling format and graded
+  reasoning effort. Every other DeepSeek model (including `deepseek-v4-pro`)
+  continues to use the OpenAI-compatible Chat Completions endpoint. This is a
+  per-model routing decision; no configuration change is required.
+
 ## 0.26.3 - 2026-08-02
 
 ### Added

{kolega_code-0.26.3 → kolega_code-0.26.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.26.3
+Version: 0.26.5
 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.26.3 → kolega_code-0.26.5}/kolega_code/__init__.py

@@ -151,4 +151,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.26.3"
+__version__ = "0.26.5"

{kolega_code-0.26.3 → kolega_code-0.26.5}/kolega_code/agent/__init__.py

@@ -51,4 +51,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.26.3"
+__version__ = "0.26.5"

{kolega_code-0.26.3 → kolega_code-0.26.5}/kolega_code/agent/baseagent.py

@@ -1399,6 +1399,7 @@ class BaseAgent(LogMixin):
         client = LLMClient(
             provider=model_config.provider.value,
             api_key=self.config.get_api_key(model_config.provider) or "",
+            model=model_config.model,
             max_retries=model_config.rate_limits.max_retries,
             requests_per_minute=model_config.rate_limits.requests_per_minute,
             tokens_per_minute=model_config.rate_limits.tokens_per_minute,

{kolega_code-0.26.3 → kolega_code-0.26.5}/kolega_code/agent/context.py

@@ -109,6 +109,7 @@ class AgentContext:
             return InstrumentedLLMClient(
                 provider=model_config.provider,
                 api_key=self.config.get_api_key(model_config.provider) or "",
+                model=model_config.model,
                 max_retries=model_config.rate_limits.max_retries,
                 requests_per_minute=model_config.rate_limits.requests_per_minute,
                 tokens_per_minute=model_config.rate_limits.tokens_per_minute,
@@ -126,6 +127,7 @@ class AgentContext:
         return LLMClient(
             provider=model_config.provider,
             api_key=self.config.get_api_key(model_config.provider) or "",
+            model=model_config.model,
             max_retries=model_config.rate_limits.max_retries,
             requests_per_minute=model_config.rate_limits.requests_per_minute,
             tokens_per_minute=model_config.rate_limits.tokens_per_minute,

{kolega_code-0.26.3 → kolega_code-0.26.5}/kolega_code/agent/tool_backend/terminal_tool.py

@@ -76,6 +76,7 @@ class TerminalTool(BaseTool):
         client = LLMClient(
             provider=provider.value,
             api_key=api_key or "",
+            model=self.config.fast_config.model,
             max_retries=rate_limits.max_retries,
             requests_per_minute=rate_limits.requests_per_minute,
             tokens_per_minute=rate_limits.tokens_per_minute,

{kolega_code-0.26.3 → kolega_code-0.26.5}/kolega_code/agent/tool_backend/think_hard_tool.py

@@ -37,6 +37,7 @@ class ThinkHardTool(StreamingTool):
             client = InstrumentedLLMClient(
                 provider=provider.value,
                 api_key=api_key or "",
+                model=self.config.thinking_config.model,
                 max_retries=rate_limits.max_retries,
                 requests_per_minute=rate_limits.requests_per_minute,
                 tokens_per_minute=rate_limits.tokens_per_minute,
@@ -54,6 +55,7 @@ class ThinkHardTool(StreamingTool):
             client = LLMClient(
                 provider=provider.value,
                 api_key=api_key or "",
+                model=self.config.thinking_config.model,
                 max_retries=rate_limits.max_retries,
                 requests_per_minute=rate_limits.requests_per_minute,
                 tokens_per_minute=rate_limits.tokens_per_minute,

{kolega_code-0.26.3 → kolega_code-0.26.5}/kolega_code/agent/tool_backend/web_fetch_tool.py

@@ -142,6 +142,7 @@ class WebFetchTool(StreamingTool):
         client_kwargs = {
             "provider": provider.value,
             "api_key": self.config.get_api_key(provider),
+            "model": self.config.fast_config.model,
             "max_retries": rate_limits.max_retries,
             "requests_per_minute": rate_limits.requests_per_minute,
             "tokens_per_minute": rate_limits.tokens_per_minute,

{kolega_code-0.26.3 → kolega_code-0.26.5}/kolega_code/llm/client.py

@@ -73,11 +73,18 @@ class LLMClient:
         requests_per_minute: Optional[int] = None,
         tokens_per_minute: Optional[int] = None,
         token_manager: Optional[Any] = None,
+        model: Optional[str] = None,
     ):
         self.provider_name = provider.lower()
         self._api_key = api_key  # Store API key privately
         # Refreshing OAuth token manager, used only by the ChatGPT-subscription provider.
         self._token_manager = token_manager
+        # Routing hint only: nearly every model shares its provider's API surface, so
+        # the client is provider-scoped and the model id is passed per call. The one
+        # exception is deepseek-v4-flash (Responses API vs the deepseek Chat default),
+        # which must be known at construction to pick the right provider class. The
+        # per-call `model=` kwarg still governs the request body.
+        self._model = model
         self.provider = self._initialize_provider(
             provider,
             max_retries=max_retries,
@@ -163,6 +170,23 @@ class LLMClient:
                     provider_name=chatgpt_constants.PROVIDER_KEY,
                 )
 
+            # TEMPORARY single exception: deepseek-v4-flash speaks the Responses API
+            # (bare host, no /v1) while the rest of the deepseek catalog stays on Chat
+            # Completions. Special-cased here — like the ChatGPT provider above —
+            # because it needs a distinct base URL. Delete this branch once DeepSeek
+            # moves its catalog to Responses (then route "deepseek" wholesale).
+            if provider.lower() == "deepseek" and self._model == "deepseek-v4-flash":
+                from .providers.deepseek_responses import DeepSeekResponsesProvider
+
+                return DeepSeekResponsesProvider(
+                    api_key=self._api_key,
+                    max_retries=max_retries,
+                    requests_per_minute=requests_per_minute,
+                    tokens_per_minute=tokens_per_minute,
+                    base_url="https://api.deepseek.com",
+                    provider_name="deepseek",
+                )
+
             base_urls: Dict[str, str] = {
                 "openai": "https://api.openai.com/v1/",
                 "together": "https://api.together.xyz/v1",

{kolega_code-0.26.3 → kolega_code-0.26.5}/kolega_code/llm/instrumented_client.py

@@ -80,8 +80,11 @@ class InstrumentedLLMClient(LLMClient):
         user_email: Optional[str] = None,
         usage_recorder: Optional[Any] = None,
         token_manager: Optional[Any] = None,
+        model: Optional[str] = None,
     ):
-        super().__init__(provider, api_key, max_retries, requests_per_minute, tokens_per_minute, token_manager)
+        super().__init__(
+            provider, api_key, max_retries, requests_per_minute, tokens_per_minute, token_manager, model=model
+        )
         self.langfuse = langfuse_client
         self.workspace_id = workspace_id
         self.thread_id = thread_id

kolega_code-0.26.5/kolega_code/llm/providers/deepseek_responses.py

@@ -0,0 +1,66 @@
+"""DeepSeek provider that speaks the **Responses API** (``/responses``).
+
+TEMPORARY: ``deepseek-v4-flash`` is the one DeepSeek model on the Responses API
+today; the rest of the deepseek catalog stays on Chat Completions
+(:class:`~kolega_code.llm.providers.openai.OpenAIProvider`). DeepSeek plans to move
+its catalog over (``deepseek-v4-pro`` in early Aug 2026), at which point this class
+and its routing branch in ``client.py`` can be deleted and the whole ``deepseek``
+provider routed to Responses wholesale.
+
+Request building, streaming, and token counting are shared with the OpenAI
+Responses providers via
+:class:`~kolega_code.llm.providers.responses_common.ResponsesProviderBase`; only the
+transport differs — a plain api key against ``api.deepseek.com``. DeepSeek's Responses
+API is stateless (no ``previous_response_id`` / ``reasoning.encrypted_content``), so
+there is no cross-turn reasoning continuity, but unsupported params (including the
+``include=["reasoning.encrypted_content"]`` the shared builder sends) are silently
+ignored, so the shared request builder works unmodified. The base URL is the bare
+host — DeepSeek's Responses guide uses ``https://api.deepseek.com`` (no ``/v1``).
+"""
+
+from __future__ import annotations
+
+import uuid
+from typing import Optional
+
+from openai import AsyncOpenAI
+
+from .base import BaseLLMProvider
+from .responses_common import ResponsesProviderBase
+
+DEFAULT_BASE_URL = "https://api.deepseek.com"
+DEFAULT_MODEL = "deepseek-v4-flash"
+
+
+class DeepSeekResponsesProvider(ResponsesProviderBase):
+    """DeepSeek Responses-API provider authenticated with a standard api key."""
+
+    def __init__(
+        self,
+        api_key: str,
+        max_retries: int = 3,
+        requests_per_minute: Optional[int] = None,
+        tokens_per_minute: Optional[int] = None,
+        base_url: Optional[str] = None,
+        provider_name: str = "deepseek",
+    ) -> None:
+        # Skip OpenAIProvider.__init__ (it builds Chat Completions sync+async
+        # clients); wire a Responses-only async client instead.
+        BaseLLMProvider.__init__(
+            self,
+            api_key=api_key,
+            max_retries=max_retries,
+            requests_per_minute=requests_per_minute,
+            tokens_per_minute=tokens_per_minute,
+            base_url=base_url or DEFAULT_BASE_URL,
+        )
+        self.provider_name = provider_name
+        # A stable per-session prompt_cache_key lets the backend cache the prompt
+        # prefix across turns (DeepSeek ignores it if unsupported, which is harmless).
+        self._session_id = str(uuid.uuid4())
+        self.async_client = AsyncOpenAI(api_key=api_key, base_url=self.base_url, max_retries=max_retries)
+        # The Responses path is async-only; the sync client is unused.
+        self.sync_client = None
+
+    def _default_model(self) -> str:
+        return DEFAULT_MODEL

{kolega_code-0.26.3 → kolega_code-0.26.5}/kolega_code/llm/providers/responses_common.py

@@ -129,6 +129,7 @@ def to_responses_input(messages: MessageHistory) -> List[Dict[str, Any]]:
             continue
 
         text_parts: List[tuple] = []
+        tool_call_items: List[Dict[str, Any]] = []
         tool_image_messages: List[Dict[str, Any]] = []
         for block in message.content or []:
             if isinstance(block, ResponsesReasoningBlock):
@@ -140,8 +141,14 @@ def to_responses_input(messages: MessageHistory) -> List[Dict[str, Any]]:
                 # reasoning block first in the assistant message.
                 items.append(block.to_responses_item())
             elif isinstance(block, ToolCall):
+                # Collected, not emitted inline: the function_call items must be the
+                # LAST items of the assistant turn so the next message's
+                # function_call_output items follow them immediately. An assistant
+                # text item interposed between the calls and their outputs makes
+                # DeepSeek's Responses API 400 ("No tool output found for tool call
+                # ..."). See the assistant-text ordering below.
                 if block.input_kind == "freeform":
-                    items.append(
+                    tool_call_items.append(
                         {
                             "type": "custom_tool_call",
                             "call_id": block.id,
@@ -150,7 +157,7 @@ def to_responses_input(messages: MessageHistory) -> List[Dict[str, Any]]:
                         }
                     )
                 else:
-                    items.append(
+                    tool_call_items.append(
                         {
                             "type": "function_call",
                             "call_id": block.id,
@@ -178,11 +185,42 @@ def to_responses_input(messages: MessageHistory) -> List[Dict[str, Any]]:
             # Foreign Anthropic thinking/redacted-thinking blocks (from a prior
             # provider) are skipped here; adapt_history_for_provider has already
             # dropped them before this conversion runs.
+        # Assistant text goes BEFORE the tool calls; the calls stay last so their
+        # outputs (next message) are adjacent — required by DeepSeek's Responses API.
         if text_parts:
             item = _role_message_item(message.role, text_parts)
             if item:
                 items.append(item)
+        items.extend(tool_call_items)
         items.extend(tool_image_messages)
+
+    # Every function_call must be answered by a function_call_output or the
+    # Responses API 400s ("No tool output found for tool call ..."). A tool call
+    # can be left unanswered when a turn made several parallel calls and one
+    # result went missing (e.g. a yielded/long-running command). Mirror the Chat
+    # path (Message.to_openai) and pad any orphan with a placeholder output so the
+    # request stays valid. Keyed by call_id, preserving the freeform vs json shape.
+    # Defense-in-depth: every function_call must still be answered by a
+    # function_call_output, or the Responses API 400s. Pad any orphan (mirrors the
+    # Chat path, Message.to_openai). With the ordering above this should not fire,
+    # but a genuinely dropped result must not become a hard request failure.
+    answered = {
+        it.get("call_id") for it in items if it.get("type") in ("function_call_output", "custom_tool_call_output")
+    }
+    for it in items:
+        if it.get("type") not in ("function_call", "custom_tool_call"):
+            continue
+        call_id = it.get("call_id")
+        if call_id in answered:
+            continue
+        answered.add(call_id)
+        items.append(
+            {
+                "type": "custom_tool_call_output" if it["type"] == "custom_tool_call" else "function_call_output",
+                "call_id": call_id,
+                "output": "[no tool output recorded]",
+            }
+        )
     return items
 
 

{kolega_code-0.26.3 → kolega_code-0.26.5}/kolega_code/llm/specs/catalog/deepseek.py

@@ -14,6 +14,11 @@ DEEPSEEK_SPECS = {
             mode="deepseek_effort",
         ),
     },
+    # deepseek-v4-flash speaks the Responses API (see DeepSeekResponsesProvider), so its
+    # reasoning effort must be emitted as the Responses `reasoning` block rather than the
+    # Chat-Completions `reasoning_effort` field the shared Responses request builder ignores.
+    # DeepSeek's Responses API is stateless (no reasoning.encrypted_content), so this mode
+    # also correctly excludes flash from the flat reasoning_content replay path.
     ("deepseek", "deepseek-v4-flash"): {
         "context_length": 1000000,
         "max_completion_tokens": 384000,
@@ -23,7 +28,7 @@ DEEPSEEK_SPECS = {
         "thinking_effort": ThinkingEffortSpec(
             options=("none", "high", "max"),
             default="high",
-            mode="deepseek_effort",
+            mode="openai_responses_reasoning",
         ),
     },
 }

{kolega_code-0.26.3 → kolega_code-0.26.5}/pyproject.toml

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