kolega-code 0.28.4__tar.gz → 0.30.0__tar.gz

{kolega_code-0.28.4 → kolega_code-0.30.0}/CHANGELOG.md

@@ -6,6 +6,68 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 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
+
+- Custom endpoints: use models from any OpenAI Chat Completions, OpenAI
+  Responses, or Anthropic Messages-compatible server (LM Studio, Ollama, vLLM,
+  ...). Define endpoints under `custom_endpoints` in settings.json or via the
+  `--custom-endpoints` / `--endpoint-url` flags and `KOLEGA_CODE_CUSTOM_ENDPOINTS`
+  / `KOLEGA_CODE_ENDPOINT_*` environment variables (never persisted), then select
+  them as `custom:<id>` anywhere a provider is chosen. Supports thinking-effort
+  modes per wire dialect and native reasoning replay.
+
+- Custom endpoints accept a `temperature` field (per endpoint, or per model in
+  its `models` map; default 1.0), exposed in the TUI endpoint editor, via
+  `--endpoint-temperature`, and via `KOLEGA_CODE_ENDPOINT_TEMPERATURE`. Sent on
+  Chat Completions and Anthropic requests; ignored by Responses-style endpoints.
+
+### Fixed
+
+- Together models (e.g. Kimi K2.7-Code) now replay prior reasoning through the
+  native `reasoning` field instead of visible `*Thinking:*` text, avoiding a full
+  re-derivation of the chain-of-thought on every turn. Reasoning models without a
+  declared thinking-effort spec now resolve their provider's replay field.
+
 ## 0.28.4 - 2026-08-12
 
 ### Fixed

{kolega_code-0.28.4 → kolega_code-0.30.0}/PKG-INFO

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

@@ -22,7 +22,7 @@ from .agent.errors import AgentError, MaxAgentIterationsExceeded
 from .events import AgentEventEmitter
 
 # Configuration
-from .config import AgentConfig, ModelConfig, ModelProvider, RateLimitConfig
+from .config import AgentConfig, CustomEndpointConfig, ModelConfig, ModelProvider, RateLimitConfig
 
 # Events and connection management
 from .events import AgentConnectionManager
@@ -108,6 +108,7 @@ __all__ = [
     "AgentEventEmitter",
     # Configuration
     "AgentConfig",
+    "CustomEndpointConfig",
     "ModelConfig",
     "ModelProvider",
     "RateLimitConfig",
@@ -173,4 +174,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.28.4"
+__version__ = "0.30.0"

{kolega_code-0.28.4 → kolega_code-0.30.0}/kolega_code/agent/__init__.py

@@ -51,4 +51,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.28.4"
+__version__ = "0.30.0"

{kolega_code-0.28.4 → kolega_code-0.30.0}/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
@@ -1741,6 +1764,7 @@ class BaseAgent(LogMixin):
 
         from kolega_code.llm.client import LLMClient
 
+        endpoint = self.config.custom_endpoint_for(model_config)
         client = LLMClient(
             provider=model_config.provider.value,
             api_key=self.config.get_api_key(model_config.provider) or "",
@@ -1751,6 +1775,8 @@ class BaseAgent(LogMixin):
             token_manager=self.config.get_chatgpt_token_manager(),
             usage_ledger=self.usage_ledger,
             trace_sink=self.llm_trace_sink,
+            base_url=endpoint.base_url if endpoint else None,
+            api_style=endpoint.api_style if endpoint else None,
         )
         with llm_call_origin(helper_origin("hook_prompt")):
             response = await client.generate(
@@ -2485,6 +2511,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.28.4 → kolega_code-0.30.0}/kolega_code/agent/context.py

@@ -113,6 +113,7 @@ class AgentContext:
         itself is still passed per call.
         """
         model_config = self.config.model_config_for_agent(agent_name)
+        endpoint = self.config.custom_endpoint_for(model_config)
 
         if self.telemetry.langfuse_client:
             return InstrumentedLLMClient(
@@ -135,6 +136,8 @@ class AgentContext:
                 trace_sink=self.telemetry.llm_trace_sink,
                 context_window_tokens=self.config.context_window_tokens,
                 max_output_tokens=self.config.max_output_tokens,
+                base_url=endpoint.base_url if endpoint else None,
+                api_style=endpoint.api_style if endpoint else None,
             )
 
         return LLMClient(
@@ -149,4 +152,6 @@ class AgentContext:
             trace_sink=self.telemetry.llm_trace_sink,
             context_window_tokens=self.config.context_window_tokens,
             max_output_tokens=self.config.max_output_tokens,
+            base_url=endpoint.base_url if endpoint else None,
+            api_style=endpoint.api_style if endpoint else None,
         )

{kolega_code-0.28.4 → kolega_code-0.30.0}/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.28.4 → kolega_code-0.30.0}/kolega_code/agent/tool_backend/terminal_tool.py

@@ -97,6 +97,7 @@ class TerminalTool(BaseTool):
         provider = self.config.fast_config.provider
         api_key = self.config.get_api_key(provider)
         rate_limits = self.config.fast_config.rate_limits
+        endpoint = self.config.custom_endpoint_for(self.config.fast_config)
 
         client = LLMClient(
             provider=provider.value,
@@ -108,6 +109,8 @@ class TerminalTool(BaseTool):
             token_manager=self.config.get_chatgpt_token_manager(),
             usage_ledger=getattr(self.caller, "usage_ledger", None),
             trace_sink=getattr(self.caller, "llm_trace_sink", None),
+            base_url=endpoint.base_url if endpoint else None,
+            api_style=endpoint.api_style if endpoint else None,
         )
 
         try:

{kolega_code-0.28.4 → kolega_code-0.30.0}/kolega_code/agent/tool_backend/web_fetch_tool.py

@@ -146,6 +146,7 @@ class WebFetchTool(StreamingTool):
     def _build_client(self) -> LLMClient:
         provider = self.config.fast_config.provider
         rate_limits = self.config.fast_config.rate_limits
+        endpoint = self.config.custom_endpoint_for(self.config.fast_config)
         client_kwargs = {
             "provider": provider.value,
             "api_key": self.config.get_api_key(provider),
@@ -156,6 +157,8 @@ class WebFetchTool(StreamingTool):
             "token_manager": self.config.get_chatgpt_token_manager(),
             "usage_ledger": getattr(self.caller, "usage_ledger", None),
             "trace_sink": getattr(self.caller, "llm_trace_sink", None),
+            "base_url": endpoint.base_url if endpoint else None,
+            "api_style": endpoint.api_style if endpoint else None,
         }
         caller_llm = getattr(self.caller, "llm", None)
         if isinstance(caller_llm, InstrumentedLLMClient):

{kolega_code-0.28.4 → kolega_code-0.30.0}/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,