kolega-code 0.29.0__tar.gz → 0.30.1__tar.gz

{kolega_code-0.29.0 → kolega_code-0.30.1}/CHANGELOG.md

@@ -6,6 +6,53 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 0.30.1 - 2026-08-17
+
+### Fixed
+
+- Compaction now uses the primary model's thinking setting instead of
+  omitting it. Empty or reasoning-only helper completions are retried,
+  then can still take the zero-tail recovery path instead of being
+  treated as a final `llm_error`.
+
+## 0.30.0 - 2026-08-14
+
+### Added
+
+- Added Google Gemini 3.7 Flash (`gemini-3.7-flash`): 1M-token context, 64K
+  output, vision and function calling, and `low`/`medium`/`high` thinking
+  levels. It omits Google's deprecated temperature parameter and is now the
+  default Google model.
+- DeepSeek V4-Pro now routes to the Responses API by default (joining V4-Flash),
+  removing the model-name carve-out. Both DeepSeek models support `none`, `low`,
+  `high`, and `max` reasoning effort (`low` is new; `none` disables reasoning).
+  Hosted web search is now available on V4-Pro as well as V4-Flash.
+- Added support for xAI Grok 4.6 (`grok-4.6`): 500K-token context, vision input,
+  and `low`/`medium`/`high`/`xhigh` reasoning effort. Selectable in the Settings
+  UI, `/model` picker, CLI flags, and env vars.
+- Added support for Z.AI GLM-5.3 (`glm-5.3`) on the GLM Coding Plan provider:
+  1M-token context, 128K max output, and `high`/`max` thinking effort. GLM-5.3
+  is now the Z.AI default model.
+- Added the Perplexity Agent API provider (`perplexity_agent`): one
+  `PERPLEXITY_API_KEY` reaches OpenAI, Anthropic, Google, xAI, and Perplexity
+  models through Perplexity's Responses-compatible Agent API, with optional
+  hosted search tools.
+- `/plan` accepts an optional prompt: `/plan <task>` switches to plan mode and
+  starts that planning turn. Bare `/plan` still only switches mode.
+
+### Fixed
+
+- Google Gemini models no longer reject builtin tool calls with a 400 about
+  `additionalProperties` in function-declaration schemas.
+- Quitting the TUI no longer waits up to 30s for an unresponsive language
+  server to acknowledge shutdown.
+- The Z.AI context-window gauge now counts tokens locally (Z.AI's count
+  endpoint reports 0 for GLM-5.3) and residual usage calibrates from
+  multi-provider response billing.
+- MCP tools whose names contain invalid characters or exceed provider length
+  limits are sanitized at collection time, and provider 400 details are shown
+  in the turn error instead of a generic failure.
+
 ## 0.29.0 - 2026-08-13
 
 ### Added

{kolega_code-0.29.0 → kolega_code-0.30.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.29.0
+Version: 0.30.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.29.0 → kolega_code-0.30.1}/kolega_code/__init__.py

@@ -174,4 +174,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.29.0"
+__version__ = "0.30.1"

{kolega_code-0.29.0 → kolega_code-0.30.1}/kolega_code/agent/__init__.py

@@ -51,4 +51,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.29.0"
+__version__ = "0.30.1"

{kolega_code-0.29.0 → kolega_code-0.30.1}/kolega_code/agent/baseagent.py

@@ -521,6 +521,8 @@ class BaseAgent(LogMixin):
         # gate reads client_web_tools_enabled, the stream call reads
         # hosted_web_search_active.
         self.supports_hosted_web_search = bool(model_specs.get("supports_hosted_web_search", False))
+        # Spec-declared server-side tools; _apply_web_search_state derives the live list.
+        self._model_server_tools: List[str] = [str(tool) for tool in model_specs.get("server_tools") or []]
         self.web_search_mode = getattr(self.config, "web_search_mode", "auto") or "auto"
         self._apply_web_search_state()
 
@@ -731,22 +733,27 @@ class BaseAgent(LogMixin):
             initialize()
 
     def _apply_web_search_state(self) -> None:
-        """Resolve web_search_mode + model capability into the two live gates.
+        """Resolve web_search_mode + model capability into the live gates.
 
         ``hosted_web_search_active`` — request the provider's server-side
         web_search tool on main-loop stream calls. ``client_web_tools_enabled``
         — register the client-side web_search/web_fetch tools (read by the
-        ToolCollection gate). Hosted active always excludes the client tools:
-        two search paths confuse the model and waste schema tokens.
+        ToolCollection gate). ``server_tools`` — the spec-declared server-side
+        tools (e.g. the Perplexity Agent API's). One setting gates all of it:
+        auto/hosted request the server-side tooling, client defers to the
+        client-side web tools, off disables web tooling entirely. Active
+        server-side web tooling always excludes the client tools: two search
+        paths confuse the model and waste schema tokens.
         """
         mode = (self.web_search_mode or "auto").lower()
         supported = self.supports_hosted_web_search
+        server_web_tooling = supported or "web_search" in self._model_server_tools
         if mode == "off":
             hosted, client = False, False
         elif mode == "client":
             hosted, client = False, True
         elif mode == "hosted":
-            if not supported:
+            if not server_web_tooling:
                 provider = self.primary_model_config.provider
                 logger.warning(
                     "web_search_mode=hosted, but %s/%s has no hosted web search; falling back to the client tools",
@@ -758,6 +765,9 @@ class BaseAgent(LogMixin):
             hosted, client = supported, not supported
         self.hosted_web_search_active = hosted
         self.client_web_tools_enabled = client
+        self.server_tools = list(self._model_server_tools) if mode in ("auto", "hosted") else []
+        if "web_search" in self.server_tools:
+            self.client_web_tools_enabled = False
 
     def apply_web_search_mode(self, mode: str) -> None:
         """Change the web tool mode mid-session (TUI ``/web-search``).
@@ -770,31 +780,36 @@ class BaseAgent(LogMixin):
         self._apply_web_search_state()
 
     async def _emit_hosted_tool_call(self, delta: Dict[str, Any]) -> None:
-        """Render a completed hosted web_search call as a tool_call/tool_result pair.
+        """Render a completed hosted/server-side tool call as a tool_call/tool_result pair.
 
         The call executed on the provider's servers; there is no local tool
-        invocation and the searched content never reaches the client (it is
-        injected into the model's context server-side). The shared item id
-        correlates the pair in every transcript consumer.
+        invocation. For OpenAI/DeepSeek web_search the searched content never
+        reaches the client (it is injected into the model's context
+        server-side); Perplexity Agent API result items (search_results /
+        fetch_url_results) carry their results client-side via the delta's
+        item_type/payload. The shared item id correlates the pair in every
+        transcript consumer.
         """
         block = WebSearchCallBlock(
             item_id=delta.get("id") or None,
             status=delta.get("status"),
             action=delta.get("action") or {},
+            item_type=str(delta.get("item_type") or "web_search_call"),
+            payload=delta.get("payload"),
         )
         tool_call_id = block.item_id or str(uuid.uuid4())
         await self.send_chat_message(
             message_type="tool_call",
-            content=f"Calling {WebSearchCallBlock.TOOL_LABEL}: {block.label()}",
+            content=f"Calling {block.tool_label}: {block.label()}",
             is_streaming=False,
-            tool_description=WebSearchCallBlock.TOOL_LABEL,
+            tool_description=block.tool_label,
             tool_call_id=tool_call_id,
         )
         await self.send_chat_message(
             message_type="tool_result",
             content=block.result_summary(),
             is_streaming=False,
-            tool_description=WebSearchCallBlock.TOOL_LABEL,
+            tool_description=block.tool_label,
             tool_call_id=tool_call_id,
         )
 
@@ -1130,7 +1145,15 @@ class BaseAgent(LogMixin):
         if new_calls:
             self._context_residual_tokens += self.HOSTED_SEARCH_PROVISIONAL_TOKENS * new_calls
             return
-        billed = (assistant_message.usage_metadata or {}).get("prompt_tokens")
+        billed = (
+            assistant_message.usage.input_tokens
+            if assistant_message.usage and assistant_message.usage.reported
+            else (
+                (assistant_message.usage_metadata or {}).get("prompt_tokens")
+                or (assistant_message.usage_metadata or {}).get("input_tokens")
+                or (assistant_message.usage_metadata or {}).get("prompt_token_count")
+            )
+        )
         counted = self._last_raw_context_count
         if not isinstance(billed, int) or counted is None:
             return
@@ -1201,9 +1224,10 @@ class BaseAgent(LogMixin):
                 llm=self.llm,
                 model=self.primary_model_config.model,
                 temperature=self.model_default_temperature,
-                # No extended thinking: a bounded summary doesn't need it, and the
-                # thinking budget could otherwise exceed the small summary max_tokens.
-                thinking=None,
+                # Same thinking setting as the primary request. Omitting it is not a
+                # disable: some endpoints default to reasoning-on, and some reject a
+                # missing effort. A None effort (no thinking spec) still omits the field.
+                thinking=self.primary_model_config.thinking_effort,
                 on_info=on_info,
                 on_error=on_error,
                 system_prompt_text=compaction_system_prompt,
@@ -2425,9 +2449,11 @@ class BaseAgent(LogMixin):
                     # at the model (llm_error — the provider client already applied
                     # its retry policy, so another summarization request buys
                     # nothing) or hit the minimum-history guard (too_few — a zero
-                    # tail must not weaken it). A nothing_to_summarize result MAY
-                    # proceed: with no retained tail, the safe boundary can advance
-                    # past the previous one even when the six-message tail could not.
+                    # tail must not weaken it). An empty_summary or
+                    # nothing_to_summarize result MAY proceed: empty completions
+                    # already exhausted in-pass retries, and with no retained tail
+                    # the safe boundary can advance past the previous one even
+                    # when the six-message tail could not.
                     if token_count.input_tokens > self.model_max_input_tokens and result.reason not in (
                         "llm_error",
                         "too_few",
@@ -2488,6 +2514,7 @@ class BaseAgent(LogMixin):
                             tools=self.tool_collection.get_tool_list(),
                             thinking=self.primary_model_config.thinking_effort,
                             hosted_web_search=self.hosted_web_search_active,
+                            server_tools=self.server_tools or None,
                             # The strict per-run budget rechecks this request inside
                             # the client; hand it the count already taken for the
                             # gauge (same history) so it is not counted twice.

{kolega_code-0.29.0 → kolega_code-0.30.1}/kolega_code/agent/compression.py

@@ -23,7 +23,7 @@ LogCallback = Callable[[str], Awaitable[None]]
 class CompactionResult:
     """Outcome of a compaction attempt, surfaced to callers and the UI.
 
-    ``reason`` is a machine tag: "ok" | "too_few" | "nothing_to_summarize" | "llm_error".
+    ``reason`` is a machine tag: "ok" | "too_few" | "nothing_to_summarize" | "empty_summary" | "llm_error".
     ``message`` is a human-readable line for the command output / logs.
     """
 
@@ -117,6 +117,37 @@ def _bundles_tool_results(message: Message) -> bool:
     return isinstance(message.content, list) and any(isinstance(block, ToolResult) for block in message.content)
 
 
+async def _stream_summary(
+    llm,
+    messages: MessageHistory,
+    system: Message,
+    temperature: float,
+    model: str,
+    thinking,
+) -> Message:
+    """Issue the compaction helper request and return the completed message.
+
+    Stream and consume events rather than calling ``generate()``: the Anthropic
+    SDK rejects non-streaming requests whose max_tokens is large enough to risk
+    a >10-minute response. The helper origin spans the whole request because
+    providers may sample and emit their trace record at context entry or
+    final-message time, not at ``stream()``.
+    """
+    with llm_call_origin(helper_origin("compression")):
+        stream_cm = await llm.stream(
+            messages=messages,
+            system=system,
+            temperature=temperature,
+            model=model,
+            max_completion_tokens=HistoryCompressor.SUMMARY_MAX_TOKENS,
+            thinking=thinking,
+        )
+        async with stream_cm as stream:
+            async for _event in stream:
+                pass
+        return await stream.get_final_message()
+
+
 class HistoryCompressor:
     """Summarizes a conversation non-destructively when it crosses the budget threshold."""
 
@@ -131,6 +162,9 @@ class HistoryCompressor:
     # summary. A generous ceiling gives reasoning headroom while still staying
     # well under the model's full completion budget.
     SUMMARY_MAX_TOKENS = 8192
+    # Completed-but-empty summaries (reasoning-only, whitespace, no text) are
+    # retried on the same fitted request before the pass is reported unusable.
+    SUMMARY_EMPTY_ATTEMPTS = 3
     # Attempts at widening the omission gap per budget rung.
     MAX_FIT_ATTEMPTS = 6
 
@@ -254,13 +288,6 @@ class HistoryCompressor:
                     head_end, tail_start = new_head, new_tail
                     messages = build_request(head_end, tail_start)
 
-            # Stream and drain rather than calling generate(): the Anthropic SDK
-            # rejects non-streaming requests whose max_tokens is large enough to risk
-            # a >10-minute response, which the model's full completion budget triggers.
-            #
-            # The helper origin spans the whole request: providers may sample and
-            # emit their trace record at context entry or final-message time, not
-            # at stream().
             response = None
             last_error: Optional[LLMContextWindowExceededError] = None
             dispatched_gap: Optional[tuple[int, int]] = None
@@ -273,19 +300,14 @@ class HistoryCompressor:
                         # re-sending it would only be rejected again.
                         continue
                 try:
-                    with llm_call_origin(helper_origin("compression")):
-                        stream_cm = await llm.stream(
-                            messages=messages,
-                            system=system_message,
-                            temperature=temperature,
-                            model=model,
-                            max_completion_tokens=self.SUMMARY_MAX_TOKENS,
-                            thinking=thinking,
-                        )
-                        async with stream_cm as stream:
-                            async for _event in stream:
-                                pass
-                        response = await stream.get_final_message()
+                    response = await _stream_summary(
+                        llm,
+                        messages=messages,
+                        system=system_message,
+                        temperature=temperature,
+                        model=model,
+                        thinking=thinking,
+                    )
                     break
                 except LLMContextWindowExceededError as exc:
                     if max_input_tokens is None:
@@ -297,22 +319,45 @@ class HistoryCompressor:
                 assert last_error is not None
                 raise last_error
 
-            summary_text = response.get_text_content()
-            if not summary_text or not summary_text.strip():
-                msg = "Compression produced an empty summary; history left unchanged."
-                if on_error:
-                    await on_error(msg)
+            last_empty_message = "Compression produced an empty summary; history left unchanged."
+            for attempt in range(1, self.SUMMARY_EMPTY_ATTEMPTS + 1):
+                summary_text = response.get_text_content()
+                if summary_text and summary_text.strip():
+                    folded = split - prior_through
+                    conversation.apply_compaction(summary_text, split)
+                    done = f"Compressed {folded} older message(s) into a summary; kept the latest turns verbatim."
+                    if on_info:
+                        await on_info(done)
+                    return CompactionResult(ok=True, reason="ok", summarized_messages=folded, message=done)
+
+                stop = getattr(response, "stop_reason", None)
+                stop_note = f" (stop_reason={stop})" if stop else ""
+                last_empty_message = f"Compression produced an empty summary{stop_note}; history left unchanged."
+                if attempt >= self.SUMMARY_EMPTY_ATTEMPTS:
+                    break
+                retry_msg = (
+                    f"Compression produced an empty summary{stop_note}; "
+                    f"retrying ({attempt + 1}/{self.SUMMARY_EMPTY_ATTEMPTS})."
+                )
+                if on_info:
+                    await on_info(retry_msg)
                 else:
-                    logger.error(msg)
-                return CompactionResult(ok=False, reason="llm_error", message=msg)
-
-            folded = split - prior_through
-            conversation.apply_compaction(summary_text, split)
+                    logger.info(retry_msg)
+                # Same fitted request: empty completions are not a budget-fit failure.
+                response = await _stream_summary(
+                    llm,
+                    messages=messages,
+                    system=system_message,
+                    temperature=temperature,
+                    model=model,
+                    thinking=thinking,
+                )
 
-            done = f"Compressed {folded} older message(s) into a summary; kept the latest turns verbatim."
-            if on_info:
-                await on_info(done)
-            return CompactionResult(ok=True, reason="ok", summarized_messages=folded, message=done)
+            if on_error:
+                await on_error(last_empty_message)
+            else:
+                logger.error(last_empty_message)
+            return CompactionResult(ok=False, reason="empty_summary", message=last_empty_message)
 
         except Exception as e:
             # Never swallow into a fake success: log the full traceback and surface

{kolega_code-0.29.0 → kolega_code-0.30.1}/kolega_code/agent/tool_backend/agent_tool.py

@@ -399,7 +399,7 @@ class AgentTool(BaseTool):
                 agent.session_recorder = scoped_recorder
 
             # Track messages and their sequence
-            last_saved_index = -1  # Track what we've already saved
+            last_saved_index = -1
             streamed_messages = {}  # Track messages by UUID for assembly
 
             # Process the task and stream messages

{kolega_code-0.29.0 → kolega_code-0.30.1}/kolega_code/agent/tools.py

@@ -302,16 +302,13 @@ class ToolCollection(LogMixin):
         self.workspace_id = workspace_id
         self.thread_id = thread_id
 
-        # Convert string path to Path object if needed
         self.project_path = Path(project_path) if isinstance(project_path, str) else project_path
 
-        # Create filesystem instance if not provided
         if filesystem is None:
             self.filesystem = LocalFileSystem(root_path=self.project_path)
         else:
             self.filesystem = filesystem
 
-        # Create terminal manager instance if not provided
         if terminal_manager is None:
             self.terminal_manager = LocalTerminalManager(
                 workspace_id, thread_id, connection_manager, default_workdir=self.project_path
@@ -319,7 +316,6 @@ class ToolCollection(LogMixin):
         else:
             self.terminal_manager = terminal_manager
 
-        # Create browser manager instance if not provided
         if browser_manager is None:
             self.browser_manager = PlaywrightBrowserManager()
         else:
@@ -388,7 +384,6 @@ class ToolCollection(LogMixin):
         }
         self.tool_exclusions.extend(tool_config.tool_exclusions)
 
-        # Initialize tool backends
         self._initialize_tools()
         self._register_tool_extensions()
 
@@ -619,7 +614,6 @@ class ToolCollection(LogMixin):
             browser_manager=self.browser_manager,
         )
 
-        # Build tool
         self.build_tool = BuildTool(
             self.project_path,
             self.workspace_id,

{kolega_code-0.29.0 → kolega_code-0.30.1}/kolega_code/agent/utils/commands.py

@@ -58,9 +58,9 @@ class CommandProcessor:
                 f"Compressed history: {result.summarized_messages} older message(s) summarized. "
                 f"Context {pct(before)}% → {pct(after)}% of the input budget."
             )
-        if result.reason == "llm_error":
-            return f"Compression failed: {result.message}"
-        return f"Nothing to compress. {result.message} (context {pct(before)}% of the input budget)."
+        if result.reason in ("too_few", "nothing_to_summarize"):
+            return f"Nothing to compress. {result.message} (context {pct(before)}% of the input budget)."
+        return f"Compression failed: {result.message}"
 
     async def _handle_clear(self) -> str:
         """Handle the /clear command."""

{kolega_code-0.29.0 → kolega_code-0.30.1}/kolega_code/cli/config.py

@@ -74,6 +74,7 @@ API_KEY_ENV = {
     ModelProvider.THINKING_MACHINES: "TINKER_API_KEY",
     # Native Tinker sampling authenticates with the same key.
     ModelProvider.TINKER: "TINKER_API_KEY",
+    ModelProvider.PERPLEXITY_AGENT: "PERPLEXITY_API_KEY",
 }
 
 DEFAULT_WEB_SEARCH_BACKEND = "duckduckgo"
@@ -780,13 +781,20 @@ def _resolve_active_thinking_effort(
     settings: Optional[CliSettings],
 ) -> Optional[str]:
     explicit_effort = overrides.thinking_effort or env.get("KOLEGA_CODE_THINKING_EFFORT")
+    saved_effort: Optional[str] = None
     if explicit_effort is None and settings:
         settings_model_matches = settings.active_provider == provider.value and settings.active_model == model
         if settings_model_matches:
-            explicit_effort = settings.active_thinking_effort
+            saved_effort = settings.active_thinking_effort
     try:
-        return normalize_thinking_effort(provider, model, explicit_effort)
+        return normalize_thinking_effort(
+            provider, model, explicit_effort if explicit_effort is not None else saved_effort
+        )
     except ValueError as exc:
+        if saved_effort is not None and explicit_effort is None:
+            # A saved effort can outlive a catalog change; fall back to the default
+            # instead of locking startup. Explicit requests still error.
+            return normalize_thinking_effort(provider, model, None)
         raise CliConfigError(str(exc)) from exc
 
 
@@ -971,6 +979,7 @@ def build_agent_config(
             ollama_cloud_api_key=_api_key_for_provider(ModelProvider.OLLAMA_CLOUD, loaded_env, settings),
             openrouter_api_key=_api_key_for_provider(ModelProvider.OPENROUTER, loaded_env, settings),
             thinking_machines_api_key=_api_key_for_provider(ModelProvider.THINKING_MACHINES, loaded_env, settings),
+            perplexity_api_key=_api_key_for_provider(ModelProvider.PERPLEXITY_AGENT, loaded_env, settings),
             environment=overrides.environment or loaded_env.get("KOLEGA_CODE_ENVIRONMENT", "development"),
             edit_protocol=edit_protocol,
             long_context_config=_model_config(