kolega-code 0.26.8__tar.gz → 0.26.9__tar.gz

{kolega_code-0.26.8 → kolega_code-0.26.9}/CHANGELOG.md

@@ -6,6 +6,56 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 0.26.9 - 2026-08-03
+
+### Added
+
+- Settings → Model & Account gains a **Model Slots** section for pinning the fast
+  and thinking models, each with its own provider. Previously these slots were
+  reachable only through CLI flags and environment variables, so in the TUI they
+  silently inherited the active model — every `web_fetch` answering call ran on
+  the main coding model. Slots still inherit by default, and each row now shows
+  which model it currently resolves to.
+- The README now includes a direct invitation to the Kolega Code Discord
+  community.
+
+### Changed
+
+- Settings gains a **Providers** category, first in the rail, holding every model
+  provider's API key and the ChatGPT sign-in, each row labelled with its live
+  credential status. **Model & Account** is renamed **Models** and keeps only what
+  runs. Keys now stage per provider, so credentials for a provider you are not
+  currently using — needed by a fast/thinking slot or an agent-role override — can be
+  entered without switching your main model and switching back. **Test Connection**
+  moves with them and probes the selected provider rather than the active model, so a
+  credential can be checked without running on that provider.
+- **Breaking:** provider and model are now always specified together. `--provider`
+  without `--model` (and the per-role/per-slot equivalents such as
+  `KOLEGA_CODE_FAST_PROVIDER`) is an error instead of silently selecting that
+  provider's default model, and a model named without a provider is rejected rather
+  than assumed to be Anthropic's. Scripts passing only one of the pair need updating;
+  the error names the missing flag. Saved settings are unaffected — the Settings UI
+  always writes both — and a saved model that later leaves the catalog still degrades
+  to the provider's default rather than blocking startup.
+
+### Fixed
+
+- `deepseek-v4-flash` no longer has its reasoning truncated mid-derivation. The
+  64000-token output cap added in 0.26.8 was measured on the chat API for
+  `deepseek-v4-pro` and applied to flash by assumption; flash actually runs to
+  at least 112990 output tokens in a single Responses call. Hard tasks that
+  reason for a long time before acting were cut off at the cap and produced no
+  tool call at all. flash now uses its full published output budget, while pro
+  and the fireworks/openrouter DeepSeek routes keep the 64000 cap where their
+  measured ceilings apply.
+
+### Removed
+
+- The unreachable `DEFAULT_LONG_MODEL`, `DEFAULT_FAST_MODEL`, `DEFAULT_THINKING_MODEL`
+  and their provider constants. No model was ever resolved through them — an unset
+  slot inherits the active model — but they were documented as defaults, which is
+  where "what is my fast model?" became unanswerable.
+
 ## 0.26.8 - 2026-08-03
 
 ### Added

{kolega_code-0.26.8 → kolega_code-0.26.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.26.8
+Version: 0.26.9
 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/
@@ -494,6 +494,7 @@ Full documentation lives at **[kolega-ai.github.io/kolega-code](https://kolega-a
 - [Contributing](CONTRIBUTING.md)
 - [Security policy](SECURITY.md)
 - [Issue tracker](https://github.com/kolega-ai/kolega-code/issues)
+- [Discord community](https://discord.gg/kaS8PKKp4)
 
 ## Contributing
 
@@ -504,3 +505,13 @@ privately per [SECURITY.md](SECURITY.md).
 ## License
 
 Released under the [Apache License 2.0](LICENSE).
+
+## Join the community
+
+Building something with Kolega Code, hit a rough edge, or want to shape where
+Gigacode goes next? Come talk to us.
+
+[![Join our Discord](https://img.shields.io/badge/Discord-join%20the%20community-5865F2?logo=discord&logoColor=white)](https://discord.gg/kaS8PKKp4)
+
+**→ [Join the Kolega Code Discord](https://discord.gg/kaS8PKKp4)** — share workflows,
+get help, and hear about releases first.

{kolega_code-0.26.8 → kolega_code-0.26.9}/README.md

@@ -215,6 +215,7 @@ Full documentation lives at **[kolega-ai.github.io/kolega-code](https://kolega-a
 - [Contributing](CONTRIBUTING.md)
 - [Security policy](SECURITY.md)
 - [Issue tracker](https://github.com/kolega-ai/kolega-code/issues)
+- [Discord community](https://discord.gg/kaS8PKKp4)
 
 ## Contributing
 
@@ -225,3 +226,13 @@ privately per [SECURITY.md](SECURITY.md).
 ## License
 
 Released under the [Apache License 2.0](LICENSE).
+
+## Join the community
+
+Building something with Kolega Code, hit a rough edge, or want to shape where
+Gigacode goes next? Come talk to us.
+
+[![Join our Discord](https://img.shields.io/badge/Discord-join%20the%20community-5865F2?logo=discord&logoColor=white)](https://discord.gg/kaS8PKKp4)
+
+**→ [Join the Kolega Code Discord](https://discord.gg/kaS8PKKp4)** — share workflows,
+get help, and hear about releases first.

{kolega_code-0.26.8 → kolega_code-0.26.9}/kolega_code/__init__.py

@@ -151,4 +151,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.26.8"
+__version__ = "0.26.9"

{kolega_code-0.26.8 → kolega_code-0.26.9}/kolega_code/agent/__init__.py

@@ -51,4 +51,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.26.8"
+__version__ = "0.26.9"

{kolega_code-0.26.8 → kolega_code-0.26.9}/kolega_code/cli/app.py

@@ -1101,16 +1101,16 @@ class KolegaCodeApp(
         if event.button.id == "save_settings":
             await self._save_settings_from_ui()
             return
-        if event.button.id == "settings_chatgpt_login":
+        if event.button.id == "provider_chatgpt_login":
             await self._settings_login_chatgpt()
             return
-        if event.button.id == "settings_chatgpt_logout":
+        if event.button.id == "provider_chatgpt_logout":
             self._settings_logout_chatgpt()
             return
-        if event.button.id == "settings_remove_api_key":
+        if event.button.id == "provider_remove_api_key":
             self._settings_remove_api_key()
             return
-        if event.button.id == "settings_test_connection":
+        if event.button.id == "provider_test_connection":
             await self._test_settings_connection()
             return
         if event.button.id and event.button.id.startswith("mcp_"):

{kolega_code-0.26.8 → kolega_code-0.26.9}/kolega_code/cli/config.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import os
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Mapping, Optional
+from typing import Mapping, NoReturn, Optional
 
 from pydantic import ValidationError
 
@@ -21,12 +21,9 @@ from .settings import CliSettings, SettingsStore
 # Providers authenticated by an OAuth sign-in instead of a static API key.
 OAUTH_PROVIDERS = frozenset({ModelProvider.OPENAI_CHATGPT})
 
-DEFAULT_LONG_PROVIDER = ModelProvider.ANTHROPIC
-DEFAULT_LONG_MODEL = "claude-opus-5"
-DEFAULT_FAST_PROVIDER = ModelProvider.ANTHROPIC
-DEFAULT_FAST_MODEL = "claude-haiku-4-5-20251001"
-DEFAULT_THINKING_PROVIDER = ModelProvider.ANTHROPIC
-DEFAULT_THINKING_MODEL = "claude-opus-5"
+# No built-in provider or model defaults by design. A model must be named together with
+# its provider (see _require_provider_for_model), and an unset operational slot inherits
+# the active model rather than pinning itself to any particular model.
 DEPRECATED_THINKING_TOKENS_MESSAGE = (
     "Thinking token budgets have been replaced by model-specific named effort. "
     "Use --thinking-effort or KOLEGA_CODE_THINKING_EFFORT."
@@ -120,6 +117,34 @@ def _model_sources(model: str) -> list[str]:
     return sorted(provider for provider, candidate in MODEL_SPECS if candidate == model)
 
 
+def _require_provider_for_model(model: str, model_source: Optional[str], provider_names: str) -> NoReturn:
+    """Reject a model named without a provider.
+
+    Nothing is guessed here. The same model id can be served by several providers on
+    different credentials (e.g. an OpenAI id reachable both by API key and by ChatGPT
+    subscription), so picking one for the user would silently choose an account.
+    """
+    label = f"{model_source}={model}" if model_source else f"Model '{model}'"
+    sources = _model_sources(model)
+    hint = (
+        f" It is offered by: {', '.join(sources)}."
+        if sources
+        else f" Valid providers: {', '.join(provider.value for provider in ModelProvider)}."
+    )
+    raise CliConfigError(f"{label} also needs a provider; set {provider_names}.{hint}")
+
+
+def _require_model_for_provider(provider: str, provider_source: Optional[str], model_names: str) -> NoReturn:
+    """Reject a provider named without a model.
+
+    Provider and model are always specified together: there is no house default model
+    to fall back on, and picking one from the catalog would pin a choice the user did
+    not make.
+    """
+    label = f"{provider_source}={provider}" if provider_source else f"Provider '{provider}'"
+    raise CliConfigError(f"{label} also needs a model; set {model_names}.")
+
+
 def _ensure_explicit_model_supported(
     provider: ModelProvider,
     model: str,
@@ -227,16 +252,19 @@ def _active_provider_model(
     model_value, model_source = _explicit_value(overrides.model, env, "KOLEGA_CODE_MODEL", "--model")
 
     if provider_value or model_value:
-        provider = _provider(provider_value or DEFAULT_LONG_PROVIDER.value)
-        if model_value:
-            _ensure_explicit_model_supported(
-                provider,
-                model_value,
-                model_source=model_source,
-                provider_source=provider_source,
-            )
-            return provider, model_value
-        return provider, default_model_for_provider(provider)
+        if not provider_value:
+            assert model_value is not None
+            _require_provider_for_model(model_value, model_source, "--provider or KOLEGA_CODE_PROVIDER")
+        if not model_value:
+            _require_model_for_provider(provider_value, provider_source, "--model or KOLEGA_CODE_MODEL")
+        provider = _provider(provider_value)
+        _ensure_explicit_model_supported(
+            provider,
+            model_value,
+            model_source=model_source,
+            provider_source=provider_source,
+        )
+        return provider, model_value
 
     if settings and settings.active_provider and settings.active_model:
         try:
@@ -254,42 +282,56 @@ def _slot_provider_model(
     model_env_key: str,
     provider_override: Optional[str],
     model_override: Optional[str],
-    default_provider: ModelProvider,
-    default_model: str,
-    active_provider: Optional[ModelProvider],
-    active_model: Optional[str],
+    active_provider: ModelProvider,
+    active_model: str,
+    saved: Optional[Mapping[str, str]] = None,
 ) -> tuple[ModelProvider, str]:
-    provider_value, provider_source = _explicit_value(
-        provider_override,
-        env,
-        provider_env_key,
-        f"--{provider_env_key.removeprefix('KOLEGA_CODE_').lower().replace('_', '-')}",
-    )
-    model_value, model_source = _explicit_value(
-        model_override,
-        env,
-        model_env_key,
-        f"--{model_env_key.removeprefix('KOLEGA_CODE_').lower().replace('_', '-')}",
-    )
+    """Resolve one operational slot: CLI flag > env var > saved slot > active model.
 
-    if provider_value or model_value:
-        provider = _provider(provider_value or (active_provider.value if active_provider else default_provider.value))
-        if model_value:
-            _ensure_explicit_model_supported(
-                provider,
-                model_value,
-                model_source=model_source,
-                provider_source=provider_source,
-            )
-            return provider, model_value
-        return provider, active_model if active_provider == provider and active_model else default_model_for_provider(
-            provider
+    ``saved`` is a persisted ``{provider, model}`` override from Settings, always
+    carrying both fields (``CliSettings`` drops half-written entries). Provider and
+    model must be given together here too, so a flag/env that names only one of them
+    is an error rather than a silent pick.
+
+    Only explicit values are validated against the catalog: a *saved* model that has
+    since left the catalog degrades to the provider's default rather than locking the
+    user out of Settings.
+
+    There is no built-in per-slot default: an unset slot inherits the active model, and
+    ``build_agent_config`` raises ``MISSING_MODEL_SELECTION_MESSAGE`` before calling this
+    when no active model is configured, so ``active_provider``/``active_model`` are always
+    present here.
+    """
+    provider_flag = f"--{provider_env_key.removeprefix('KOLEGA_CODE_').lower().replace('_', '-')}"
+    model_flag = f"--{model_env_key.removeprefix('KOLEGA_CODE_').lower().replace('_', '-')}"
+    provider_value, provider_source = _explicit_value(provider_override, env, provider_env_key, provider_flag)
+    model_value, model_source = _explicit_value(model_override, env, model_env_key, model_flag)
+
+    if provider_value and not model_value:
+        _require_model_for_provider(provider_value, provider_source, f"{model_flag} or {model_env_key}")
+    if model_value and not provider_value:
+        _require_provider_for_model(model_value, model_source, f"{provider_flag} or {provider_env_key}")
+
+    if provider_value:
+        assert model_value is not None
+        provider = _provider(provider_value)
+        _ensure_explicit_model_supported(
+            provider,
+            model_value,
+            model_source=model_source,
+            provider_source=provider_source,
         )
+        return provider, model_value
 
-    if active_provider and active_model:
-        return active_provider, active_model
+    saved = saved or {}
+    saved_provider, saved_model = saved.get("provider"), saved.get("model")
+    if saved_provider and saved_model:
+        provider = _provider(saved_provider)
+        if (provider.value, saved_model) not in MODEL_SPECS:
+            saved_model = default_model_for_provider(provider)
+        return provider, saved_model
 
-    return default_provider, default_model
+    return active_provider, active_model
 
 
 def _model_config(provider: ModelProvider, model: str, thinking_effort: Optional[str] = None) -> ModelConfig:
@@ -339,14 +381,15 @@ def _agent_role_env_keys(role: AgentRole) -> tuple[str, str, str]:
 def _agent_model_overrides(
     env: Mapping[str, str],
     settings: Optional[CliSettings],
-    active_provider: ModelProvider,
-    active_model: str,
 ) -> dict[str, ModelConfig]:
     """Resolve per-agent-role model overrides from env vars over saved settings.
 
-    A role with neither an env nor a settings provider/model is omitted, so it
-    inherits the active model. Field-level precedence is env > settings, mirroring
-    the per-slot resolution used for long/fast/thinking.
+    A role with neither an env nor a settings provider/model is omitted, so it inherits
+    the active model. Provider and model are specified together, exactly as for the
+    operational slots: an env var naming only one of them is an error rather than a
+    silent pick. Saved entries always carry both (``CliSettings`` drops half-written
+    ones), and a saved model that has left the catalog degrades to the provider default
+    instead of locking the user out of Settings.
     """
     saved = settings.agent_models if settings else {}
     overrides: dict[str, ModelConfig] = {}
@@ -355,31 +398,29 @@ def _agent_model_overrides(
         entry = saved.get(role.value) or {}
         provider_env_value = env.get(provider_key)
         model_env_value = env.get(model_key)
-        effort_env_value = env.get(effort_key)
+        effort_value = env.get(effort_key) or entry.get("thinking_effort")
+
+        if provider_env_value and not model_env_value and not entry.get("model"):
+            _require_model_for_provider(provider_env_value, provider_key, model_key)
+        if model_env_value and not provider_env_value and not entry.get("provider"):
+            _require_provider_for_model(model_env_value, model_key, provider_key)
+
         provider_value = provider_env_value or entry.get("provider")
         model_value = model_env_value or entry.get("model")
-        effort_value = effort_env_value or entry.get("thinking_effort")
-
-        if not provider_value and not model_value:
+        if not provider_value or not model_value:
             continue
 
-        provider = _provider(provider_value or active_provider.value)
-        if model_value:
-            if model_env_value:
-                _ensure_explicit_model_supported(
-                    provider,
-                    model_value,
-                    model_source=model_key,
-                    provider_source=provider_key if provider_env_value else None,
-                )
-            elif (provider.value, model_value) not in MODEL_SPECS:
-                model_value = default_model_for_provider(provider)
-            model = model_value
-        elif active_provider == provider and active_model:
-            model = active_model
-        else:
-            model = default_model_for_provider(provider)
-        overrides[role.value] = _model_config(provider, model, thinking_effort=effort_value)
+        provider = _provider(provider_value)
+        if model_env_value:
+            _ensure_explicit_model_supported(
+                provider,
+                model_value,
+                model_source=model_key,
+                provider_source=provider_key if provider_env_value else None,
+            )
+        elif (provider.value, model_value) not in MODEL_SPECS:
+            model_value = default_model_for_provider(provider)
+        overrides[role.value] = _model_config(provider, model_value, thinking_effort=effort_value)
     return overrides
 
 
@@ -411,8 +452,6 @@ def build_agent_config(
         "KOLEGA_CODE_MODEL",
         overrides.provider,
         overrides.model,
-        DEFAULT_LONG_PROVIDER,
-        DEFAULT_LONG_MODEL,
         active_provider,
         active_model,
     )
@@ -422,10 +461,9 @@ def build_agent_config(
         "KOLEGA_CODE_FAST_MODEL",
         overrides.fast_provider,
         overrides.fast_model,
-        DEFAULT_FAST_PROVIDER,
-        DEFAULT_FAST_MODEL,
         active_provider,
         active_model,
+        settings.model_slots.get("fast") if settings else None,
     )
     thinking_provider, thinking_model = _slot_provider_model(
         loaded_env,
@@ -433,10 +471,9 @@ def build_agent_config(
         "KOLEGA_CODE_THINKING_MODEL",
         overrides.thinking_provider,
         overrides.thinking_model,
-        DEFAULT_THINKING_PROVIDER,
-        DEFAULT_THINKING_MODEL,
         active_provider,
         active_model,
+        settings.model_slots.get("thinking") if settings else None,
     )
     active_thinking_effort = _resolve_active_thinking_effort(
         long_provider,
@@ -449,7 +486,7 @@ def build_agent_config(
         active_thinking_effort if thinking_provider == long_provider and thinking_model == long_model else None
     )
 
-    agent_model_overrides = _agent_model_overrides(loaded_env, settings, active_provider, active_model)
+    agent_model_overrides = _agent_model_overrides(loaded_env, settings)
     web_search_backend, web_search_api_key, web_search_base_url = _search_config(loaded_env, settings)
     state_dir = settings_store.root if settings_store is not None else SettingsStore().root
     mcp_config = load_mcp_config(
@@ -547,6 +584,24 @@ def key_status(provider: str, project_path: Path, settings: Optional[CliSettings
     return "missing"
 
 
+def resolved_api_key(provider: str, project_path: Path, settings: Optional[CliSettings] = None) -> Optional[str]:
+    """The API key a provider would actually use: env var first, then stored settings.
+
+    The value counterpart to ``key_status``, which reports the same precedence in words.
+    """
+    return _api_key_for_provider(_provider(provider), load_cli_env(project_path), settings)
+
+
+def probe_token_manager(settings: Optional[CliSettings]) -> Optional[ChatGPTTokenManager]:
+    """A ChatGPT token manager for credential probes, deliberately non-persisting.
+
+    A probe runs against an unapplied Settings draft, so a token refresh triggered by it
+    must not write back to settings.json the way the session's own manager does.
+    """
+    tokens = _resolve_chatgpt_tokens(settings)
+    return ChatGPTTokenManager(tokens) if tokens is not None else None
+
+
 def active_model_override_message(
     config: AgentConfig,
     project_path: Path,

{kolega_code-0.26.8 → kolega_code-0.26.9}/kolega_code/cli/messages.py

@@ -249,6 +249,24 @@ BROWSER_MODEL_EXPLICIT_NO_VISION = (
 BROWSER_MODEL_PROVIDER_NO_VISION = (
     "Provider {provider} has no vision-capable Browser models. Choose another provider or Default (inherit)."
 )
+PROVIDERS_HINT = (
+    "Credentials for model providers. Select one to add, replace, or remove its key. "
+    "What actually runs is chosen under Models."
+)
+MODEL_CREDENTIAL_POINTER = "API keys and ChatGPT sign-in live under Providers."
+PROVIDER_CREDENTIAL_STATUS = "Credential status: {status}"
+PROVIDER_KEY_STAGED = "Key will be saved for {provider} when you Apply."
+PROVIDER_KEY_NOT_STORED = (
+    "There is no locally stored key for this provider. Environment credentials are not changed here."
+)
+PROVIDER_KEY_REMOVAL_STAGED = "The locally stored API key will be removed when you Apply."
+PROVIDER_TEST_RUNNING = "Testing {provider}/{model}…"
+MODEL_SLOT_INHERITED = "Using {provider}/{model} (inherited from the active model)."
+MODEL_SLOT_PINNED = "Using {provider}/{model}."
+MODEL_SLOT_HINT = (
+    "Utility slots used outside the main conversation. Default inherits the active model; "
+    "a slot may use a different provider, which needs that provider's API key."
+)
 
 # Status dashboard
 STATUS_TOKENS_UNKNOWN = "Token counts unavailable."

{kolega_code-0.26.8 → kolega_code-0.26.9}/kolega_code/cli/model_connection.py

@@ -4,9 +4,9 @@ from __future__ import annotations
 
 import asyncio
 from dataclasses import dataclass
-from typing import Any, Callable
+from typing import Any, Callable, Optional
 
-from kolega_code.config import AgentConfig
+from kolega_code.config import ModelProvider, RateLimitConfig
 from kolega_code.llm.client import LLMClient
 from kolega_code.llm.exceptions import LLMError, llm_error_message
 from kolega_code.llm.ledger import helper_origin, llm_call_origin
@@ -34,27 +34,35 @@ async def _probe_generate(client: Any, model: str, messages: MessageHistory) ->
 
 
 async def test_model_connection(
-    config: AgentConfig,
+    provider: ModelProvider,
+    model: str,
     *,
+    api_key: str = "",
+    token_manager: Any = None,
+    rate_limits: Optional[RateLimitConfig] = None,
     client_factory: Callable[..., Any] = LLMClient,
     timeout: float = CONNECTION_TEST_TIMEOUT_SECONDS,
     usage_ledger: Any = None,
 ) -> ModelConnectionResult:
-    """Send a tiny no-tool prompt through the selected model.
+    """Send a tiny no-tool prompt through one provider/model pair.
 
     This is intentionally opt-in: providers do not expose one uniform, free auth
     endpoint, so a real generation is the only dependable cross-provider probe.
+
+    The target is passed in rather than read off an ``AgentConfig`` so a credential can
+    be probed on its own — the Providers screen tests a key for a provider that may not
+    be in use, and must keep working when the rest of the model configuration is broken.
     """
 
-    model_config = config.long_context_config
+    limits = rate_limits or RateLimitConfig()
     try:
         factory_kwargs: dict[str, Any] = {
-            "provider": model_config.provider,
-            "api_key": config.get_api_key(model_config.provider) or "",
+            "provider": provider,
+            "api_key": api_key,
             "max_retries": 0,
-            "requests_per_minute": model_config.rate_limits.requests_per_minute,
-            "tokens_per_minute": model_config.rate_limits.tokens_per_minute,
-            "token_manager": config.get_chatgpt_token_manager(),
+            "requests_per_minute": limits.requests_per_minute,
+            "tokens_per_minute": limits.tokens_per_minute,
+            "token_manager": token_manager,
         }
         # The probe is a real paid request; account for it when the host has a
         # ledger. Omitted when None so injected fake factories keep their shape.
@@ -63,18 +71,15 @@ async def test_model_connection(
         client = client_factory(**factory_kwargs)
         messages = MessageHistory([Message(role="user", content=[TextBlock(text="Reply with OK.")])])
         await asyncio.wait_for(
-            _probe_generate(client, model_config.model, messages),
+            _probe_generate(client, model, messages),
             timeout=timeout,
         )
     except asyncio.TimeoutError:
         return ModelConnectionResult(False, f"Connection test timed out after {timeout:g} seconds.")
     except LLMError as exc:
-        return ModelConnectionResult(False, llm_error_message(exc, model=model_config.model))
+        return ModelConnectionResult(False, llm_error_message(exc, model=model))
     except Exception:
         return ModelConnectionResult(
             False, "The connection test failed unexpectedly. Check the provider and try again."
         )
-    return ModelConnectionResult(
-        True,
-        f"Connected to {model_config.provider.value}/{model_config.model}.",
-    )
+    return ModelConnectionResult(True, f"Connected to {provider.value}/{model}.")

{kolega_code-0.26.8 → kolega_code-0.26.9}/kolega_code/cli/provider_registry.py

@@ -319,13 +319,30 @@ AGENT_ROLE_LABELS: dict[AgentRole, str] = {
 }
 
 
+# Display labels and render order for the operational model slots the UI exposes.
+# The long-context slot is the active model itself, so it is not listed here.
+MODEL_SLOT_LABELS: dict[str, str] = {
+    "fast": "Fast",
+    "thinking": "Thinking",
+}
+
+
 def agent_role_options() -> list[tuple[str, str]]:
     """Return (label, role-value) pairs for the configurable agent roles, in order."""
     return [(label, role.value) for role, label in AGENT_ROLE_LABELS.items()]
 
 
+def model_slot_options() -> list[tuple[str, str]]:
+    """Return (label, slot-value) pairs for the configurable model slots, in order."""
+    return [(label, slot) for slot, label in MODEL_SLOT_LABELS.items()]
+
+
 def agent_role_provider_options() -> list[tuple[str, str]]:
-    """Provider Select options for a per-agent row, with an inherit option first."""
+    """Provider Select options for an override row, with an inherit option first.
+
+    Shared by the per-agent rows and the model-slot rows: both mean "no override —
+    inherit the active model" when the sentinel is selected.
+    """
     return [("Default (inherit)", INHERIT_SENTINEL), *ui_provider_options()]