kolega-code 0.35.1__tar.gz → 0.37.0__tar.gz

{kolega_code-0.35.1 → kolega_code-0.37.0}/CHANGELOG.md

@@ -6,6 +6,56 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 0.37.0 - 2026-09-09
+
+### Added
+
+- **DeepSeek V4.1 Flash (preview).** DeepSeek's temporary
+  `deepseek-v4.1-flash-expires-on-0910` model is available under **DeepSeek V4.1
+  Flash (Preview, expires Sep 10)** in the model picker, with vision, hosted web
+  search, and `none`/`low`/`high`/`max` reasoning effort (default `high`). It is
+  not the default and is not aliased to a stable model; the ID expires on
+  September 10, 2026, after which an available stable model must be selected.
+
+### Fixed
+
+- Pin PDFium and the Intel Python 3.11/3.12 ONNX Runtime dependency to restore
+  compatible wheel selection on macOS Monterey for both the installer and direct
+  package installs. Intel Monterey requires Python 3.11 or 3.12.
+- Settings saves are merged with concurrent writers instead of replacing the whole
+  file, so a long-running instance can no longer drop a gateway token or API key
+  another process saved after it started.
+- `kolega-code gateway status` now reports an installed background service that
+  is failing to start (service state, start count, last exit code, log path)
+  instead of only printing "not running".
+
+## 0.36.0 - 2026-09-07
+
+### Added
+
+- **GPT-6 Astra.** OpenAI's new flagship model is available on both the API
+  and ChatGPT-subscription providers: 1M-token context with 128K output,
+  vision, hosted web search, `codex_apply_patch` editing, and
+  `low`–`max` reasoning effort levels (default `medium`). The
+  ChatGPT-subscription route keeps the conservative 400K input budget until
+  Astra's larger window is verified on the Codex backend.
+- **Pre-registered OAuth credentials for remote MCP servers.** Servers that
+  don't implement Dynamic Client Registration (HubSpot, Slack, GitHub
+  Copilot, enterprise IdPs) can now be connected with a pre-registered
+  client: new `--oauth-client-id`, `--oauth-client-secret`,
+  `--oauth-client-secret-env`, and `--oauth-auth-method` flags on
+  `kolega-code mcp add`, matching OAuth controls on the MCP page in TUI
+  settings, preserved explicit redirect ports/hosts, actionable diagnostics
+  when registration fails, and PBKDF2-salted OAuth cache fingerprints with
+  refresh tokens preserved across reconnects.
+
+### Fixed
+
+- **Gateway (Telegram):** the typing indicator now stays alive for the whole
+  turn. Telegram expires typing actions after ~5 seconds, so it previously
+  vanished during exactly the stretches where feedback matters — model
+  thinking before the first chunk and long-running tool calls.
+
 ## 0.35.1 - 2026-09-03
 
 ### Fixed

{kolega_code-0.35.1 → kolega_code-0.37.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.35.1
+Version: 0.37.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/
@@ -47,6 +47,7 @@ Requires-Dist: markdownify==1.2.3
 Requires-Dist: markitdown[docx,pdf,pptx,xls,xlsx]==0.1.6
 Requires-Dist: mcp==1.28.1
 Requires-Dist: nest-asyncio==1.6.0
+Requires-Dist: onnxruntime==1.19.2; sys_platform == 'darwin' and platform_machine == 'x86_64' and python_version < '3.13'
 Requires-Dist: onnxruntime==1.27.0; python_version >= '3.14' and sys_platform != 'win32'
 Requires-Dist: openai==2.46.0
 Requires-Dist: packaging==25.0
@@ -56,6 +57,7 @@ Requires-Dist: playwright==1.59.0
 Requires-Dist: psutil==7.2.2
 Requires-Dist: pydantic==2.13.4
 Requires-Dist: pygments==2.20.0
+Requires-Dist: pypdfium2==5.11.0
 Requires-Dist: python-dotenv==1.2.2
 Requires-Dist: pyyaml==6.0.3
 Requires-Dist: readability-lxml==0.8.4.1

{kolega_code-0.35.1 → kolega_code-0.37.0}/kolega_code/__init__.py

@@ -174,4 +174,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.35.1"
+__version__ = "0.37.0"

{kolega_code-0.35.1 → kolega_code-0.37.0}/kolega_code/agent/__init__.py

@@ -51,4 +51,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.35.1"
+__version__ = "0.37.0"

{kolega_code-0.35.1 → kolega_code-0.37.0}/kolega_code/cli/gateway.py

@@ -33,6 +33,7 @@ from kolega_code.gateway.service import (
     install_service,
     is_service_installed,
     restart_service,
+    service_state_summary,
     uninstall_service,
 )
 
@@ -290,6 +291,7 @@ def _gateway_status(config: GatewayConfig) -> int:
     if payload is not None:
         # A heartbeat from a process that no longer exists (e.g. SIGKILLed).
         print(f"gateway: not running (stale heartbeat from pid {payload.get('pid')})")
+        _print_service_state(config)
         return 0
     lock = FileLock(str(config.state_dir / LOCK_FILE_NAME))
     try:
@@ -303,9 +305,20 @@ def _gateway_status(config: GatewayConfig) -> int:
         return 0
     lock.release()
     print(f"gateway: not running (state: {config.state_dir})")
+    _print_service_state(config)
     return 0
 
 
+def _print_service_state(config: GatewayConfig) -> None:
+    summary = service_state_summary()
+    if summary is None:
+        return
+    print(f"  service: {summary}")
+    log_path = config.state_dir / "gateway.log"
+    if log_path.exists():
+        print(f"  log: {log_path}")
+
+
 def _pid_alive(pid: Any) -> bool:
     if not isinstance(pid, int) or pid <= 0:
         return False

{kolega_code-0.35.1 → kolega_code-0.37.0}/kolega_code/cli/main.py

@@ -796,6 +796,14 @@ def _build_subcommand_parser() -> argparse.ArgumentParser:
     add.add_argument("--env", action="append", default=[], help="Environment variable as NAME=VALUE (repeatable).")
     add.add_argument("--cwd", help="Working directory for stdio command; relative paths resolve under project.")
     add.add_argument("--oauth", action="store_true", help="Enable OAuth for this HTTP MCP server.")
+    add.add_argument("--oauth-client-id", help="Pre-registered OAuth client ID.")
+    add.add_argument("--oauth-client-secret", help="Pre-registered OAuth client secret.")
+    add.add_argument("--oauth-client-secret-env", help="Environment variable name holding the OAuth client secret.")
+    add.add_argument(
+        "--oauth-auth-method",
+        choices=["client_secret_post", "client_secret_basic", "none"],
+        help="Token endpoint authentication method.",
+    )
     add.add_argument("--oauth-scope", help="OAuth scopes to request.")
     add.add_argument("--redirect-uri", help="OAuth redirect URI; defaults to an ephemeral localhost callback.")
     add.add_argument("--disabled", action="store_true", help="Add the server disabled.")
@@ -2697,6 +2705,12 @@ def _mcp_mutation_target(args: argparse.Namespace, project_path: Path, state_dir
 def _server_config_from_add_args(args: argparse.Namespace) -> MCPServerConfig:
     headers = _parse_key_value_options(getattr(args, "header", []) or [], "--header")
     env = _parse_key_value_options(getattr(args, "env", []) or [], "--env")
+    oauth_client_id = getattr(args, "oauth_client_id", None)
+    oauth_client_secret = getattr(args, "oauth_client_secret", None)
+    oauth_client_secret_env = getattr(args, "oauth_client_secret_env", None)
+    oauth_auth_method = getattr(args, "oauth_auth_method", None)
+    oauth_enabled = bool(args.oauth) or bool(oauth_client_id or oauth_client_secret or oauth_client_secret_env)
+
     payload: dict[str, Any] = {
         "id": args.server_id,
         "name": args.name,
@@ -2709,9 +2723,13 @@ def _server_config_from_add_args(args: argparse.Namespace) -> MCPServerConfig:
         "env": env,
         "cwd": args.cwd,
         "oauth": {
-            "enabled": bool(args.oauth),
+            "enabled": oauth_enabled,
             "scope": args.oauth_scope,
             "redirect_uri": args.redirect_uri,
+            "client_id": oauth_client_id,
+            "client_secret": oauth_client_secret,
+            "client_secret_env": oauth_client_secret_env,
+            "token_endpoint_auth_method": oauth_auth_method,
         },
     }
     return MCPServerConfig.model_validate(payload)

{kolega_code-0.35.1 → kolega_code-0.37.0}/kolega_code/cli/provider_registry.py

@@ -70,6 +70,7 @@ MODEL_LABELS: dict[str, str] = {
     "kimi-for-coding": "Kimi for Coding",
     "kimi-for-coding-highspeed": "Kimi for Coding (HighSpeed)",
     # DeepSeek
+    "deepseek-v4.1-flash-expires-on-0910": "DeepSeek V4.1 Flash (Preview, expires Sep 10)",
     "deepseek-v4-pro": "DeepSeek V4 Pro",
     "deepseek-v4-flash": "DeepSeek V4 Flash",
     "deepseek-v4-flash-vision-exp": "DeepSeek V4 Flash Vision (Exp)",
@@ -90,6 +91,7 @@ MODEL_LABELS: dict[str, str] = {
     "claude-opus-4-5-20251101": "Claude Opus 4.5",
     "claude-haiku-4-5-20251001": "Claude Haiku 4.5",
     # OpenAI (shared labels across the API and ChatGPT-subscription providers)
+    "gpt-6-astra": "GPT-6 Astra",
     "gpt-5.6-sol": "GPT-5.6 Sol",
     "gpt-5.6-terra": "GPT-5.6 Terra",
     "gpt-5.6-luna": "GPT-5.6 Luna",

{kolega_code-0.35.1 → kolega_code-0.37.0}/kolega_code/cli/settings.py

@@ -2,11 +2,15 @@
 
 from __future__ import annotations
 
+import copy
 import json
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Optional
 
+from filelock import FileLock
+from filelock import Timeout as FileLockTimeout
+
 from kolega_code.local_state import write_private_text
 from kolega_code.llm.specs.custom_endpoints import (
     API_STYLES,
@@ -33,6 +37,41 @@ class SettingsStoreError(RuntimeError):
     """Raised when CLI settings cannot be loaded or saved."""
 
 
+SETTINGS_LOCK_TIMEOUT_SECONDS = 10.0
+
+
+def _merge_settings_documents(
+    base: dict[str, Any],
+    current: dict[str, Any],
+    on_disk: dict[str, Any],
+) -> dict[str, Any]:
+    """Apply one writer's changes on top of the current document.
+
+    ``base`` is the state the writer loaded, so keys it did not touch keep the
+    on-disk value and a stale writer cannot revert another process's change.
+    Nested dicts merge key by key, and keys the writer never saw survive.
+    """
+    merged: dict[str, Any] = {}
+    for key in set(base) | set(current) | set(on_disk):
+        if key not in current:
+            if key in base:
+                continue
+            if key in on_disk:
+                merged[key] = on_disk[key]
+            continue
+        if key in base and base[key] == current[key]:
+            merged[key] = on_disk[key] if key in on_disk else current[key]
+            continue
+        if key not in base and current[key] is None and key in on_disk:
+            merged[key] = on_disk[key]
+            continue
+        if isinstance(base.get(key), dict) and isinstance(current[key], dict) and isinstance(on_disk.get(key), dict):
+            merged[key] = _merge_settings_documents(base[key], current[key], on_disk[key])
+            continue
+        merged[key] = current[key]
+    return merged
+
+
 def _coerce_model_entries(raw: object) -> dict[str, dict]:
     """Normalize a stored key -> {provider, model, ...} mapping.
 
@@ -272,6 +311,9 @@ class CliSettings:
     # Additive optional field — absent in older files -> empty mapping.
     custom_endpoints: dict[str, dict] = field(default_factory=dict)
     schema_version: int = SETTINGS_SCHEMA_VERSION
+    # The document this instance was loaded from, used as the merge base by
+    # SettingsStore.save(). Never serialized.
+    _merge_base: Optional[dict[str, Any]] = field(default=None, repr=False, compare=False)
 
     @classmethod
     def from_dict(cls, data: dict) -> "CliSettings":
@@ -452,12 +494,47 @@ class SettingsStore:
 
     def load(self) -> CliSettings:
         if not self.path.exists():
-            return CliSettings()
+            settings = CliSettings()
+            settings._merge_base = copy.deepcopy(settings.to_dict())
+            return settings
         try:
-            return CliSettings.from_dict(json.loads(self.path.read_text(encoding="utf-8")))
+            data = json.loads(self.path.read_text(encoding="utf-8"))
+            settings = CliSettings.from_dict(data)
         except json.JSONDecodeError as exc:
             raise SettingsStoreError(f"Settings file is not valid JSON: {self.path}") from exc
+        # The merge base is what this process understood, not the raw file:
+        # a key it never saw (newer schema, hand-edit) must survive its save.
+        settings._merge_base = copy.deepcopy(settings.to_dict())
+        if isinstance(data, dict) and "schema_version" in data:
+            settings._merge_base["schema_version"] = data["schema_version"]
+        return settings
 
     def save(self, settings: CliSettings) -> None:
-        payload = json.dumps(settings.to_dict(), indent=2, sort_keys=True)
-        write_private_text(self.path, payload + "\n")
+        """Write this instance's changes, keeping concurrent writers' fields."""
+        lock = FileLock(f"{self.path}.lock")
+        try:
+            lock.acquire(timeout=SETTINGS_LOCK_TIMEOUT_SECONDS)
+        except FileLockTimeout as exc:
+            raise SettingsStoreError(f"Timed out locking the settings file: {self.path}") from exc
+        try:
+            merged = self._merged_document(settings)
+            payload = json.dumps(merged, indent=2, sort_keys=True)
+            write_private_text(self.path, payload + "\n")
+        finally:
+            lock.release()
+        settings._merge_base = copy.deepcopy(merged)
+
+    def _merged_document(self, settings: CliSettings) -> dict[str, Any]:
+        current = settings.to_dict()
+        if settings._merge_base is None:
+            return current
+        return _merge_settings_documents(settings._merge_base, current, self._read_document())
+
+    def _read_document(self) -> dict[str, Any]:
+        try:
+            raw = json.loads(self.path.read_text(encoding="utf-8"))
+        except FileNotFoundError:
+            return {}
+        except (json.JSONDecodeError, OSError) as exc:
+            raise SettingsStoreError(f"Settings file is not valid JSON: {self.path}") from exc
+        return raw if isinstance(raw, dict) else {}

{kolega_code-0.35.1 → kolega_code-0.37.0}/kolega_code/cli/tui/settings_panel.py

@@ -104,6 +104,12 @@ MCP_TRANSPORT_OPTIONS = [
     ("stdio command", "stdio"),
 ]
 MCP_ENABLED_OPTIONS = [("Enabled", "true"), ("Disabled", "false")]
+MCP_OAUTH_AUTH_METHOD_OPTIONS = [
+    ("Auto (POST if secret, none if public)", "auto"),
+    ("client_secret_post", "client_secret_post"),
+    ("client_secret_basic", "client_secret_basic"),
+    ("none (public client / PKCE)", "none"),
+]
 MCP_STATUS_MESSAGE_MAX = 96
 MCP_STATUS_NAME_MAX = 34
 # Compression threshold select: "default" maps to None (the agent's built-in 95%).
@@ -417,6 +423,16 @@ class SettingsPanelMixin(tui_app_base.KolegaAppBase):
             self._update_mcp_transport_fields(str(event.value))
             return
 
+        if select_id == "mcp_oauth_select":
+            transport = "streamable_http"
+            try:
+                transport = str(self._settings_query_one("#mcp_transport_select", Select).value)
+            except NoMatches:
+                pass
+            http = transport in {"streamable_http", "sse"}
+            self._update_mcp_oauth_fields(http and str(event.value) == "true")
+            return
+
         row = _row_for_widget(select_id)
         if row is not None and select_id == row.provider_id:
             provider = str(event.value)
@@ -1477,6 +1493,12 @@ class SettingsPanelMixin(tui_app_base.KolegaAppBase):
             set_input("mcp_url_input", "")
             set_input("mcp_headers_input", "")
             set_select("mcp_oauth_select", "false")
+            set_input("mcp_oauth_client_id_input", "")
+            set_input("mcp_oauth_client_secret_input", "")
+            set_input("mcp_oauth_client_secret_env_input", "")
+            set_input("mcp_oauth_redirect_uri_input", "")
+            set_input("mcp_oauth_scope_input", "")
+            set_select("mcp_oauth_auth_method_select", "auto")
             set_input("mcp_command_input", "")
             set_input("mcp_args_input", "")
             set_input("mcp_env_input", "")
@@ -1491,6 +1513,12 @@ class SettingsPanelMixin(tui_app_base.KolegaAppBase):
         set_input("mcp_url_input", server.url or "")
         set_input("mcp_headers_input", json.dumps(server.headers, sort_keys=True) if server.headers else "")
         set_select("mcp_oauth_select", "true" if server.oauth.enabled else "false")
+        set_input("mcp_oauth_client_id_input", server.oauth.client_id or "")
+        set_input("mcp_oauth_client_secret_input", server.oauth.client_secret or "")
+        set_input("mcp_oauth_client_secret_env_input", server.oauth.client_secret_env or "")
+        set_input("mcp_oauth_redirect_uri_input", server.oauth.redirect_uri or "")
+        set_input("mcp_oauth_scope_input", server.oauth.scope or "")
+        set_select("mcp_oauth_auth_method_select", server.oauth.token_endpoint_auth_method or "auto")
         set_input("mcp_command_input", server.command or "")
         set_input("mcp_args_input", " ".join(shlex.quote(arg) for arg in server.args))
         set_input("mcp_env_input", json.dumps(server.env, sort_keys=True) if server.env else "")
@@ -1503,6 +1531,26 @@ class SettingsPanelMixin(tui_app_base.KolegaAppBase):
             self._set_mcp_source_hint("This server is stored in your global MCP config.")
         self._update_mcp_transport_fields(server.transport)
 
+    def _update_mcp_oauth_fields(self, visible: bool) -> None:
+        for widget_id in (
+            "mcp_oauth_client_id_label",
+            "mcp_oauth_client_id_input",
+            "mcp_oauth_client_secret_label",
+            "mcp_oauth_client_secret_input",
+            "mcp_oauth_client_secret_env_label",
+            "mcp_oauth_client_secret_env_input",
+            "mcp_oauth_redirect_uri_label",
+            "mcp_oauth_redirect_uri_input",
+            "mcp_oauth_scope_label",
+            "mcp_oauth_scope_input",
+            "mcp_oauth_auth_method_label",
+            "mcp_oauth_auth_method_select",
+        ):
+            try:
+                self._settings_query_one(f"#{widget_id}").display = visible
+            except NoMatches:
+                pass
+
     def _update_mcp_transport_fields(self, transport: str) -> None:
         http = transport in {"streamable_http", "sse"}
         for widget_id, visible in (
@@ -1525,6 +1573,12 @@ class SettingsPanelMixin(tui_app_base.KolegaAppBase):
                 self._settings_query_one(f"#{widget_id}").display = visible
             except NoMatches:
                 pass
+        oauth_enabled = False
+        try:
+            oauth_enabled = http and str(self._settings_query_one("#mcp_oauth_select", Select).value) == "true"
+        except NoMatches:
+            pass
+        self._update_mcp_oauth_fields(oauth_enabled)
         try:
             url_input = self._settings_query_one("#mcp_url_input", Input)
             if transport == "streamable_http":
@@ -1621,7 +1675,8 @@ class SettingsPanelMixin(tui_app_base.KolegaAppBase):
         enabled = str(self._settings_query_one("#mcp_enabled_select", Select).value) == "true"
         url = self._settings_query_one("#mcp_url_input", Input).value.strip() or None
         headers_text = self._settings_query_one("#mcp_headers_input", Input).value.strip()
-        oauth_enabled = str(self._settings_query_one("#mcp_oauth_select", Select).value) == "true"
+        http = transport in {"streamable_http", "sse"}
+        oauth_enabled = http and str(self._settings_query_one("#mcp_oauth_select", Select).value) == "true"
         command = self._settings_query_one("#mcp_command_input", Input).value.strip() or None
         args_text = self._settings_query_one("#mcp_args_input", Input).value.strip()
         env_text = self._settings_query_one("#mcp_env_input", Input).value.strip()
@@ -1640,6 +1695,77 @@ class SettingsPanelMixin(tui_app_base.KolegaAppBase):
             else selected
         )
 
+        oauth_client_id = None
+        oauth_client_secret = None
+        oauth_client_secret_env = None
+        oauth_redirect_uri = None
+        oauth_scope = None
+        oauth_auth_method: Optional[Literal["client_secret_post", "client_secret_basic", "none"]] = None
+
+        if http:
+            try:
+                oauth_client_id = self._settings_query_one("#mcp_oauth_client_id_input", Input).value.strip() or None
+            except NoMatches:
+                pass
+            try:
+                oauth_client_secret = (
+                    self._settings_query_one("#mcp_oauth_client_secret_input", Input).value.strip() or None
+                )
+            except NoMatches:
+                pass
+            try:
+                oauth_client_secret_env = (
+                    self._settings_query_one("#mcp_oauth_client_secret_env_input", Input).value.strip() or None
+                )
+            except NoMatches:
+                pass
+            try:
+                oauth_redirect_uri = (
+                    self._settings_query_one("#mcp_oauth_redirect_uri_input", Input).value.strip() or None
+                )
+            except NoMatches:
+                pass
+            try:
+                oauth_scope = self._settings_query_one("#mcp_oauth_scope_input", Input).value.strip() or None
+            except NoMatches:
+                pass
+            try:
+                method_val = str(self._settings_query_one("#mcp_oauth_auth_method_select", Select).value)
+                if method_val in {"client_secret_post", "client_secret_basic", "none"}:
+                    oauth_auth_method = cast(Literal["client_secret_post", "client_secret_basic", "none"], method_val)
+            except NoMatches:
+                pass
+
+        client_name = "Kolega Code"
+        client_uri = None
+        client_metadata_url = None
+        timeout_seconds = 300.0
+        if selected != MCP_NEW_SERVER_VALUE:
+            try:
+                config = self._load_mcp_config_for_ui()
+                existing = config.servers.get(selected)
+                if existing:
+                    client_name = existing.oauth.client_name
+                    client_uri = existing.oauth.client_uri
+                    client_metadata_url = existing.oauth.client_metadata_url
+                    timeout_seconds = existing.oauth.timeout_seconds
+            except Exception:
+                pass
+
+        oauth = MCPOAuthConfig(
+            enabled=oauth_enabled,
+            client_id=oauth_client_id,
+            client_secret=oauth_client_secret,
+            client_secret_env=oauth_client_secret_env,
+            redirect_uri=oauth_redirect_uri,
+            scope=oauth_scope,
+            token_endpoint_auth_method=oauth_auth_method,
+            client_name=client_name,
+            client_uri=client_uri,
+            client_metadata_url=client_metadata_url,
+            timeout_seconds=timeout_seconds,
+        )
+
         return MCPServerConfig(
             id=server_id,
             name=name,
@@ -1647,7 +1773,7 @@ class SettingsPanelMixin(tui_app_base.KolegaAppBase):
             enabled=enabled,
             url=url,
             headers=headers,
-            oauth=MCPOAuthConfig(enabled=oauth_enabled),
+            oauth=oauth,
             command=command,
             args=args,
             env=env,

{kolega_code-0.35.1 → kolega_code-0.37.0}/kolega_code/cli/tui/settings_screen.py

@@ -588,6 +588,26 @@ class SettingsScreen(ModalScreen[None]):
                     allow_blank=False,
                     value="false",
                 )
+                yield Label("OAuth Client ID", id="mcp_oauth_client_id_label")
+                yield Input(id="mcp_oauth_client_id_input", placeholder="e.g. client_abc123")
+                yield Label("OAuth Client Secret", id="mcp_oauth_client_secret_label")
+                yield Input(id="mcp_oauth_client_secret_input", placeholder="optional direct secret", password=True)
+                yield Label("OAuth Client Secret Env Var", id="mcp_oauth_client_secret_env_label")
+                yield Input(id="mcp_oauth_client_secret_env_input", placeholder="e.g. HUBSPOT_MCP_CLIENT_SECRET")
+                yield Label("OAuth Redirect URI", id="mcp_oauth_redirect_uri_label")
+                yield Input(
+                    id="mcp_oauth_redirect_uri_input",
+                    placeholder="e.g. http://127.0.0.1:33418/callback (default: ephemeral port)",
+                )
+                yield Label("OAuth Scopes", id="mcp_oauth_scope_label")
+                yield Input(id="mcp_oauth_scope_input", placeholder="e.g. read write")
+                yield Label("OAuth Token Auth Method", id="mcp_oauth_auth_method_label")
+                yield Select(
+                    settings_panel.MCP_OAUTH_AUTH_METHOD_OPTIONS,
+                    id="mcp_oauth_auth_method_select",
+                    allow_blank=False,
+                    value="auto",
+                )
                 yield Label("Command", id="mcp_command_label")
                 yield Input(id="mcp_command_input", placeholder="npx")
                 yield Label("Arguments", id="mcp_args_label")

{kolega_code-0.35.1 → kolega_code-0.37.0}/kolega_code/gateway/bridge.py

@@ -18,7 +18,10 @@ turns:
   would surface above the latest text), and the messages persist as a trail
   of what the agent did during the turn;
 - text is chunked at the adapter's limit; the first chunk is the edited
-  message and overflow chunks are sent as continuations on finalize.
+  message and overflow chunks are sent as continuations on finalize;
+- a typing action is re-sent every few seconds for the whole turn (chat
+  platforms expire it after ~5s), so thinking and long tool runs keep
+  showing "typing…" until the reply lands.
 
 Chunk content is *incremental*, so the renderer appends and re-renders the
 accumulated text — it never replaces with the last segment.
@@ -39,6 +42,10 @@ logger = logging.getLogger(__name__)
 
 #: Cap on a round message's lines so a chatty turn cannot spam an unbounded edit.
 MAX_STATUS_LINES = 8
+#: Chat platforms expire a typing action after ~5 seconds (Telegram: "status
+#: is set for 5 seconds or less"); refresh slightly faster so the indicator
+#: never lapses while a turn is in progress.
+TYPING_REFRESH_SECONDS = 4.0
 #: Rendered status line: (icon, tool description, tool call id).
 StatusLine = tuple[str, str, str]
 
@@ -54,6 +61,7 @@ class TurnRenderer:
         event_queue: asyncio.Queue[AgentEvent],
         chunk_limit: Optional[int] = None,
         edit_throttle_seconds: float = 1.0,
+        typing_refresh_seconds: float = TYPING_REFRESH_SECONDS,
         monotonic: Any = time.monotonic,
     ) -> None:
         self._adapter = adapter
@@ -61,6 +69,7 @@ class TurnRenderer:
         self._events = event_queue
         self._chunk_limit = chunk_limit or adapter.capabilities.text_chunk_limit
         self._edit_throttle = edit_throttle_seconds
+        self._typing_refresh = typing_refresh_seconds
         self._monotonic = monotonic
         # Per-segment state, mirroring the TUI's stream fold: a segment is one
         # contiguous assistant response identified by its chunk uuid (the
@@ -92,10 +101,12 @@ class TurnRenderer:
         reply stays visible.
         """
         pump: Optional[asyncio.Task[None]] = None
+        typing: Optional[asyncio.Task[None]] = None
         if self._events is not None:
             pump = asyncio.create_task(self._event_pump(), name="gateway-turn-event-pump")
         try:
             await self._adapter.set_typing(self._chat_id, True)
+            typing = asyncio.create_task(self._typing_keepalive(), name="gateway-turn-typing")
             async for chunk in chunks:
                 if chunk.get("type") != "response":
                     # Thinking chunks stay off the wire; they are reasoning, not output.
@@ -121,14 +132,31 @@ class TurnRenderer:
             await self._finalize_segment()
             return self._total_text
         finally:
-            if pump is not None:
-                pump.cancel()
-                try:
-                    await pump
-                except asyncio.CancelledError:
-                    pass
+            for task in (pump, typing):
+                if task is not None:
+                    task.cancel()
+                    try:
+                        await task
+                    except asyncio.CancelledError:
+                        pass
             await self._adapter.set_typing(self._chat_id, False)
 
+    async def _typing_keepalive(self) -> None:
+        """Re-send the typing action so the indicator outlives its ~5s expiry.
+
+        Covers the silent stretches of a turn — model thinking before the
+        first chunk and long-running tool calls, where no message is sent or
+        edited. Refresh only (never hides: the ``False`` call is the
+        adapter's business); a failing adapter must not end the loop, since
+        typing is cosmetic.
+        """
+        while True:
+            await asyncio.sleep(self._typing_refresh)
+            try:
+                await self._adapter.set_typing(self._chat_id, True)
+            except Exception:  # noqa: BLE001 — typing indicators are cosmetic
+                logger.debug("gateway: typing refresh failed", exc_info=True)
+
     # -- Reply messages (one per response segment) -------------------------
 
     async def _finalize_segment(self) -> None:

{kolega_code-0.35.1 → kolega_code-0.37.0}/kolega_code/gateway/service.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 
 import os
 import plistlib
+import re
 import shlex
 import shutil
 import subprocess
@@ -214,6 +215,41 @@ def run_service_command(argv: list[str]) -> subprocess.CompletedProcess[str] | N
         return None
 
 
+def service_state_summary(
+    *,
+    systemd_dir: Optional[Path] = None,
+    launchd_dir: Optional[Path] = None,
+    platform: Optional[str] = None,
+) -> Optional[str]:
+    """One line of service-manager state for an installed gateway, else None.
+
+    ``gateway status`` uses this to explain a service that is installed but not
+    running, which the daemon's own status file cannot show.
+    """
+    platform = platform if platform is not None else sys.platform
+    if not is_service_installed(systemd_dir=systemd_dir, launchd_dir=launchd_dir, platform=platform):
+        return None
+    if platform == "darwin":
+        proc = run_service_command(["launchctl", "print", f"gui/{os.getuid()}/{LAUNCHD_LABEL}"])
+        if proc is None or proc.returncode != 0:
+            return "launchd agent installed but not loaded"
+        output = proc.stdout or ""
+        parts: list[str] = []
+        state = re.search(r"^\s*state = (.+)$", output, re.MULTILINE)
+        if state:
+            parts.append(f"state {state.group(1).strip()}")
+        runs = re.search(r"^\s*runs = (\d+)$", output, re.MULTILINE)
+        if runs:
+            parts.append(f"{runs.group(1)} starts")
+        last_exit = re.search(r"^\s*last exit code = (\d+)$", output, re.MULTILINE)
+        if last_exit:
+            parts.append(f"last exit code {last_exit.group(1)}")
+        return "launchd agent " + (", ".join(parts) if parts else "loaded")
+    proc = run_service_command(["systemctl", "--user", "is-active", SERVICE_NAME])
+    state_text = (proc.stdout or "").strip() if proc is not None else ""
+    return f"systemd unit {state_text or 'unknown'}"
+
+
 def restart_service(
     *,
     unit_path: Optional[Path] = None,