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

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

@@ -6,6 +6,44 @@ 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

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

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

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

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

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

{kolega_code-0.29.0 → 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
@@ -2488,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.29.0 → 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.29.0 → 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,

{kolega_code-0.29.0 → kolega_code-0.30.0}/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(

{kolega_code-0.29.0 → kolega_code-0.30.0}/kolega_code/cli/main.py

@@ -48,17 +48,24 @@ from kolega_code.hooks import HookDispatcher, HookEvent, load_hook_config
 from kolega_code.llm.exceptions import LLMBillingError, billing_error_message
 from kolega_code.llm.models import Message, TextBlock
 from kolega_code.mcp.config import (
+    _SERVER_ID_MAX_LENGTH,
+    LoadedMCPConfig,
     MCPConfigError,
     MCPServerConfig,
     global_mcp_config_path,
     load_mcp_config,
     project_mcp_config_path,
     remove_server_config,
+    sanitize_mcp_server_id,
     server_fingerprint,
     set_server_enabled,
     upsert_server_config,
 )
-from kolega_code.mcp.service import MCP_FAILURE_MESSAGE_GENERIC, MCPService
+from kolega_code.mcp.service import (
+    MCP_FAILURE_MESSAGE_GENERIC,
+    MCPService,
+    mcp_tool_name_adjustment_note,
+)
 from kolega_code.mcp.tools import build_mcp_tool_extension
 from kolega_code.agent.prompt_provider import AgentMode
 from kolega_code.permissions import (
@@ -1606,6 +1613,8 @@ async def _run_ask(args: argparse.Namespace) -> int:
     )
     if mcp_extension is not None:
         tool_extensions.append(mcp_extension)
+        if mcp_config is not None:
+            _print_mcp_tool_name_warnings(mcp_config, settings_store.root, project_path)
     extension_bundle = None
     if extension_selection is not None:
         extension_host = KolegaExtensionHost(
@@ -2335,6 +2344,8 @@ async def _run_mcp(args: argparse.Namespace) -> int:
         return 0
 
     if args.mcp_command == "verify":
+        if getattr(args, "server_id", None):
+            args.server_id = sanitize_mcp_server_id(args.server_id)
         server_ids = _mcp_verify_server_ids(args, config)
         if not server_ids:
             raise ValueError("No MCP servers to verify.")
@@ -2366,33 +2377,41 @@ async def _run_mcp(args: argparse.Namespace) -> int:
         except MCPConfigError as exc:
             raise ValueError(str(exc)) from exc
         print(f"Saved MCP server {server.id} to {path}")
+        if args.server_id.strip() != server.id:
+            print(
+                f"mcp: server id '{args.server_id}' exceeds {_SERVER_ID_MAX_LENGTH} characters; "
+                f"saved as '{server.id}'.",
+                file=sys.stderr,
+            )
         if source == "project" and not settings.is_mcp_project_trusted(project_path):
             print("Project MCP config is not trusted yet. Re-run with --trust-mcp to enable it.", file=sys.stderr)
         return 0
 
     if args.mcp_command == "remove":
         path, source = _mcp_mutation_target(args, project_path, settings_store.root)
+        server_id = sanitize_mcp_server_id(args.server_id)
         try:
-            removed = remove_server_config(path, args.server_id, source=source)
+            removed = remove_server_config(path, server_id, source=source)
         except MCPConfigError as exc:
             raise ValueError(str(exc)) from exc
         if not removed:
-            raise ValueError(f"MCP server not found in {path}: {args.server_id}")
-        service.status_store.clear(args.server_id)
-        service.oauth_store.clear(args.server_id)
-        print(f"Removed MCP server {args.server_id} from {path}")
+            raise ValueError(f"MCP server not found in {path}: {server_id}")
+        service.status_store.clear(server_id)
+        service.oauth_store.clear(server_id)
+        print(f"Removed MCP server {server_id} from {path}")
         return 0
 
     if args.mcp_command in {"enable", "disable"}:
         path, source = _mcp_mutation_target(args, project_path, settings_store.root)
         enabled = args.mcp_command == "enable"
+        server_id = sanitize_mcp_server_id(args.server_id)
         try:
-            changed = set_server_enabled(path, args.server_id, enabled, source=source)
+            changed = set_server_enabled(path, server_id, enabled, source=source)
         except MCPConfigError as exc:
             raise ValueError(str(exc)) from exc
         if not changed:
-            raise ValueError(f"MCP server not found in {path}: {args.server_id}")
-        print(f"{'Enabled' if enabled else 'Disabled'} MCP server {args.server_id} in {path}")
+            raise ValueError(f"MCP server not found in {path}: {server_id}")
+        print(f"{'Enabled' if enabled else 'Disabled'} MCP server {server_id} in {path}")
         return 0
 
     raise ValueError(f"Unknown mcp command: {args.mcp_command}")
@@ -2411,21 +2430,41 @@ def _print_mcp_list(config, service: MCPService) -> None:
         return
     print("ID\tSOURCE\tTRANSPORT\tENABLED\tOAUTH\tSTATUS\tTOOLS\tMESSAGE")
     for server in config.servers.values():
-        status_text, tool_count, message = _mcp_cli_status_parts(server, service)
+        status_text, tool_count, message, _ = _mcp_cli_status_parts(server, service)
         print(
             f"{server.id}\t{server.source}\t{server.transport}\t{server.enabled}\t{server.oauth.enabled}\t"
             f"{status_text}\t{tool_count}\t{message}"
         )
 
 
-def _mcp_cli_status_parts(server: MCPServerConfig, service: MCPService) -> tuple[str, int, str]:
+def _print_mcp_tool_name_warnings(config: LoadedMCPConfig, state_dir: Path, project_path: Path) -> None:
+    """Warn on stderr when verified MCP tools get provider-adjusted wire names.
+
+    Mirrors the ``mcp: {diagnostic}`` startup output: the model-facing names are
+    sanitized, and silently renaming them would be confusing.
+    """
+    service = MCPService(config, state_dir=state_dir, project_path=project_path)
+    for server in config.enabled_servers:
+        status = service.server_status(server)
+        if not status or status.status != "verified":
+            continue
+        if status.fingerprint != server_fingerprint(server):
+            continue
+        note = mcp_tool_name_adjustment_note(server.id, status.tools)
+        if note:
+            print(f"mcp: warning: server '{server.id}': {note}", file=sys.stderr)
+
+
+def _mcp_cli_status_parts(server: MCPServerConfig, service: MCPService) -> tuple[str, int, str, str]:
     status = service.server_status(server)
     current_fingerprint = server_fingerprint(server)
     verified = bool(status and status.status == "verified" and status.fingerprint == current_fingerprint)
     stale = bool(status and status.fingerprint and status.fingerprint != current_fingerprint)
+    note = ""
     if verified and status:
         status_text = "verified"
         tool_count = status.tool_count
+        note = mcp_tool_name_adjustment_note(server.id, status.tools)
     elif stale:
         status_text = "stale"
         tool_count = 0
@@ -2435,12 +2474,13 @@ def _mcp_cli_status_parts(server: MCPServerConfig, service: MCPService) -> tuple
     else:
         status_text = "unverified"
         tool_count = 0
-    return status_text, tool_count, _mcp_cli_list_message(status_text, tool_count)
+    return status_text, tool_count, _mcp_cli_list_message(status_text, tool_count, note), note
 
 
-def _mcp_cli_list_message(status: str, tool_count: int) -> str:
+def _mcp_cli_list_message(status: str, tool_count: int, note: str = "") -> str:
     if status == "verified":
-        return f"Verified {tool_count} tool(s)."
+        message = f"Verified {tool_count} tool(s)."
+        return f"{message} {note}" if note else message
     if status == "stale":
         return "Configuration changed since last verification. Verify again."
     if status == "failed":
@@ -2586,6 +2626,27 @@ def _run_doctor(args: argparse.Namespace) -> int:
     line("Long model", f"{summary['long_provider']}/{summary['long_model']}")
     line("Fast model", f"{summary['fast_provider']}/{summary['fast_model']}")
     line("Thinking effort", summary["thinking_effort"])
+
+    # MCP servers: offline status from config + local verification state (no network).
+    mcp_config = load_mcp_config(
+        project_path, settings_store.root, project_trusted=settings.is_mcp_project_trusted(project_path)
+    )
+    mcp_service = MCPService(mcp_config, state_dir=settings_store.root, project_path=project_path)
+    for diagnostic in mcp_config.diagnostics:
+        print(f"mcp: {diagnostic}", file=sys.stderr)
+    if not mcp_config.servers:
+        line("MCP servers", "none configured", "muted")
+    for server in mcp_config.servers.values():
+        status_text, tool_count, _, note = _mcp_cli_status_parts(server, mcp_service)
+        status_style = "success" if status_text == "verified" else ("error" if status_text == "failed" else "muted")
+        line(
+            f"MCP {server.id}",
+            f"{server.transport} · {'enabled' if server.enabled else 'disabled'} · {status_text} · "
+            f"{tool_count} tool(s)",
+            status_style,
+        )
+        if note:
+            line(f"MCP {server.id} tool names", f"{note} See `kolega-code mcp list` for detail.", "warning")
     return 0
 
 

{kolega_code-0.29.0 → kolega_code-0.30.0}/kolega_code/cli/model_catalog.py

@@ -23,19 +23,22 @@ from kolega_code.config import ModelProvider
 from kolega_code.llm.specs import MODEL_SPECS, is_featured_model
 from kolega_code.llm.specs import ollama_cloud_catalog as ollama_cloud
 from kolega_code.llm.specs import openrouter_catalog as openrouter
+from kolega_code.llm.specs import perplexity_catalog as perplexity
 from kolega_code.llm.specs import tinker_catalog as tinker
 from kolega_code.llm.specs.validation import validate_model_spec
 
 from .provider_registry import PROVIDER_LABELS, get_ui_model, rebuild_ui_model_options
 from .session_store import default_state_dir
 
-# Overlay sources keyed by provider value. Each module exposes PROVIDER,
+# Overlay sources keyed by provider value. Each entry exposes PROVIDER,
 # MODELS_URL, CACHE_FILENAME, fetch_models(), catalog_entries(), load_cache()
-# and save_cache().
+# and save_cache(). The Perplexity entry is a duck-typed catalog object rather
+# than a module — same contract.
 OVERLAY_SOURCES = {
     ollama_cloud.PROVIDER: ollama_cloud,
     openrouter.PROVIDER: openrouter,
     tinker.PROVIDER: tinker,
+    perplexity.AGENT_PROVIDER: perplexity.AGENT_CATALOG,
 }
 
 # Capture the release snapshot before startup applies any runtime caches.

{kolega_code-0.29.0 → kolega_code-0.30.0}/kolega_code/cli/provider_registry.py

@@ -45,6 +45,7 @@ PROVIDER_LABELS: dict[ModelProvider, str] = {
     ModelProvider.OPENROUTER: "OpenRouter",
     ModelProvider.THINKING_MACHINES: "Thinking Machines",
     ModelProvider.TINKER: "Tinker",
+    ModelProvider.PERPLEXITY_AGENT: "Perplexity Agent API",
 }
 
 # Friendly display names for models. Anything not listed falls back to its raw
@@ -64,6 +65,7 @@ MODEL_LABELS: dict[str, str] = {
     "deepseek-v4-pro": "DeepSeek V4 Pro",
     "deepseek-v4-flash": "DeepSeek V4 Flash",
     # Z.AI (GLM Coding Plan)
+    "glm-5.3": "GLM-5.3",
     "glm-5.2": "GLM-5.2",
     "glm-5.1": "GLM-5.1",
     # Anthropic
@@ -86,11 +88,13 @@ MODEL_LABELS: dict[str, str] = {
     "gpt-5.4-mini": "GPT-5.4 Mini",
     "gpt-5.3-codex-spark": "GPT-5.3 Codex Spark",
     # Google
+    "gemini-3.7-flash": "Gemini 3.7 Flash",
     "gemini-3.6-flash": "Gemini 3.6 Flash",
     "gemini-3.5-flash-lite": "Gemini 3.5 Flash-Lite",
     "gemini-3.1-pro-preview": "Gemini 3.1 Pro",
     "gemini-3.5-flash": "Gemini 3.5 Flash",
     # xAI
+    "grok-4.6": "Grok 4.6",
     "grok-4.5": "Grok 4.5",
     "grok-4.3": "Grok 4.3",
     "grok-build-0.1": "Grok Build 0.1",
@@ -148,12 +152,12 @@ MODEL_LABELS: dict[str, str] = {
 PROVIDER_DEFAULT_MODEL: dict[ModelProvider, str] = {
     ModelProvider.MOONSHOT: "kimi-k3",
     ModelProvider.DEEPSEEK: "deepseek-v4-pro",
-    ModelProvider.ZAI: "glm-5.2",
+    ModelProvider.ZAI: "glm-5.3",
     ModelProvider.KIMI_CODING: "kimi-for-coding",
     ModelProvider.ANTHROPIC: "claude-opus-5",
     ModelProvider.OPENAI: "gpt-5.6-sol",
     ModelProvider.OPENAI_CHATGPT: "gpt-5.6-sol",
-    ModelProvider.GOOGLE: "gemini-3.1-pro-preview",
+    ModelProvider.GOOGLE: "gemini-3.7-flash",
     ModelProvider.XAI: "grok-4.5",
     ModelProvider.FIREWORKS: "accounts/fireworks/models/glm-5p2",
     ModelProvider.TOGETHER: "moonshotai/Kimi-K2.7-Code",
@@ -166,6 +170,7 @@ PROVIDER_DEFAULT_MODEL: dict[ModelProvider, str] = {
     # Cheap and renderable without the optional tinker-inkling extra, so the
     # provider works out of the box for anyone who installs the base extras.
     ModelProvider.TINKER: "Qwen/Qwen3-8B",
+    ModelProvider.PERPLEXITY_AGENT: "openai/gpt-5.6-sol",
 }
 
 UI_DEFAULT_PROVIDER = ModelProvider.MOONSHOT.value
@@ -209,6 +214,8 @@ def _api_key_env(provider: ModelProvider) -> str:
         return "TINKER_API_KEY"
     if provider == ModelProvider.TINKER:
         return "TINKER_API_KEY"
+    if provider == ModelProvider.PERPLEXITY_AGENT:
+        return "PERPLEXITY_API_KEY"
     return f"{provider.value.upper()}_API_KEY"
 
 

{kolega_code-0.29.0 → kolega_code-0.30.0}/kolega_code/cli/slash_commands.py

@@ -52,7 +52,7 @@ TUI_COMMAND_ENTRIES: tuple[SlashCommandEntry, ...] = (
     ),
     SlashCommandEntry("detach", "Remove pending image attachments", CommandScope.TUI),
     SlashCommandEntry("init", "Create or update AGENTS.md for this repository", CommandScope.TUI),
-    SlashCommandEntry("plan", "Switch to plan mode", CommandScope.TUI),
+    SlashCommandEntry("plan", "Switch to plan mode, optionally with a planning prompt", CommandScope.TUI),
     SlashCommandEntry("build", "Switch to build mode", CommandScope.TUI),
     SlashCommandEntry("sidebar", "Show or hide the side panel", CommandScope.TUI),
     SlashCommandEntry("settings", "Open Settings", CommandScope.TUI),

{kolega_code-0.29.0 → kolega_code-0.30.0}/kolega_code/cli/theme.py

@@ -36,24 +36,24 @@ class Color:
 class Glyph:
     """Unicode glyphs used in the UI. Use g() to apply ASCII fallbacks."""
 
-    USER = "❯"  # ❯
-    AGENT = "●"  # ●
-    STATUS = "●"  # ●
-    TOOL = "⏺"  # ⏺
-    SUB_AGENT = "◆"  # ◆
-    PLAN = "◆"  # ◆
+    USER = "❯"
+    AGENT = "●"
+    STATUS = "●"
+    TOOL = "⏺"
+    SUB_AGENT = "◆"
+    PLAN = "◆"
     QUESTION = "?"
-    INSET_BAR = "│"  # │
-    INSET_ELBOW = "└"  # └
-    ELLIPSIS = "…"  # …
-    BULLET_SEP = "·"  # ·
-    BAR_FILLED = "█"  # █
-    BAR_EMPTY = "░"  # ░
-    CHECK = "✓"  # ✓
-    CROSS = "✗"  # ✗
-    DOWN = "↓"  # ↓
-    PENDING = "○"  # ○ — phase not started
-    RUNNING = "▶"  # ▶ — phase in progress
+    INSET_BAR = "│"
+    INSET_ELBOW = "└"
+    ELLIPSIS = "…"
+    BULLET_SEP = "·"
+    BAR_FILLED = "█"
+    BAR_EMPTY = "░"
+    CHECK = "✓"
+    CROSS = "✗"
+    DOWN = "↓"
+    PENDING = "○"  # phase not started
+    RUNNING = "▶"  # phase in progress
 
 
 ASCII_FALLBACKS = {
@@ -74,7 +74,7 @@ ASCII_FALLBACKS = {
     Glyph.RUNNING: ">",
 }
 
-SPINNER_FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"  # ⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏
+SPINNER_FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
 SPINNER_FRAMES_ASCII = "|/-\\"
 SPINNER_INTERVAL = 0.25
 

{kolega_code-0.29.0 → kolega_code-0.30.0}/kolega_code/cli/tui/agent_runtime.py

@@ -34,6 +34,8 @@ from kolega_code.agent.prompts import (
 from kolega_code.hooks import HookDispatcher, HookEvent, load_hook_config, project_hooks_present
 from kolega_code.scratchpad import SCRATCHPAD_PROMPT_EXTENSION_ID, ensure_scratchpad_dir, scratchpad_dir_for
 from kolega_code.llm.exceptions import LLMError, llm_error_message
+from kolega_code.mcp.config import LoadedMCPConfig, server_fingerprint
+from kolega_code.mcp.service import MCPService, mcp_tool_name_adjustment_note
 from kolega_code.mcp.tools import build_mcp_tool_extension
 from kolega_code.permissions import PermissionDecision
 from kolega_code.session.runtime import deserialize_permission_request
@@ -966,6 +968,23 @@ class AgentRuntimeMixin(tui_app_base.KolegaAppBase):
         if self._scheduled_loop is not None and self._scheduled_loop.is_active:
             self._request_loop_stop(messages.LOOP_STOPPED_BY_USER.format(iterations=self._scheduled_loop.iterations))
 
+    def _log_mcp_tool_name_warnings(self, mcp_config: LoadedMCPConfig) -> None:
+        """Warn in the log pane when verified MCP tools get provider-adjusted wire names.
+
+        Mirrors the ``mcp: {diagnostic}`` startup warnings: the model-facing names
+        are sanitized, and silently renaming them would be confusing.
+        """
+        service = MCPService(mcp_config, state_dir=self.settings_store.root, project_path=self.active_project_path)
+        for server in mcp_config.enabled_servers:
+            status = service.server_status(server)
+            if not status or status.status != "verified":
+                continue
+            if status.fingerprint != server_fingerprint(server):
+                continue
+            note = mcp_tool_name_adjustment_note(server.id, status.tools)
+            if note:
+                self._log_status(f"mcp: warning: server '{server.id}': {note}", level="warn")
+
     async def _ensure_agent_from_settings(self, rebuild: bool = False) -> None:
         try:
             config = build_agent_config(
@@ -1186,6 +1205,8 @@ class AgentRuntimeMixin(tui_app_base.KolegaAppBase):
         )
         if mcp_extension is not None:
             tool_extensions.append(mcp_extension)
+            if mcp_config is not None and self.active_project_path == self.project_path:
+                self._log_mcp_tool_name_warnings(mcp_config)
 
         # gigacode applies to any top-level agent and is carried across rebuilds.
         # In plan mode the orchestrating agent is read-only, so its workflow