kolega-code 0.27.0__tar.gz → 0.27.1__tar.gz

{kolega_code-0.27.0 → kolega_code-0.27.1}/CHANGELOG.md

@@ -6,6 +6,36 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 0.27.1 - 2026-08-10
+
+### Added
+
+- Thinking Machines models can now be used through either the hosted API or
+  the native Tinker `SamplingClient`, with model discovery, settings, usage
+  tracking, and connection testing integrated across the CLI and TUI.
+- History compression thresholds can now be configured from Settings,
+  `settings.json`, `KOLEGA_CODE_COMPRESSION_THRESHOLD`, or
+  `--compression-threshold`.
+- Sub-agent dispatch can now be enabled or disabled for a session from
+  Settings, `settings.json`, `KOLEGA_CODE_SUBAGENTS`, or `--subagents on|off`.
+
+### Changed
+
+- Compression summaries can use up to 8,192 tokens, reducing the risk that
+  important context is lost in longer sessions.
+- The bundled OpenRouter catalogue was refreshed from the 2026-08-10 model
+  list and weekly rankings. It now includes 260 tool-capable models, including
+  featured `deepseek/deepseek-v4-flash-0731`.
+
+### Fixed
+
+- Provider connection tests now send a system message, improving compatibility
+  with models that reject probes containing only a user message.
+
+### Security
+
+- Updated `h2` to `4.4.1` to address `GHSA-6hr6-w5qg-qmwg`.
+
 ## 0.27.0 - 2026-08-06
 
 ### Changed

{kolega_code-0.27.0 → kolega_code-0.27.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.27.0
+Version: 0.27.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/
@@ -276,6 +276,9 @@ Requires-Dist: pytest-xdist==3.8.0; extra == 'dev'
 Requires-Dist: pytest==9.0.3; extra == 'dev'
 Requires-Dist: ruff==0.15.12; extra == 'dev'
 Requires-Dist: twine==6.2.0; extra == 'dev'
+Provides-Extra: tinker
+Requires-Dist: tinker-cookbook==0.5.3; extra == 'tinker'
+Requires-Dist: tml-renderers==0.1.0; extra == 'tinker'
 Description-Content-Type: text/markdown
 
 # Kolega Code

{kolega_code-0.27.0 → kolega_code-0.27.1}/kolega_code/__init__.py

@@ -151,4 +151,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.27.0"
+__version__ = "0.27.1"

{kolega_code-0.27.0 → kolega_code-0.27.1}/kolega_code/agent/__init__.py

@@ -51,4 +51,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.27.0"
+__version__ = "0.27.1"

{kolega_code-0.27.0 → kolega_code-0.27.1}/kolega_code/agent/baseagent.py

@@ -439,6 +439,12 @@ class BaseAgent(LogMixin):
         # Counts consecutive transient LLM failures (rate-limit / overload) so the turn loop
         # backs off and eventually gives up instead of retrying forever; reset on any good turn.
         self._consecutive_llm_retries = 0
+        # Host-configured compression threshold (fraction of the context window) shadows
+        # the class default when the config carries one; every read below and in
+        # _send_context_update goes through the instance attribute.
+        config_threshold = getattr(self.config, "history_compression_threshold", None)
+        if config_threshold is not None:
+            self.history_compression_threshold = config_threshold
         self.compressor = HistoryCompressor(threshold=self.history_compression_threshold)
         self.emitter = AgentEventEmitter(
             connection_manager=self.connection_manager,

{kolega_code-0.27.0 → kolega_code-0.27.1}/kolega_code/agent/compression.py

@@ -39,9 +39,12 @@ class HistoryCompressor:
     KEEP_RECENT_MESSAGES = 6
     # Don't bother summarizing a trivially short prefix.
     MIN_PREFIX_TO_SUMMARIZE = 3
-    # Cap the summary length: the prompt targets ~600 words (~900 tokens), so a
-    # small ceiling keeps it tight and avoids the model's full completion budget.
-    SUMMARY_MAX_TOKENS = 2048
+    # Cap the summary length. The prompt targets ~600 words, but reasoning
+    # models (deepseek-v4-flash Responses, etc.) can consume the entire budget
+    # on chain-of-thought and leave no room for text output, producing an empty
+    # summary. A generous ceiling gives reasoning headroom while still staying
+    # well under the model's full completion budget.
+    SUMMARY_MAX_TOKENS = 8192
 
     def __init__(self, threshold: float = 0.8) -> None:
         # Fraction of the model context window above which compression kicks in

{kolega_code-0.27.0 → kolega_code-0.27.1}/kolega_code/agent/tools.py

@@ -2312,6 +2312,21 @@ class ToolCollection(LogMixin):
         Returns:
             True if the tool should be included, False otherwise
         """
+        # Settings gate: sub-agent dispatch can be disabled host-wide
+        # (AgentConfig.subagents_enabled, from settings.json or the --subagents
+        # flag). Placed first so it also beats the custom_tool_groups whitelist
+        # below (planning/investigation agents) and covers host extension
+        # dispatch tools appended to this instance's agent_dispatch_tools.
+        # Gigacode workflow workers are exempt: their dispatch chain is lent by
+        # run_workflow (a separate opt-in) and depth-narrowed below.
+        # Strict `is False` so Mock configs in tests keep the default (enabled).
+        if (
+            method_name in self.agent_dispatch_tools
+            and getattr(self.config, "subagents_enabled", True) is False
+            and not has_workflow_context_marker(getattr(self.caller, "sub_agent_context", None))
+        ):
+            return False
+
         # Gigacode delegation depth is scoped through sub_agent_context. It only
         # narrows a workflow worker's existing dispatch inventory; callers with no
         # workflow context retain their normal behavior.
@@ -2472,6 +2487,14 @@ class ToolCollection(LogMixin):
             dispatch_candidates.intersection_update(self.tool_config.allowed_tools)
         if "dispatch_agent" in dispatch_candidates and not self._available_agent_types():
             dispatch_candidates.discard("dispatch_agent")
+        # Sub-agent dispatch disabled host-wide (AgentConfig.subagents_enabled):
+        # no dispatch candidates remain, so the informational
+        # list_subagent_models tool drops out as well. Gigacode paths are
+        # unaffected: the top-level workflow-authoring branch above already
+        # qualified, and a workflow worker with delegation depth left keeps the
+        # dispatch chain lent by run_workflow.
+        if getattr(self.config, "subagents_enabled", True) is False and not has_workflow_context_marker(context):
+            dispatch_candidates.clear()
         return bool(dispatch_candidates)
 
     async def initialize(self) -> list[str]:

{kolega_code-0.27.0 → kolega_code-0.27.1}/kolega_code/cli/config.py

@@ -11,12 +11,17 @@ from pydantic import ValidationError
 
 from kolega_code.auth.tokens import ChatGPTTokenManager, OAuthTokens
 from kolega_code.config import AgentConfig, AgentRole, EditProtocol, ModelConfig, ModelProvider, RateLimitConfig
-from kolega_code.llm.specs import MODEL_SPECS, get_model_specs, normalize_thinking_effort
+from kolega_code.llm.specs import MODEL_SPECS, get_model_specs, model_is_known, normalize_thinking_effort
 from kolega_code.mcp.config import load_mcp_config
 from kolega_code.services.lsp.config import LspConfig
 
 from .provider_registry import default_model_for_provider
-from .settings import CliSettings, SettingsStore
+from .settings import (
+    COMPRESSION_THRESHOLD_MAX_PERCENT,
+    COMPRESSION_THRESHOLD_MIN_PERCENT,
+    CliSettings,
+    SettingsStore,
+)
 
 # Providers authenticated by an OAuth sign-in instead of a static API key.
 OAUTH_PROVIDERS = frozenset({ModelProvider.OPENAI_CHATGPT})
@@ -48,6 +53,9 @@ API_KEY_ENV = {
     ModelProvider.KIMI_CODING: "KIMI_CODING_API_KEY",
     ModelProvider.OLLAMA_CLOUD: "OLLAMA_API_KEY",
     ModelProvider.OPENROUTER: "OPENROUTER_API_KEY",
+    ModelProvider.THINKING_MACHINES: "TINKER_API_KEY",
+    # Native Tinker sampling authenticates with the same key.
+    ModelProvider.TINKER: "TINKER_API_KEY",
 }
 
 DEFAULT_WEB_SEARCH_BACKEND = "duckduckgo"
@@ -61,6 +69,13 @@ SEARXNG_BASE_URL_ENV = "SEARXNG_BASE_URL"
 # LSP master switch: on or off. Absent means defer to settings.lsp_enabled.
 LSP_MODES = ("on", "off")
 LSP_MODE_ENV = "KOLEGA_CODE_LSP"
+# Sub-agent dispatch (dispatch_agent) master switch: on or off. Absent means
+# defer to settings.subagents_enabled, then the default (enabled).
+SUBAGENT_MODES = ("on", "off")
+SUBAGENTS_MODE_ENV = "KOLEGA_CODE_SUBAGENTS"
+# Compression threshold override, in percent (10-100). Absent means defer to
+# settings.compression_threshold, then the agent's built-in default (80%).
+COMPRESSION_THRESHOLD_ENV = "KOLEGA_CODE_COMPRESSION_THRESHOLD"
 # Env vars that supply a cloud web-search backend's key, keyed by backend name.
 SEARCH_BACKEND_KEY_ENV = {
     "firecrawl": "FIRECRAWL_API_KEY",
@@ -85,6 +100,12 @@ class CliConfigOverrides:
     edit_protocol: Optional[str] = None
     web_search_mode: Optional[str] = None
     lsp_mode: Optional[str] = None
+    # Sub-agent dispatch override from the --subagents flag ("on"/"off"); None
+    # defers to KOLEGA_CODE_SUBAGENTS, then settings.subagents_enabled.
+    subagents_mode: Optional[str] = None
+    # Compression threshold in percent, as typed on the command line; parsed and
+    # validated in _compression_threshold.
+    compression_threshold: Optional[str] = None
 
 
 def load_cli_env(project_path: Path, env: Optional[Mapping[str, str]] = None) -> dict[str, str]:
@@ -161,11 +182,19 @@ def _ensure_explicit_model_supported(
     provider_source: Optional[str],
 ) -> None:
     """Raise a targeted error when an explicit model is paired with the wrong provider."""
-    if (provider.value, model) in MODEL_SPECS:
+    if model_is_known(provider, model):
         return
 
     model_label = f"{model_source}={model}" if model_source else f"Model '{model}'"
     provider_label = f"{provider_source}={provider.value}" if provider_source else f"provider {provider.value}"
+    if provider == ModelProvider.TINKER:
+        # Checkpoint paths (tinker://...) always resolve via the wildcard; an
+        # unknown base model id needs a catalog refresh.
+        raise CliConfigError(
+            f"{model_label} is not a known Tinker base model. "
+            "Run `kolega-code models refresh --provider tinker` to pick up newer bases, "
+            "or use a saved checkpoint path (tinker://<run-id>/sampler_weights/<step>)."
+        )
     sources = _model_sources(model)
     if sources:
         preferred = sources[0]
@@ -274,14 +303,74 @@ def _lsp_enabled(
     return True
 
 
+def _subagents_enabled(
+    env: Mapping[str, str],
+    settings: Optional[CliSettings],
+    override: Optional[str],
+) -> bool:
+    """Resolve the sub-agent dispatch master switch with flag-over-env-over-settings precedence."""
+    mode = (override or env.get(SUBAGENTS_MODE_ENV) or "").strip().lower()
+    if mode:
+        if mode not in SUBAGENT_MODES:
+            valid = ", ".join(SUBAGENT_MODES)
+            raise CliConfigError(f"Unsupported subagents mode '{mode}'. Valid modes: {valid}")
+        return mode == "on"
+    if settings is not None and settings.subagents_enabled is not None:
+        return bool(settings.subagents_enabled)
+    return True
+
+
+def _compression_threshold(
+    env: Mapping[str, str],
+    settings: Optional[CliSettings],
+    override: Optional[str],
+) -> Optional[float]:
+    """Resolve the compression threshold with flag-over-env-over-settings precedence.
+
+    User-facing surfaces carry a percent (10-100); the returned value is the
+    fraction the agent compares against, or None for the built-in default (80%).
+    Explicit flag/env values are validated strictly (a typo must fail loudly);
+    settings values were already range-coerced at load."""
+    # Resolve presence per layer instead of via _explicit_value, whose truthiness
+    # check treats an explicit empty value as absent; here it is invalid input to
+    # reject, not a missing layer to fall through.
+    explicit: Optional[str] = None
+    source: Optional[str] = None
+    if override is not None:
+        explicit, source = override, "--compression-threshold"
+    elif COMPRESSION_THRESHOLD_ENV in env:
+        explicit, source = env[COMPRESSION_THRESHOLD_ENV], COMPRESSION_THRESHOLD_ENV
+    percent: Optional[float] = None
+    if explicit is not None:
+        try:
+            percent = float(explicit)
+        except ValueError:
+            percent = None
+        if (
+            percent is None
+            or percent < COMPRESSION_THRESHOLD_MIN_PERCENT
+            or percent > COMPRESSION_THRESHOLD_MAX_PERCENT
+        ):
+            raise CliConfigError(
+                f"Unsupported compression threshold '{explicit}' from {source}. "
+                f"Valid range: {COMPRESSION_THRESHOLD_MIN_PERCENT}-{COMPRESSION_THRESHOLD_MAX_PERCENT} (percent)."
+            )
+    elif settings is not None and settings.compression_threshold is not None:
+        percent = settings.compression_threshold
+    if percent is None:
+        return None
+    return percent / 100.0
+
+
 def _coerce_known_model(provider: ModelProvider, model: Optional[str]) -> str:
     """Return ``model`` if it's a known spec for ``provider``, else the default.
 
     Guards against a settings.json that points at a model which has since been
     renamed or removed (e.g. an old ChatGPT slug): without this, config building
-    raises and the TUI disables the composer, locking the user out.
+    raises and the TUI disables the composer, locking the user out. Wildcard-
+    addressed models (Tinker checkpoint paths) count as known and are kept.
     """
-    if model and (provider.value, model) in MODEL_SPECS:
+    if model and model_is_known(provider, model):
         return model
     return default_model_for_provider(provider)
 
@@ -370,7 +459,7 @@ def _slot_provider_model(
     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:
+        if not model_is_known(provider, saved_model):
             saved_model = default_model_for_provider(provider)
         return provider, saved_model
 
@@ -461,7 +550,7 @@ def _agent_model_overrides(
                 model_source=model_key,
                 provider_source=provider_key if provider_env_value else None,
             )
-        elif (provider.value, model_value) not in MODEL_SPECS:
+        elif not model_is_known(provider, model_value):
             model_value = default_model_for_provider(provider)
         overrides[role.value] = _model_config(provider, model_value, thinking_effort=effort_value)
     return overrides
@@ -519,6 +608,7 @@ def build_agent_config(
     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)
     web_search_mode = _web_search_mode(loaded_env, settings, overrides.web_search_mode)
+    compression_threshold = _compression_threshold(loaded_env, settings, overrides.compression_threshold)
     state_dir = settings_store.root if settings_store is not None else SettingsStore().root
     mcp_config = load_mcp_config(
         project_path,
@@ -569,6 +659,7 @@ def build_agent_config(
             kimi_coding_api_key=_api_key_for_provider(ModelProvider.KIMI_CODING, loaded_env, settings),
             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),
             environment=overrides.environment or loaded_env.get("KOLEGA_CODE_ENVIRONMENT", "development"),
             edit_protocol=edit_protocol,
             long_context_config=_model_config(long_provider, long_model, thinking_effort=active_thinking_effort),
@@ -583,6 +674,8 @@ def build_agent_config(
             lsp=LspConfig(enabled=_lsp_enabled(loaded_env, settings, overrides.lsp_mode)),
             lsp_project_trusted=lsp_project_trusted,
             eval_enabled=(True if settings is None or settings.eval_enabled is None else bool(settings.eval_enabled)),
+            subagents_enabled=_subagents_enabled(loaded_env, settings, overrides.subagents_mode),
+            history_compression_threshold=compression_threshold,
         )
     except ValueError as exc:
         raise CliConfigError(str(exc)) from exc

{kolega_code-0.27.0 → kolega_code-0.27.1}/kolega_code/cli/main.py

@@ -73,6 +73,7 @@ from .diagnostics import write_crash_log
 from .config import (
     DEPRECATED_THINKING_TOKENS_MESSAGE,
     LSP_MODES,
+    SUBAGENT_MODES,
     WEB_SEARCH_MODES,
     CliConfigError,
     CliConfigOverrides,
@@ -82,7 +83,7 @@ from .config import (
 )
 from .connection import CliConnectionManager
 from .mentions import build_file_attachments
-from .model_catalog import SORT_CHOICES, apply_catalog_overlay, run_models_list, run_models_refresh
+from .model_catalog import SORT_CHOICES, apply_all_catalog_overlays, run_models_list, run_models_refresh
 from .session_store import SessionRecord, SessionStore, SessionStoreError, resolve_active_project
 from .settings import CliSettings, SettingsStore, SettingsStoreError
 from .goal import (
@@ -155,9 +156,9 @@ def main(argv: Optional[Iterable[str]] = None) -> int:
     except (OSError, ValueError, RuntimeError):
         pass
     args = parse_args(list(argv) if argv is not None else sys.argv[1:])
-    # Merge any cached provider catalog before a command resolves a model. This
-    # only reads a local file; refreshing it is an explicit `models refresh`.
-    apply_catalog_overlay(getattr(args, "state_dir", None))
+    # Merge any cached provider catalogs before a command resolves a model.
+    # This only reads local files; refreshing them is an explicit `models refresh`.
+    apply_all_catalog_overlays(getattr(args, "state_dir", None))
     try:
         if getattr(args, "version", False):
             return _run_version()
@@ -241,6 +242,13 @@ def _add_common_model_args(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--thinking-effort", help="Model-specific thinking effort for the active model.")
     parser.add_argument("--thinking-tokens", dest="deprecated_thinking_tokens", type=int, help=argparse.SUPPRESS)
     parser.add_argument("--environment", help="Environment label for tracing/metadata.")
+    parser.add_argument(
+        "--compression-threshold",
+        metavar="PERCENT",
+        help="Context-window usage percentage that triggers automatic history compression "
+        "(10-100; default 80). Overrides settings.json for this session; not persisted. "
+        "100 effectively disables automatic compression.",
+    )
     parser.add_argument(
         "--edit-protocol",
         choices=[protocol.value for protocol in EditProtocol],
@@ -332,6 +340,13 @@ def _add_tui_args(parser: argparse.ArgumentParser) -> None:
         default=None,
         help="Force LSP tools on or off for this session (overrides settings.json; not persisted).",
     )
+    parser.add_argument(
+        "--subagents",
+        choices=list(SUBAGENT_MODES),
+        default=None,
+        help="Force sub-agent dispatch (dispatch_agent) on or off for this session "
+        "(overrides settings.json; not persisted).",
+    )
     _add_session_args(parser, session_help="Legacy alias for --resume SESSION_ID.")
     _add_worktree_args(parser)
     _add_common_model_args(parser)
@@ -427,6 +442,13 @@ def _build_subcommand_parser() -> argparse.ArgumentParser:
         default=None,
         help="Force LSP tools on or off for this session (overrides settings.json; not persisted).",
     )
+    ask.add_argument(
+        "--subagents",
+        choices=list(SUBAGENT_MODES),
+        default=None,
+        help="Force sub-agent dispatch (dispatch_agent) on or off for this session "
+        "(overrides settings.json; not persisted).",
+    )
     ask.add_argument("--save", action="store_true", help="Persist the session after the prompt completes.")
     ask.add_argument("--json", action="store_true", help="Emit complete messages and events as JSON.")
     ask.add_argument("--browser-visible", action="store_true", help="Launch visible Playwright browser windows.")
@@ -640,6 +662,8 @@ def _overrides_from_args(args: argparse.Namespace) -> CliConfigOverrides:
         edit_protocol=getattr(args, "edit_protocol", None),
         web_search_mode=getattr(args, "web_search", None),
         lsp_mode=getattr(args, "lsp", None),
+        subagents_mode=getattr(args, "subagents", None),
+        compression_threshold=getattr(args, "compression_threshold", None),
     )
 
 

{kolega_code-0.27.0 → kolega_code-0.27.1}/kolega_code/cli/model_catalog.py

@@ -1,14 +1,13 @@
-"""Model-catalog inspection and the optional OpenRouter catalog overlay.
+"""Model-catalog inspection and optional runtime catalog overlays.
 
 Backs ``kolega-code models list`` and ``kolega-code models refresh``.
 
-The bundled OpenRouter catalog is a snapshot taken when a Kolega Code release is
-cut, so a model published after that release is unknown to it. ``models refresh``
-fetches the documented ``/api/v1/models`` endpoint once, on request, and caches
-the result in the state directory; the cache is merged into ``MODEL_SPECS`` at
-CLI startup. Startup itself never touches the network, and cached entries are
-never marked ``featured`` — Settings pickers lead with the release's curated-by-
-usage set (and admit any catalogued id through their "Other…" entry), while
+Bundled catalogs are snapshots taken when a Kolega Code release is cut, so a
+model published after that release is unknown to them. ``models refresh``
+fetches a provider's live catalog once, on request, and caches the result in
+the state directory; the cache is merged into ``MODEL_SPECS`` at CLI startup.
+Startup itself never touches the network, and cached entries are never marked
+``featured`` — Settings pickers lead with the release's curated set, while
 sub-agent prompts keep showing the featured set alone.
 """
 
@@ -23,55 +22,87 @@ from typing import Any, Iterable, Optional, Sequence
 from kolega_code.config import ModelProvider
 from kolega_code.llm.specs import MODEL_SPECS, is_featured_model
 from kolega_code.llm.specs import openrouter_catalog as openrouter
+from kolega_code.llm.specs import tinker_catalog as tinker
 
 from .provider_registry import PROVIDER_LABELS, get_ui_model, rebuild_ui_model_options
 from .session_store import default_state_dir
 
-# Point the overlay at an explicit file (useful for pinning a catalog in CI).
-CATALOG_PATH_ENV = "KOLEGA_CODE_OPENROUTER_CATALOG"
-# Ignore any cached overlay and use the bundled snapshot alone.
-CATALOG_DISABLE_ENV = "KOLEGA_CODE_DISABLE_OPENROUTER_CATALOG"
+# Overlay sources keyed by provider value. Each module exposes PROVIDER,
+# MODELS_URL, CACHE_FILENAME, fetch_models(), catalog_entries(), load_cache()
+# and save_cache().
+OVERLAY_SOURCES = {
+    openrouter.PROVIDER: openrouter,
+    tinker.PROVIDER: tinker,
+}
+
+
+def _overlay_module(catalog: str) -> Any:
+    module = OVERLAY_SOURCES.get(catalog)
+    if module is None:
+        raise ValueError(
+            f"No refreshable catalog for provider '{catalog}'. Valid: {', '.join(sorted(OVERLAY_SOURCES))}"
+        )
+    return module
+
+
+def _catalog_env_names(catalog: str) -> tuple[str, str]:
+    upper = catalog.upper()
+    return f"KOLEGA_CODE_{upper}_CATALOG", f"KOLEGA_CODE_DISABLE_{upper}_CATALOG"
+
+
+# OpenRouter's pin/disable env vars, kept as module constants for back-compat
+# (tests and docs reference them by name).
+CATALOG_PATH_ENV, CATALOG_DISABLE_ENV = _catalog_env_names(openrouter.PROVIDER)
 
 SORT_CHOICES = ("popularity", "id")
 
 
-def overlay_path(state_dir: Optional[Path] = None, env: Optional[dict[str, str]] = None) -> Path:
-    """Resolve the OpenRouter overlay cache path."""
+def overlay_path(
+    state_dir: Optional[Path] = None,
+    env: Optional[dict[str, str]] = None,
+    catalog: str = openrouter.PROVIDER,
+) -> Path:
+    """Resolve an overlay cache path for ``catalog``."""
+    module = _overlay_module(catalog)
     environ = env if env is not None else dict(os.environ)
-    override = environ.get(CATALOG_PATH_ENV)
+    path_env, _ = _catalog_env_names(catalog)
+    override = environ.get(path_env)
     if override:
         return Path(override).expanduser()
     root = state_dir or default_state_dir(environ)
-    return Path(root).expanduser() / openrouter.CACHE_FILENAME
+    return Path(root).expanduser() / module.CACHE_FILENAME
 
 
-def overlay_disabled(env: Optional[dict[str, str]] = None) -> bool:
+def overlay_disabled(env: Optional[dict[str, str]] = None, catalog: str = openrouter.PROVIDER) -> bool:
     environ = env if env is not None else dict(os.environ)
-    value = (environ.get(CATALOG_DISABLE_ENV) or "").strip().lower()
+    _, disable_env = _catalog_env_names(catalog)
+    value = (environ.get(disable_env) or "").strip().lower()
     return value not in ("", "0", "false", "no")
 
 
 def apply_catalog_overlay(
     state_dir: Optional[Path] = None,
     env: Optional[dict[str, str]] = None,
+    catalog: str = openrouter.PROVIDER,
 ) -> int:
-    """Merge a cached OpenRouter catalog into ``MODEL_SPECS``; return entries added.
+    """Merge a cached ``catalog`` overlay into ``MODEL_SPECS``; return entries added.
 
     Bundled entries always win: a refresh may add models, never redefine the
     reviewed specs (or the featured set) that shipped with the release. Any
     failure is silent by design — the bundled snapshot is a complete catalog on
     its own, and no CLI command should fail because a cache file is unreadable.
     """
-    if overlay_disabled(env):
+    module = _overlay_module(catalog)
+    if overlay_disabled(env, catalog=catalog):
         return 0
-    path = overlay_path(state_dir, env)
-    entries = openrouter.load_cache(path)
+    path = overlay_path(state_dir, env, catalog=catalog)
+    entries = module.load_cache(path)
     if not entries:
         return 0
 
     added = 0
     for identifier, spec in entries:
-        key = (openrouter.PROVIDER, identifier)
+        key = (module.PROVIDER, identifier)
         if key in MODEL_SPECS:
             continue
         # Overlay models are never featured: the picker keeps showing the
@@ -84,6 +115,14 @@ def apply_catalog_overlay(
     return added
 
 
+def apply_all_catalog_overlays(state_dir: Optional[Path] = None) -> int:
+    """Merge every configured catalog overlay; return total entries added."""
+    total = 0
+    for catalog in OVERLAY_SOURCES:
+        total += apply_catalog_overlay(state_dir, catalog=catalog)
+    return total
+
+
 def catalog_rows(
     *,
     provider: Optional[str] = None,
@@ -186,24 +225,25 @@ def run_models_list(args: Any, printer) -> int:
 def run_models_refresh(args: Any, printer, error_printer) -> int:
     """Handle ``kolega-code models refresh``."""
     provider = _resolve_provider(getattr(args, "provider", None)) or openrouter.PROVIDER
-    if provider != openrouter.PROVIDER:
-        error_printer(f"Only '{openrouter.PROVIDER}' has a refreshable catalog.")
+    module = OVERLAY_SOURCES.get(provider)
+    if module is None:
+        error_printer(f"No refreshable catalog for provider '{provider}'. Valid: {', '.join(sorted(OVERLAY_SOURCES))}.")
         return 2
 
-    printer(f"Fetching {openrouter.MODELS_URL} ...")
+    printer(f"Fetching {module.MODELS_URL} ...")
     try:
-        payload = openrouter.fetch_models()
-        entries = openrouter.catalog_entries(payload)
+        payload = module.fetch_models()
+        entries = module.catalog_entries(payload)
     except Exception as exc:  # noqa: BLE001 - surface the cause, whatever the transport raised
-        error_printer(f"Could not refresh the OpenRouter catalog: {exc}")
+        error_printer(f"Could not refresh the {provider} catalog: {exc}")
         return 1
 
-    bundled = {model for (provider_value, model) in MODEL_SPECS if provider_value == openrouter.PROVIDER}
-    path = overlay_path(getattr(args, "state_dir", None))
-    previously_cached = {identifier for identifier, _ in openrouter.load_cache(path)}
+    bundled = {model for (provider_value, model) in MODEL_SPECS if provider_value == provider}
+    path = overlay_path(getattr(args, "state_dir", None), catalog=provider)
+    previously_cached = {identifier for identifier, _ in module.load_cache(path)}
     new_models = [identifier for identifier, _ in entries if identifier not in bundled]
 
-    openrouter.save_cache(path, entries, fetched_at=dt.datetime.now(dt.timezone.utc).isoformat())
+    module.save_cache(path, entries, fetched_at=dt.datetime.now(dt.timezone.utc).isoformat())
 
     added = [identifier for identifier in new_models if identifier not in previously_cached]
     printer(
@@ -212,8 +252,9 @@ def run_models_refresh(args: Any, printer, error_printer) -> int:
     )
     if added:
         printer("Newly available: " + ", ".join(sorted(added)[:20]) + ("..." if len(added) > 20 else ""))
-    if overlay_disabled():
-        printer(f"NOTE: {CATALOG_DISABLE_ENV} is set, so the cache is ignored at startup.")
+    if overlay_disabled(catalog=provider):
+        _, disable_env = _catalog_env_names(provider)
+        printer(f"NOTE: {disable_env} is set, so the cache is ignored at startup.")
     return 0
 
 

{kolega_code-0.27.0 → kolega_code-0.27.1}/kolega_code/cli/model_connection.py

@@ -27,6 +27,10 @@ async def _probe_generate(client: Any, model: str, messages: MessageHistory) ->
     with llm_call_origin(helper_origin("model_connection")):
         return await client.generate(
             messages=messages,
+            # The Anthropic provider family (anthropic, moonshot, zai,
+            # kimi_coding, thinking_machines) requires a system message, so the
+            # probe must carry one even though it is not the point of the test.
+            system=Message(role="system", content=[TextBlock(text="Reply with OK.")]),
             model=model,
             max_completion_tokens=CONNECTION_TEST_MAX_COMPLETION_TOKENS,
             tools=[],